pi-proactive 0.2.0-beta.2 → 0.2.0-beta.3

package/node_modules/typebox/build/schema/resolve/resolve.mjs

@@ -1,67 +1,49 @@
+// deno-fmt-ignore-file
 import { Guard } from '../../guard/index.mjs';
 import { Pointer } from '../pointer/index.mjs';
 import * as Schema from '../types/index.mjs';
-import * as Stack from '../engine/_stack.mjs';
+export const DefaultBase = 'https://json-schema.org';
 // ------------------------------------------------------------------
-// Helpers
-//
-// Utilities to compute schema base URIs, normalize absolute URLs,
-// strip URL fragments for canonical hrefs, find target base URIs,
-// resolve $ref root schemas, and identify JSON pointers vs anchors.
-// ------------------------------------------------------------------
-function RelativeBase(schema, base) {
-    return Schema.IsSchemaObject(schema) && Schema.IsId(schema) ? Stack.NextUri(schema.$id, base.href) : base;
-}
-function AbsoluteBase(base) {
-    return Stack.NextUri(base, Stack.DefaultUri);
-}
-function CanonicalHref(url) {
-    return url.href.split('#')[0];
-}
-function Base(schema, base, target) {
-    return SearchBase(schema, AbsoluteBase(base), target);
-}
-function RefRoot(stack, ref) {
-    return (ref.$ref.startsWith('#') || stack.enteredResource) ? stack.lexicalSchema : stack.schema;
-}
-function IsPointerFragment(fragment) {
-    return fragment.startsWith('#/');
-}
-// ------------------------------------------------------------------
-// Search
-//
-// Recursive tree walks that locate things by identity, not URL.
-// SearchDynamicAnchor finds a node with a matching $dynamicAnchor.
-// SearchBase finds a specific target schema (by reference) and
-// returns its base URI, tracking $id rebasing as it descends.
+// Find: FindDynamicAnchor
 // ------------------------------------------------------------------
-function SearchDynamicAnchor(schema, name) {
+function FindDynamicAnchor(schema, name) {
     if (Guard.IsObject(schema) && Schema.IsDynamicAnchor(schema) && Guard.IsEqual(schema.$dynamicAnchor, name)) {
         return schema;
     }
     if (Guard.IsObject(schema)) {
         for (const key of Guard.Keys(schema)) {
-            const result = SearchDynamicAnchor(schema[key], name);
+            const result = FindDynamicAnchor(schema[key], name);
             if (result)
                 return result;
         }
     }
+    // (no-coverage) - is it even possible to search for an anchor
+    // with embedded logical schema like allOf, anyOf, etc?
+    // if (Guard.IsArray(schema)) { // (no-coverage)
+    //   for (const item of schema) {
+    //     const result = FindDynamicAnchor(item, name)
+    //     if (result) return result
+    //   }
+    // }
     return undefined;
 }
-function SearchBase(schema, base, target) {
+// ------------------------------------------------------------------
+// Find: FindBase
+// ------------------------------------------------------------------
+function FindBase(schema, base, target) {
     if (Guard.IsEqual(schema, target))
         return base.href;
-    const nextBase = RelativeBase(schema, base);
+    const nextBase = Schema.IsSchemaObject(schema) && Schema.IsId(schema) ? new URL(schema.$id, base.href) : base;
     if (Guard.IsArray(schema)) {
         for (const item of schema) {
-            const result = SearchBase(item, nextBase, target);
+            const result = FindBase(item, nextBase, target);
             if (!Guard.IsUndefined(result))
                 return result;
         }
     }
     else if (Guard.IsObject(schema)) {
         for (const key of Guard.Keys(schema)) {
-            const result = SearchBase(schema[key], nextBase, target);
+            const result = FindBase(schema[key], nextBase, target);
             if (!Guard.IsUndefined(result))
                 return result;
         }
@@ -69,263 +51,277 @@ function SearchBase(schema, base, target) {
     return undefined;
 }
 // ------------------------------------------------------------------
-// Match
-//
-// Tests whether a schema node is what a reference URL points to.
-// MatchSchemaObject checks a single node in order: $id, $anchor,
-// $dynamicAnchor, then JSON pointer/hash. MatchFromArray,
-// MatchFromObject, and Match recurse through the tree to try every
-// node, skipping const and enum since their values are user data,
-// not schema.
-// ------------------------------------------------------------------
-function MatchWithHash(schema, ref) {
-    if (ref.href.endsWith('#'))
-        return schema;
-    if (!ref.hash.startsWith('#'))
-        return undefined;
-    const fragment = decodeURIComponent(ref.hash.slice(1));
-    if (!fragment.startsWith('/'))
-        return undefined;
-    return Pointer.Get(schema, fragment);
-}
-function MatchWithId(schema, base, ref) {
-    if (!Schema.IsId(schema))
-        return undefined;
+// Match: MatchId
+// ------------------------------------------------------------------
+function MatchId(schema, base, ref) {
+    // ref is a bare fragment naming this schema's $id directly
     if (Guard.IsEqual(schema.$id, ref.hash))
         return schema;
     const absoluteRef = new URL(ref.href, base.href);
+    // ref shares this $id's document, so resolve the fragment within it
     if (Guard.IsEqual(base.pathname, absoluteRef.pathname))
-        return ref.hash.startsWith('#') ? MatchWithHash(schema, ref) : schema;
+        return ref.hash.startsWith('#') ? MatchHash(schema, ref) : schema;
     return undefined;
 }
-function MatchWithAnchor(schema, base, ref) {
-    if (!Schema.IsAnchor(schema))
-        return undefined;
+// ------------------------------------------------------------------
+// Match: MatchAnchor
+// ------------------------------------------------------------------
+function MatchAnchor(schema, base, ref) {
     const absoluteAnchor = new URL(`#${schema.$anchor}`, base.href);
     const absoluteRef = new URL(ref.href, base.href);
     return Guard.IsEqual(absoluteAnchor.href, absoluteRef.href) ? schema : undefined;
 }
-function MatchWithDynamicAnchor(schema, base, ref) {
-    if (!Schema.IsDynamicAnchor(schema))
-        return undefined;
+// ------------------------------------------------------------------
+// Match: MatchDynamicAnchor
+// ------------------------------------------------------------------
+function MatchDynamicAnchor(schema, base, ref) {
     const absoluteAnchor = new URL(`#${schema.$dynamicAnchor}`, base.href);
     const absoluteRef = new URL(ref.href, base.href);
     const isMatch = Guard.IsEqual(absoluteAnchor.href, absoluteRef.href);
     return isMatch ? schema : undefined;
 }
-function MatchSchemaObject(schema, base, ref) {
-    if (!Schema.IsSchemaObject(schema))
+// ------------------------------------------------------------------
+// Match: MatchHash
+// ------------------------------------------------------------------
+function MatchHash(schema, ref) {
+    if (ref.href.endsWith('#'))
+        return schema;
+    if (!ref.hash.startsWith('#'))
         return undefined;
-    return MatchWithId(schema, base, ref) ??
-        MatchWithAnchor(schema, base, ref) ??
-        MatchWithDynamicAnchor(schema, base, ref) ??
-        MatchWithHash(schema, ref);
-}
-function MatchFromArray(schema, base, ref) {
-    if (!Guard.IsArray(schema))
+    const fragment = decodeURIComponent(ref.hash.slice(1));
+    if (!fragment.startsWith('/'))
         return undefined;
+    const result = Pointer.Get(schema, fragment);
+    return result;
+}
+// ------------------------------------------------------------------
+// Match: Match
+// ------------------------------------------------------------------
+function Match(schema, base, ref) {
+    if (Schema.IsId(schema)) {
+        const result = MatchId(schema, base, ref);
+        if (!Guard.IsUndefined(result))
+            return result;
+    }
+    if (Schema.IsAnchor(schema)) {
+        const result = MatchAnchor(schema, base, ref);
+        if (!Guard.IsUndefined(result))
+            return result;
+    }
+    if (Schema.IsDynamicAnchor(schema)) {
+        const result = MatchDynamicAnchor(schema, base, ref);
+        if (!Guard.IsUndefined(result))
+            return result;
+    }
+    return MatchHash(schema, ref);
+}
+// ------------------------------------------------------------------
+// FromArray
+// ------------------------------------------------------------------
+function FromArray(schema, base, ref) {
     return schema.reduce((result, item) => {
-        const match = Match(item, base, ref);
+        const match = FromValue(item, base, ref);
         return !Guard.IsUndefined(match) ? match : result;
     }, undefined);
 }
-function MatchFromObject(schema, base, ref) {
-    if (!Guard.IsObject(schema))
-        return undefined;
+// ------------------------------------------------------------------
+// FromObject
+// ------------------------------------------------------------------
+function SkipProperty(key) {
+    return Guard.IsEqual(key, 'const') || Guard.IsEqual(key, 'enum');
+}
+function FromObject(schema, base, ref) {
     return Guard.Keys(schema).reduce((result, key) => {
-        if (Guard.IsEqual(key, 'const') || Guard.IsEqual(key, 'enum'))
+        if (SkipProperty(key))
             return result;
-        const match = Match(schema[key], base, ref);
+        const match = FromValue(schema[key], base, ref);
         return !Guard.IsUndefined(match) ? match : result;
     }, undefined);
 }
-function Match(schema, base, ref) {
-    const relativeBase = RelativeBase(schema, base);
-    return MatchSchemaObject(schema, relativeBase, ref) ??
-        MatchFromArray(schema, relativeBase, ref) ??
-        MatchFromObject(schema, relativeBase, ref);
+// ------------------------------------------------------------------
+// FromValue
+// ------------------------------------------------------------------
+function FromValue(schema, base, ref) {
+    const nextBase = Schema.IsSchemaObject(schema) && Schema.IsId(schema) ? new URL(schema.$id, base.href) : base;
+    if (Schema.IsSchemaObject(schema)) {
+        const result = Match(schema, nextBase, ref);
+        if (!Guard.IsUndefined(result))
+            return result;
+    }
+    if (Guard.IsArray(schema))
+        return FromArray(schema, nextBase, ref);
+    if (Guard.IsObject(schema))
+        return FromObject(schema, nextBase, ref);
+    return undefined;
+}
+// ------------------------------------------------------------------
+// Base
+// ------------------------------------------------------------------
+export function Base(schema, base, target) {
+    return FindBase(schema, new URL(base || '.', DefaultBase), target);
 }
 // ------------------------------------------------------------------
 // Resource
-//
-// Wraps RefInternal to check whether the resolved schema is itself
-// a resource root (carries its own $id). Used by FindResolvedResource
-// to tell a boundary hit from a landing inside a resource.
 // ------------------------------------------------------------------
-function Resource(context, schema, base, ref) {
-    const result = RefInternal(context, schema, base, ref);
+export function Resource(context, schema, base, ref) {
+    const result = Ref(context, schema, base, ref, false);
     return Schema.IsSchemaObject(result) && Schema.IsId(result) ? result : undefined;
 }
 // ------------------------------------------------------------------
-// FindDeferredResource
+// CanonicalHref
+// ------------------------------------------------------------------
+function CanonicalHref(url) {
+    return url.href.split('#')[0];
+}
+// ------------------------------------------------------------------
+// Ref: RefRemote (Phase 1)
+// ------------------------------------------------------------------
+function RefContext(context, ref) {
+    return Guard.HasPropertyKey(context, ref) ? context[ref] : undefined;
+}
+// ------------------------------------------------------------------
+// Ref: RefRemote (Phase 2)
+// ------------------------------------------------------------------
+function RefLocal(schema, base, ref) {
+    return FromValue(schema, base, ref);
+}
+// ------------------------------------------------------------------
+// Ref: RefRemote (Phase 3)
+// ------------------------------------------------------------------
+function RefRemote(context, base, ref) {
+    const canonicalHref = CanonicalHref(ref);
+    if (Guard.IsEqual(canonicalHref, CanonicalHref(base)))
+        return undefined;
+    if (!Guard.HasPropertyKey(context, canonicalHref))
+        return undefined;
+    const remoteSchema = context[canonicalHref];
+    const remoteBase = (Schema.IsSchemaObject(remoteSchema) && Schema.IsId(remoteSchema)) ? new URL(remoteSchema.$id, canonicalHref) : new URL(canonicalHref);
+    const result = Guard.IsEqual(ref.hash, '') ? remoteSchema : FromValue(remoteSchema, remoteBase, ref);
+    return result;
+}
+// ------------------------------------------------------------------
+// RetrievedResource: LegacyRetrievedResource
 //
-// Legacy Draft-4 schemas (no $schema keyword) treat a nested $id as
-// an in-place base change, not a new resource. A local ('#...') ref
-// landing at a different base than the current one needs a stack
-// entry so later lookups use the right base.
+// Draft-4 style schemas (no $schema keyword) treat a nested $id as an
+// in-place base URI change rather than a new resource boundary. A
+// local ('#...') ref that lands somewhere with a different base than
+// the current reference base needs a frame so later anchor/pointer
+// resolution is computed against the right base.
 // ------------------------------------------------------------------
-function FindDeferredResourceLegacy(stack, ref, schema) {
+function LegacyRetrievedResource(root, lexicalSchema, referenceBase, ref, schema) {
     if (!ref.$ref.startsWith('#'))
         return undefined;
-    if (!Schema.IsSchemaObject(stack.schema) || Guard.HasPropertyKey(stack.schema, '$schema'))
+    if (Guard.HasPropertyKey(root, '$schema'))
         return undefined;
-    const targetBase = Base(stack.lexicalSchema, stack.referenceBase, schema);
-    if (Guard.IsUndefined(targetBase) || Guard.IsEqual(targetBase, stack.referenceBase))
+    const targetBase = Base(lexicalSchema, referenceBase, schema);
+    if (Guard.IsUndefined(targetBase) || Guard.IsEqual(targetBase, referenceBase))
         return undefined;
-    return { target: schema, base: targetBase, root: /* safe-object-root */ stack.lexicalSchema };
+    return { target: schema, base: targetBase, root: lexicalSchema };
 }
-function FindDeferredResourceModern(stack, canonical, schema) {
-    const remoteRoot = stack.context[canonical];
+// ------------------------------------------------------------------
+// RetrievedResource: RemoteRetrievedResource
+//
+// The ref's canonical URL names a document already loaded into
+// context. That document becomes the frame's root going forward.
+// ------------------------------------------------------------------
+function RemoteRetrievedResource(context, canonical, schema) {
+    const remoteRoot = context[canonical];
     if (!Schema.IsSchemaObject(remoteRoot))
         return undefined;
     return { target: schema, base: canonical, root: remoteRoot };
 }
-function FindDeferredResource(stack, ref, schema, canonical, isRemote) {
-    const remote = isRemote ? FindDeferredResourceModern(stack, canonical, schema) : undefined;
-    return Guard.IsUndefined(remote) ? FindDeferredResourceLegacy(stack, ref, schema) : remote;
+// ------------------------------------------------------------------
+// RetrievedResource
+//
+// A genuinely remote document frame always wins over a same-document
+// legacy one: only one frame is ever entered per ref.
+// ------------------------------------------------------------------
+function FindRetrievedResource(stackframe, ref, schema, canonical, isRemote) {
+    const remote = isRemote ? RemoteRetrievedResource(stackframe.context, canonical, schema) : undefined;
+    if (!Guard.IsUndefined(remote))
+        return remote;
+    return LegacyRetrievedResource(stackframe.root, stackframe.lexicalSchema, stackframe.referenceBase, ref, schema);
 }
 // ------------------------------------------------------------------
-// FindResolvedResource
+// ResolvedResource: FindResolvedResource
 //
-// Handles a ref that crossed into a different resource but landed
-// on a schema without that resource's $id (e.g. a pointer into the
-// middle of a remote document). Enters the enclosing resource so
-// lexical/base lookups behave as if traversal walked in from its top.
+// The ref crossed into a different resource but landed on a schema
+// that doesn't itself carry that resource's $id (e.g. a pointer into
+// the middle of a remote document). The enclosing resource still
+// needs to be entered so lexical/base lookups behave as if traversal
+// had walked in from its top.
 // ------------------------------------------------------------------
-function FindResolvedResource(stack, canonical, schema) {
+function FindResolvedResource(context, root, referenceBase, canonical, schema, ids) {
     if (Schema.IsId(schema))
         return undefined;
-    const resource = Resource(stack.context, /* safe-object-root */ stack.schema, stack.referenceBase, canonical);
-    if (!resource || stack.ids.includes(resource))
+    const resource = Resource(context, root, referenceBase, canonical);
+    if (!resource || ids.includes(resource))
         return undefined;
-    return { resource };
+    return { target: schema, resource };
 }
 // ------------------------------------------------------------------
-// RefInternal
-//
-// Shared lookup used by Ref, RecursiveRef, and DynamicRef. Tries,
-// in order: exact match in the pre-registered context, then a local
-// search within the given schema, then a search in a remote
-// document. Returns just the schema; caller-specific bookkeeping
-// (deferred/resolved resources) happens one level up.
+// Ref
 // ------------------------------------------------------------------
-function RefInternalWithContext(context, ref) {
-    return Guard.HasPropertyKey(context, ref) ? context[ref] : undefined;
-}
-function RefInternalWithLocal(schema, base, ref) {
-    return Match(schema, base, ref);
-}
-function RefInternalWithRemote(context, base, ref) {
-    const canonicalHref = CanonicalHref(ref);
-    if (!Guard.HasPropertyKey(context, canonicalHref) || Guard.IsEqual(canonicalHref, CanonicalHref(base)))
-        return undefined;
-    const remoteSchema = context[canonicalHref];
-    const remoteBase = RelativeBase(remoteSchema, new URL(canonicalHref));
-    return Guard.IsEqual(ref.hash, '') ? remoteSchema : Match(remoteSchema, remoteBase, ref);
-}
-function RefInternal(context, schema, base, ref) {
-    const absoluteBase = AbsoluteBase(base);
-    const target = Stack.NextUri(ref, absoluteBase.href);
-    return RefInternalWithContext(context, ref) ??
-        RefInternalWithLocal(schema, absoluteBase, target) ??
-        RefInternalWithRemote(context, absoluteBase, target);
+export function Ref(remotes, schema, base, ref, applySchemaId = true) {
+    const initialBase = new URL(base || '.', DefaultBase);
+    const resolvedBase = applySchemaId && Schema.IsId(schema) ? new URL(schema.$id, initialBase) : initialBase;
+    const initialRef = new URL(ref, resolvedBase.href);
+    return RefContext(remotes, ref) ?? RefLocal(schema, resolvedBase, initialRef) ?? RefRemote(remotes, resolvedBase, initialRef);
 }
 // ------------------------------------------------------------------
-// RefNextStack
-//
-// Computes the next stack state from any deferred or resolved
-// resource found while following a $ref, carrying existing stack
-// state forward rather than rebuilding it.
-// ------------------------------------------------------------------
-function RefNextStackDeferred(stack, deferredResource) {
-    if (!deferredResource)
-        return stack;
-    const resourceEntries = new Map(stack.resourceEntries);
-    resourceEntries.set(deferredResource.target, { base: deferredResource.base, root: deferredResource.root });
-    return { ...stack, resourceEntries };
-}
-function RefNextStackResolved(stack, resolvedResource) {
-    return resolvedResource ? Stack.NextStack(stack, resolvedResource.resource) : stack;
-}
-function RefNextStack(stack, pendingResource, deferredResource, resolvedResource) {
-    const withDeferred = RefNextStackDeferred({ ...stack, pendingResource }, deferredResource);
-    const withResolved = RefNextStackResolved(withDeferred, resolvedResource);
-    return withResolved;
-}
+// DynamicRef
 // ------------------------------------------------------------------
-// RefResult
-//
-// Builds the final XRefResult. RefResultFound gets the canonical
-// URL, checks if it's remote from the current resource, and looks
-// for a deferred or resolved resource crossing accordingly.
-// RefResultNotFound just advances pendingResource if a schema was
-// found without crossing into a resource.
-// ------------------------------------------------------------------
-function RefResultFound(stack, ref, schema) {
-    const canonical = CanonicalHref(Stack.NextUri(ref.$ref, stack.referenceBase));
-    const isRemote = !Guard.IsEqual(canonical, stack.resourceBase);
-    const deferredResource = FindDeferredResource(stack, ref, schema, canonical, isRemote);
-    const resolvedResource = isRemote ? FindResolvedResource(stack, canonical, schema) : undefined;
-    return { schema, stack: RefNextStack(stack, true, deferredResource, resolvedResource) };
-}
-function RefResultNotFound(stack, schema) {
-    return { schema, stack: RefNextStack(stack, !Guard.IsUndefined(schema)) };
+export function DynamicRef(context, root, base, schema, dynamicRef, dynamicAnchors) {
+    const initialBase = new URL(base || '.', DefaultBase);
+    const fragmentRoot = dynamicRef.$dynamicRef.startsWith('#') ? schema : root;
+    const fragmentTarget = Ref(context, fragmentRoot, base, dynamicRef.$dynamicRef, false);
+    if (Guard.IsUndefined(fragmentTarget)) {
+        const fragment = new URL(dynamicRef.$dynamicRef, initialBase).hash;
+        if (!fragment.startsWith('#/') && fragment.startsWith('#')) {
+            const name = decodeURIComponent(fragment.slice(1));
+            const anchorTarget = dynamicAnchors.find((anchor) => Guard.IsEqual(anchor.$dynamicAnchor, name)) ?? FindDynamicAnchor(root, name);
+            return anchorTarget;
+        }
+        return undefined;
+    }
+    if (!Schema.IsSchemaObject(fragmentTarget) || !Schema.IsDynamicAnchor(fragmentTarget))
+        return fragmentTarget;
+    const fragment = new URL(dynamicRef.$dynamicRef, initialBase).hash;
+    if (fragment.startsWith('#/'))
+        return fragmentTarget;
+    const anchorTarget = dynamicAnchors.find((anchor) => Guard.IsEqual(anchor.$dynamicAnchor, fragmentTarget.$dynamicAnchor));
+    return anchorTarget ?? fragmentTarget;
 }
 // ------------------------------------------------------------------
-// Ref
+// ResolveRef
 //
-// Picks the root to resolve against, and returns a XRefResult
-// containing the resolved schema and the next stack state for
-// subsequent evaluation.
+// Resolves the schema a $ref points to, and describes whether that
+// crossing implies a "retrieved resource" frame or entering a
+// resource the target doesn't itself carry the $id for. The caller
+// decides whether and how to record these.
 // ------------------------------------------------------------------
-export function Ref(stack, ref) {
-    const schema = RefInternal(stack.context, RefRoot(stack, ref), stack.referenceBase, ref.$ref);
-    return Schema.IsSchemaObject(schema) ? RefResultFound(stack, ref, schema) : RefResultNotFound(stack, schema);
+export function ResolveRef(stackframe, ref) {
+    const source = stackframe.inRetrievedFrame ? stackframe.lexicalSchema : stackframe.root;
+    const refRoot = ref.$ref.startsWith('#') ? stackframe.lexicalSchema : source;
+    const schema = Ref(stackframe.context, refRoot, stackframe.referenceBase, ref.$ref, false);
+    if (!schema || !Schema.IsSchemaObject(schema))
+        return { schema };
+    const canonical = new URL(ref.$ref, stackframe.referenceBase).href.split('#')[0];
+    const isRemote = !Guard.IsEqual(canonical, stackframe.resourceBase);
+    const retrievedResource = FindRetrievedResource(stackframe, ref, schema, canonical, isRemote);
+    const resolvedResource = isRemote ? FindResolvedResource(stackframe.context, stackframe.root, stackframe.referenceBase, canonical, schema, stackframe.ids) : undefined;
+    return { schema, retrievedResource, resolvedResource };
 }
 // ------------------------------------------------------------------
-// RecursiveRef: Draft 2019-09
-//
-// If a $recursiveAnchor is active in scope, it's used as the root
-// instead of the lexical schema, letting the ref bind to the
-// outermost applicable schema rather than the innermost.
+// ResolveRecursiveRef
 // ------------------------------------------------------------------
-function IsRecursiveAnchorInScope(stack) {
-    return Schema.IsSchemaObject(stack.lexicalSchema) && Schema.IsRecursiveAnchorTrue(stack.lexicalSchema);
-}
-export function RecursiveRef(stack, recursiveRef) {
-    const schema = IsRecursiveAnchorInScope(stack) ? stack.recursiveAnchor : stack.lexicalSchema;
-    return RefInternal(stack.context, schema, stack.lexicalBase, recursiveRef.$recursiveRef);
+export function ResolveRecursiveRef(stackframe, recursiveRef) {
+    const refRoot = Schema.IsRecursiveAnchorTrue(stackframe.lexicalSchema) ? stackframe.recursiveAnchors[0] : stackframe.lexicalSchema;
+    return Ref(stackframe.context, refRoot, stackframe.lexicalBase, recursiveRef.$recursiveRef, false);
 }
 // ------------------------------------------------------------------
-// DynamicRef: Draft 2020-12
-//
-// FindScopedDynamicAnchor checks anchors tracked on the stack first,
-// then falls back to a full tree search. If RefInternal finds a target
-// directly, DynamicRefWhenFound only continues the scoped search when
-// that target itself has a $dynamicAnchor. If RefInternal finds nothing,
-// DynamicRefWhenNotFound goes straight to a scoped anchor search
-// by name.
-// ------------------------------------------------------------------
-function DynamicRefFragment(stack, dynamicRef) {
-    return Stack.NextUri(dynamicRef.$dynamicRef, AbsoluteBase(stack.lexicalBase).href).hash;
-}
-function FindScopedDynamicAnchor(stack, name) {
-    return stack.dynamicAnchors.find((anchor) => Guard.IsEqual(anchor.$dynamicAnchor, name)) ?? SearchDynamicAnchor(stack.schema, name);
-}
-function DynamicRefWhenFound(stack, dynamicRef, fragmentTarget) {
-    if (!Schema.IsSchemaObject(fragmentTarget) || !Schema.IsDynamicAnchor(fragmentTarget))
-        return fragmentTarget;
-    const fragment = DynamicRefFragment(stack, dynamicRef);
-    return IsPointerFragment(fragment) ? fragmentTarget : FindScopedDynamicAnchor(stack, fragmentTarget.$dynamicAnchor);
-}
-function DynamicRefWhenNotFound(stack, dynamicRef) {
-    const fragment = DynamicRefFragment(stack, dynamicRef);
-    // (review): We never observe this condition, but should be able to reach here in coverage.
-    // if (IsPointerFragment(fragment) || !fragment.startsWith('#')) return undefined
-    return FindScopedDynamicAnchor(stack, decodeURIComponent(fragment.slice(1)));
-}
-export function DynamicRef(stack, dynamicRef) {
-    const fragmentRoot = dynamicRef.$dynamicRef.startsWith('#') ? stack.lexicalSchema : stack.schema;
-    const fragmentTarget = RefInternal(stack.context, fragmentRoot, stack.lexicalBase, dynamicRef.$dynamicRef);
-    return Guard.IsUndefined(fragmentTarget) ? DynamicRefWhenNotFound(stack, dynamicRef) : DynamicRefWhenFound(stack, dynamicRef, fragmentTarget);
+// ResolveDynamicRef
+// ------------------------------------------------------------------
+export function ResolveDynamicRef(stackframe, dynamicRef) {
+    return DynamicRef(stackframe.context, stackframe.root, stackframe.lexicalBase, stackframe.lexicalSchema, dynamicRef, stackframe.dynamicAnchors);
 }

package/node_modules/typebox/build/schema/schema.d.mts

@@ -1,6 +1,5 @@
 export * from './engine/index.mjs';
 export * from './intern/index.mjs';
-export * from './meta/index.mjs';
 export * from './pointer/index.mjs';
 export * from './resolve/index.mjs';
 export * from './static/index.mjs';

package/node_modules/typebox/build/schema/schema.mjs

@@ -1,6 +1,5 @@
 export * from './engine/index.mjs';
 export * from './intern/index.mjs';
-export * from './meta/index.mjs';
 export * from './pointer/index.mjs';
 export * from './resolve/index.mjs';
 export * from './static/index.mjs';