Add information about schema uri for reference

Author: OptimumCode

src/commonMain/kotlin/io/github/optimumcode/json/schema/internal/RecursiveRefSchemaAssertion.kt

@@ -16,7 +16,7 @@ internal class RecursiveRefSchemaAssertion(
     errorCollector: ErrorCollector,
   ): Boolean {
     return context.getRecursiveRoot()?.validate(element, context, errorCollector) ?: run {
-      val (refIdPath, refAssertion) = context.referenceResolver.dynamicRef(refId)
+      val (refIdPath, refAssertion, _) = context.referenceResolver.dynamicRef(refId)
       refAssertion.validate(element, context) {
         errorCollector.onError(
           it.copy(

src/commonMain/kotlin/io/github/optimumcode/json/schema/internal/RefSchemaAssertion.kt

@@ -20,8 +20,8 @@ internal class RefSchemaAssertion(
   ): Boolean {
     if (!::refAssertion.isInitialized) {
       val resolved = context.referenceResolver.ref(refId)
-      refIdPath = resolved.first
-      refAssertion = resolved.second
+      refIdPath = resolved.schemaPath
+      refAssertion = resolved.assertion
     }
     return refAssertion.validate(element, context) {
       errorCollector.onError(

src/commonMain/kotlin/io/github/optimumcode/json/schema/internal/ReferenceResolver.kt

@@ -5,24 +5,36 @@ import io.github.optimumcode.json.pointer.JsonPointer
 import io.github.optimumcode.json.pointer.internal.length
 
 internal interface ReferenceResolver {
-  fun ref(refId: RefId): Pair<JsonPointer, JsonSchemaAssertion>
+  fun ref(refId: RefId): ReferenceHolder
 
-  fun dynamicRef(refId: RefId): Pair<JsonPointer, JsonSchemaAssertion>
+  fun dynamicRef(refId: RefId): ReferenceHolder
+}
+
+internal class ReferenceHolder(
+  val schemaPath: JsonPointer,
+  val assertion: JsonSchemaAssertion,
+  val scopeId: Uri,
+) {
+  operator fun component1(): JsonPointer = schemaPath
+
+  operator fun component2(): JsonSchemaAssertion = assertion
+
+  operator fun component3(): Uri = scopeId
 }
 
 internal class DefaultReferenceResolver(
   private val references: Map<RefId, AssertionWithPath>,
   private val schemaPathsStack: ArrayDeque<Pair<JsonPointer, Uri>> = ArrayDeque(),
 ) : ReferenceResolver {
-  override fun ref(refId: RefId): Pair<JsonPointer, JsonSchemaAssertion> {
+  override fun ref(refId: RefId): ReferenceHolder {
     val resolvedRef = requireNotNull(references[refId]) { "$refId is not found" }
-    return resolvedRef.schemaPath to resolvedRef.assertion
+    return resolvedRef.toRefHolder()
   }
 
-  override fun dynamicRef(refId: RefId): Pair<JsonPointer, JsonSchemaAssertion> {
+  override fun dynamicRef(refId: RefId): ReferenceHolder {
     val originalRef = requireNotNull(references[refId]) { "$refId is not found" }
     if (!originalRef.dynamic) {
-      return originalRef.schemaPath to originalRef.assertion
+      return originalRef.toRefHolder()
     }
 
     val fragment = refId.fragment
@@ -39,7 +51,7 @@ internal class DefaultReferenceResolver(
       }
         // If no outer anchor found use the original ref
         ?: originalRef
-    return resolvedDynamicRef.schemaPath to resolvedDynamicRef.assertion
+    return resolvedDynamicRef.toRefHolder()
   }
 
   fun pushSchemaPath(
@@ -52,4 +64,11 @@ internal class DefaultReferenceResolver(
   fun popSchemaPath() {
     schemaPathsStack.removeLast()
   }
+
+  private fun AssertionWithPath.toRefHolder(): ReferenceHolder =
+    ReferenceHolder(
+      schemaPath = schemaPath,
+      assertion = assertion,
+      scopeId = scopeId,
+    )
 }