@depup/typebox 1.3.27-depup.0 → 1.3.34-depup.0

package/build/schema/intern/intern.mjs

@@ -1,13 +1,9 @@
+import { Arguments } from '../../system/arguments/index.mjs';
 import { Hashing, Memory } from '../../system/index.mjs';
+import * as Schema from '../types/index.mjs';
+import * as Stack from '../engine/_stack.mjs';
 import { Guard } from '../../guard/index.mjs';
 import { Resolve } from '../resolve/index.mjs';
-import * as S from '../types/index.mjs';
-// ----------------------------------------------------------------
-// UnsupportedKeyword
-// ----------------------------------------------------------------
-function UnsupportedKeyword(keyword) {
-    throw Error(`UnsupportedKeyword '${keyword}'`);
-}
 // ----------------------------------------------------------------
 // UnresolvableRef
 // ----------------------------------------------------------------
@@ -72,7 +68,7 @@ function FromIf(context, schema) {
 // Items
 // ----------------------------------------------------------------
 function FromItems(context, schema) {
-    return S.IsItemsSized(schema) ? FromItemsSized(context, schema) : FromItemsUnsized(context, schema);
+    return Schema.IsItemsSized(schema) ? FromItemsSized(context, schema) : FromItemsUnsized(context, schema);
 }
 // ----------------------------------------------------------------
 // ItemsSized
@@ -125,21 +121,59 @@ function FromPropertyNames(context, schema) {
 // ----------------------------------------------------------------
 // Ref
 // ----------------------------------------------------------------
-function ResolveRef(context, schema, ref) {
-    return Resolve.Ref(context, schema, Resolve.DefaultBase, ref) ?? UnresolvableRef(ref);
+function ResolveRef(stack, ref) {
+    const result = Resolve.Ref(stack, { $ref: ref });
+    return { schema: result.schema ?? UnresolvableRef(ref), stack: result.stack };
 }
-function FromRef(context, schema) {
-    // Resolve target
-    const target = ResolveRef(context.context, context.schema, schema.$ref);
-    // Check if target is resolving, if not, resolve
+// ----------------------------------------------------------------
+// DynamicRef
+// ----------------------------------------------------------------
+function ResolveDynamicRef(stack, schema) {
+    return Resolve.DynamicRef(stack, schema) ?? UnresolvableRef(schema.$dynamicRef);
+}
+// ----------------------------------------------------------------
+// RecursiveRef
+// ----------------------------------------------------------------
+function ResolveRecursiveRef(stack, schema) {
+    return Resolve.RecursiveRef(stack, schema) ?? UnresolvableRef(schema.$recursiveRef);
+}
+// ----------------------------------------------------------------
+// FromResolvedRef (shared logic for Ref, DynamicRef, RecursiveRef)
+// ----------------------------------------------------------------
+function FromResolvedRef(context, target, nextStack) {
+    const nextContext = { ...context, stack: nextStack };
     const resolving = context.resolving.get(target);
     if (Guard.IsUndefined(resolving))
-        return FromSchema(context, target);
+        return FromSchema(nextContext, target);
     // Target is mid-intern, so this is a cycle (point at its reserved placeholder)
     resolving.used = true;
     return { $ref: `#/$defs/${resolving.key}` };
 }
 // ----------------------------------------------------------------
+// FromRef
+// ----------------------------------------------------------------
+function FromRef(context, schema) {
+    // Resolve target off the current traversal stack, carrying forward any resource crossing
+    const { schema: target, stack } = ResolveRef(context.stack, schema.$ref);
+    return FromResolvedRef(context, target, stack);
+}
+// ----------------------------------------------------------------
+// FromDynamicRef
+// ----------------------------------------------------------------
+function FromDynamicRef(context, schema) {
+    // Resolve target off the current traversal stack (dynamic scope depends on anchors seen so far)
+    const target = ResolveDynamicRef(context.stack, schema);
+    return FromResolvedRef(context, target, { ...context.stack, pendingResource: true });
+}
+// ----------------------------------------------------------------
+// FromRecursiveRef
+// ----------------------------------------------------------------
+function FromRecursiveRef(context, schema) {
+    // Resolve target off the current traversal stack (recursive scope depends on the path taken so far)
+    const target = ResolveRecursiveRef(context.stack, schema);
+    return FromResolvedRef(context, target, { ...context.stack, pendingResource: true });
+}
+// ----------------------------------------------------------------
 // Then
 // ----------------------------------------------------------------
 function FromThen(context, schema) {
@@ -161,46 +195,45 @@ function FromUnevaluatedProperties(context, schema) {
 // SchemaObject
 // ----------------------------------------------------------------
 function FromSchemaObject(context, schema) {
-    // Reference schemas cannot contain other keywords
-    if (S.IsRef(schema))
+    // Reference-style schemas resolve to another node and cannot contain other keywords
+    if (Schema.IsRef(schema))
         return FromRef(context, schema);
+    if (Schema.IsDynamicRef(schema))
+        return FromDynamicRef(context, schema);
+    if (Schema.IsRecursiveRef(schema))
+        return FromRecursiveRef(context, schema);
     // Check if the schema has already been resolved
     const existing = resolved.get(schema);
     if (!Guard.IsUndefined(existing))
         return existing;
-    // These keywords are unsupported
-    if (S.IsDynamicRef(schema))
-        UnsupportedKeyword('$dynamicRef');
-    if (S.IsRecursiveRef(schema))
-        UnsupportedKeyword('$recursiveRef');
     // Reserve a placeholder key in case a nested ref cycles back to this schema
     const reservation = { key: `x-ref-${context.resolving.size}`, used: false };
     context.resolving.set(schema, reservation);
     // Intern each subschema
     const remapped = {
-        ...(S.IsRefine(schema) ? { ['~refine']: schema['~refine'] } : {}),
-        ...(S.IsAdditionalItems(schema) ? { additionalItems: FromAdditionalItems(context, schema) } : {}),
-        ...(S.IsAdditionalProperties(schema) ? { additionalProperties: FromAdditionalProperties(context, schema) } : {}),
-        ...(S.IsAllOf(schema) ? { allOf: FromAllOf(context, schema) } : {}),
-        ...(S.IsAnyOf(schema) ? { anyOf: FromAnyOf(context, schema) } : {}),
-        ...(S.IsContains(schema) ? { contains: FromContains(context, schema) } : {}),
-        ...(S.IsDependentSchemas(schema) ? { dependentSchemas: FromDependentSchemas(context, schema) } : {}),
-        ...(S.IsElse(schema) ? { else: FromElse(context, schema) } : {}),
-        ...(S.IsIf(schema) ? { if: FromIf(context, schema) } : {}),
-        ...(S.IsItems(schema) ? { items: FromItems(context, schema) } : {}),
-        ...(S.IsNot(schema) ? { not: FromNot(context, schema) } : {}),
-        ...(S.IsOneOf(schema) ? { oneOf: FromOneOf(context, schema) } : {}),
-        ...(S.IsPatternProperties(schema) ? { patternProperties: FromPatternProperties(context, schema) } : {}),
-        ...(S.IsPrefixItems(schema) ? { prefixItems: FromPrefixItems(context, schema) } : {}),
-        ...(S.IsProperties(schema) ? { properties: FromProperties(context, schema) } : {}),
-        ...(S.IsPropertyNames(schema) ? { propertyNames: FromPropertyNames(context, schema) } : {}),
-        ...(S.IsThen(schema) ? { then: FromThen(context, schema) } : {}),
-        ...(S.IsUnevaluatedItems(schema) ? { unevaluatedItems: FromUnevaluatedItems(context, schema) } : {}),
-        ...(S.IsUnevaluatedProperties(schema) ? { unevaluatedProperties: FromUnevaluatedProperties(context, schema) } : {})
+        ...(Schema.IsRefine(schema) ? { ['~refine']: schema['~refine'] } : {}),
+        ...(Schema.IsAdditionalItems(schema) ? { additionalItems: FromAdditionalItems(context, schema) } : {}),
+        ...(Schema.IsAdditionalProperties(schema) ? { additionalProperties: FromAdditionalProperties(context, schema) } : {}),
+        ...(Schema.IsAllOf(schema) ? { allOf: FromAllOf(context, schema) } : {}),
+        ...(Schema.IsAnyOf(schema) ? { anyOf: FromAnyOf(context, schema) } : {}),
+        ...(Schema.IsContains(schema) ? { contains: FromContains(context, schema) } : {}),
+        ...(Schema.IsDependentSchemas(schema) ? { dependentSchemas: FromDependentSchemas(context, schema) } : {}),
+        ...(Schema.IsElse(schema) ? { else: FromElse(context, schema) } : {}),
+        ...(Schema.IsIf(schema) ? { if: FromIf(context, schema) } : {}),
+        ...(Schema.IsItems(schema) ? { items: FromItems(context, schema) } : {}),
+        ...(Schema.IsNot(schema) ? { not: FromNot(context, schema) } : {}),
+        ...(Schema.IsOneOf(schema) ? { oneOf: FromOneOf(context, schema) } : {}),
+        ...(Schema.IsPatternProperties(schema) ? { patternProperties: FromPatternProperties(context, schema) } : {}),
+        ...(Schema.IsPrefixItems(schema) ? { prefixItems: FromPrefixItems(context, schema) } : {}),
+        ...(Schema.IsProperties(schema) ? { properties: FromProperties(context, schema) } : {}),
+        ...(Schema.IsPropertyNames(schema) ? { propertyNames: FromPropertyNames(context, schema) } : {}),
+        ...(Schema.IsThen(schema) ? { then: FromThen(context, schema) } : {}),
+        ...(Schema.IsUnevaluatedItems(schema) ? { unevaluatedItems: FromUnevaluatedItems(context, schema) } : {}),
+        ...(Schema.IsUnevaluatedProperties(schema) ? { unevaluatedProperties: FromUnevaluatedProperties(context, schema) } : {})
     };
     context.resolving.delete(schema);
-    // Finalize and register the result
-    const interned = Memory.Discard(Memory.Assign(schema, remapped), ['$id']);
+    // Discard resolution keywords and finalize the interned schema
+    const interned = Memory.Discard(Memory.Assign(schema, remapped), ['$id', '$defs', '$anchor', '$dynamicAnchor', '$recursionAnchor']);
     const key = reservation.used ? reservation.key : HashKey(interned);
     registry.set(key, interned);
     // Result
@@ -224,7 +257,8 @@ function FromSchemaBoolean(_context, schema) {
 // Schema
 // ----------------------------------------------------------------
 function FromSchema(context, schema) {
-    return S.IsSchemaBoolean(schema) ? FromSchemaBoolean(context, schema) : FromSchemaObject(context, schema);
+    const next = { ...context, stack: Stack.NextStack(context.stack, schema) };
+    return Schema.IsSchemaBoolean(schema) ? FromSchemaBoolean(next, schema) : FromSchemaObject(next, schema);
 }
 // ----------------------------------------------------------------
 // BooleanEntry
@@ -238,22 +272,22 @@ function BooleanEntry(schema) {
 // ----------------------------------------------------------------
 const registry = new Map();
 const resolved = new Map();
-/**
- * [Experimental] Performs a Common Subexpression Elimination (CSE) transform on the given
- * schema. This function restructures the schema such that each distinct sub-schema is stored
- * exactly once in a $defs object and keyed by content hash. This function can be used to
- * both compress and optimize schemas prior to compilation.
- */
-export function Intern(schema) {
+/** (Experimental) This function restructures the schema such that each distinct sub-schema is stored exactly once in a $defs object and keyed by content hash. */
+export function Intern(...args) {
+    const [context, schema] = Arguments.Match(args, {
+        2: (context, schema) => [context, schema],
+        1: (schema) => [{}, schema]
+    });
     registry.clear();
     resolved.clear();
-    if (S.IsSchemaBoolean(schema))
+    if (Schema.IsSchemaBoolean(schema))
         return BooleanEntry(schema);
-    const context = S.IsDefs(schema) ? schema.$defs : {};
-    const entry = S.IsRef(schema) ? ResolveRef(context, schema, schema.$ref) : schema;
-    if (S.IsSchemaBoolean(entry))
+    const defs = Schema.IsDefs(schema) ? schema.$defs : {};
+    const rootStack = Stack.Stack({ ...context, ...defs }, schema);
+    const { schema: entry, stack } = Schema.IsRef(schema) ? ResolveRef(Stack.NextStack(rootStack, schema), schema.$ref) : { schema, stack: rootStack };
+    if (Schema.IsSchemaBoolean(entry))
         return BooleanEntry(entry);
-    const ref_context = { schema, context, resolving: new Map() };
+    const ref_context = { stack, resolving: new Map() };
     const result = FromSchema(ref_context, entry);
     return { $ref: result.$ref, $defs: Object.fromEntries(registry) };
 }

package/build/schema/meta/draft_2019_09.d.mts

@@ -0,0 +1,2 @@
+import type { XMetaSchemaObject } from './schema.mjs';
+export declare const Draft_2019_09: XMetaSchemaObject;

package/build/schema/meta/draft_2019_09.mjs

@@ -0,0 +1,288 @@
+export const Draft_2019_09 = {
+    '$schema': 'https://json-schema.org/draft/2019-09/schema',
+    '$id': 'https://json-schema.org/draft/2019-09/schema',
+    '$vocabulary': {
+        'https://json-schema.org/draft/2019-09/vocab/core': true,
+        'https://json-schema.org/draft/2019-09/vocab/applicator': true,
+        'https://json-schema.org/draft/2019-09/vocab/validation': true,
+        'https://json-schema.org/draft/2019-09/vocab/meta-data': true,
+        'https://json-schema.org/draft/2019-09/vocab/format': false,
+        'https://json-schema.org/draft/2019-09/vocab/content': true
+    },
+    '$recursiveAnchor': true,
+    'title': 'Core and Validation specifications meta-schema',
+    'allOf': [
+        {
+            '$schema': 'https://json-schema.org/draft/2019-09/schema',
+            '$id': 'https://json-schema.org/draft/2019-09/meta/core',
+            '$recursiveAnchor': true,
+            'title': 'Core vocabulary meta-schema',
+            'type': ['object', 'boolean'],
+            'properties': {
+                '$id': {
+                    'type': 'string',
+                    'format': 'uri-reference',
+                    '$comment': 'Non-empty fragments not allowed.',
+                    'pattern': '^[^#]*#?$'
+                },
+                '$schema': {
+                    'type': 'string',
+                    'format': 'uri'
+                },
+                '$anchor': {
+                    'type': 'string',
+                    'pattern': '^[A-Za-z][-A-Za-z0-9.:_]*$'
+                },
+                '$ref': {
+                    'type': 'string',
+                    'format': 'uri-reference'
+                },
+                '$recursiveRef': {
+                    'type': 'string',
+                    'format': 'uri-reference'
+                },
+                '$recursiveAnchor': {
+                    'type': 'boolean',
+                    'default': false
+                },
+                '$vocabulary': {
+                    'type': 'object',
+                    'propertyNames': {
+                        'type': 'string',
+                        'format': 'uri'
+                    },
+                    'additionalProperties': {
+                        'type': 'boolean'
+                    }
+                },
+                '$comment': {
+                    'type': 'string'
+                },
+                '$defs': {
+                    'type': 'object',
+                    'additionalProperties': { '$recursiveRef': '#' },
+                    'default': {}
+                }
+            }
+        },
+        {
+            '$schema': 'https://json-schema.org/draft/2019-09/schema',
+            '$id': 'https://json-schema.org/draft/2019-09/meta/applicator',
+            '$recursiveAnchor': true,
+            'title': 'Applicator vocabulary meta-schema',
+            'type': ['object', 'boolean'],
+            'properties': {
+                'additionalItems': { '$recursiveRef': '#' },
+                'unevaluatedItems': { '$recursiveRef': '#' },
+                'items': {
+                    'anyOf': [
+                        { '$recursiveRef': '#' },
+                        { '$ref': '#/$defs/schemaArray' }
+                    ]
+                },
+                'contains': { '$recursiveRef': '#' },
+                'additionalProperties': { '$recursiveRef': '#' },
+                'unevaluatedProperties': { '$recursiveRef': '#' },
+                'properties': {
+                    'type': 'object',
+                    'additionalProperties': { '$recursiveRef': '#' },
+                    'default': {}
+                },
+                'patternProperties': {
+                    'type': 'object',
+                    'additionalProperties': { '$recursiveRef': '#' },
+                    'propertyNames': { 'format': 'regex' },
+                    'default': {}
+                },
+                'dependentSchemas': {
+                    'type': 'object',
+                    'additionalProperties': {
+                        '$recursiveRef': '#'
+                    }
+                },
+                'propertyNames': { '$recursiveRef': '#' },
+                'if': { '$recursiveRef': '#' },
+                'then': { '$recursiveRef': '#' },
+                'else': { '$recursiveRef': '#' },
+                'allOf': { '$ref': '#/$defs/schemaArray' },
+                'anyOf': { '$ref': '#/$defs/schemaArray' },
+                'oneOf': { '$ref': '#/$defs/schemaArray' },
+                'not': { '$recursiveRef': '#' }
+            },
+            '$defs': {
+                'schemaArray': {
+                    'type': 'array',
+                    'minItems': 1,
+                    'items': { '$recursiveRef': '#' }
+                }
+            }
+        },
+        {
+            '$schema': 'https://json-schema.org/draft/2019-09/schema',
+            '$id': 'https://json-schema.org/draft/2019-09/meta/validation',
+            '$recursiveAnchor': true,
+            'title': 'Validation vocabulary meta-schema',
+            'type': ['object', 'boolean'],
+            'properties': {
+                'multipleOf': {
+                    'type': 'number',
+                    'exclusiveMinimum': 0
+                },
+                'maximum': {
+                    'type': 'number'
+                },
+                'exclusiveMaximum': {
+                    'type': 'number'
+                },
+                'minimum': {
+                    'type': 'number'
+                },
+                'exclusiveMinimum': {
+                    'type': 'number'
+                },
+                'maxLength': { '$ref': '#/$defs/nonNegativeInteger' },
+                'minLength': { '$ref': '#/$defs/nonNegativeIntegerDefault0' },
+                'pattern': {
+                    'type': 'string',
+                    'format': 'regex'
+                },
+                'maxItems': { '$ref': '#/$defs/nonNegativeInteger' },
+                'minItems': { '$ref': '#/$defs/nonNegativeIntegerDefault0' },
+                'uniqueItems': {
+                    'type': 'boolean',
+                    'default': false
+                },
+                'maxContains': { '$ref': '#/$defs/nonNegativeInteger' },
+                'minContains': {
+                    '$ref': '#/$defs/nonNegativeInteger',
+                    'default': 1
+                },
+                'maxProperties': { '$ref': '#/$defs/nonNegativeInteger' },
+                'minProperties': { '$ref': '#/$defs/nonNegativeIntegerDefault0' },
+                'required': { '$ref': '#/$defs/stringArray' },
+                'dependentRequired': {
+                    'type': 'object',
+                    'additionalProperties': {
+                        '$ref': '#/$defs/stringArray'
+                    }
+                },
+                'const': true,
+                'enum': {
+                    'type': 'array',
+                    'items': true
+                },
+                'type': {
+                    'anyOf': [
+                        { '$ref': '#/$defs/simpleTypes' },
+                        {
+                            'type': 'array',
+                            'items': { '$ref': '#/$defs/simpleTypes' },
+                            'minItems': 1,
+                            'uniqueItems': true
+                        }
+                    ]
+                }
+            },
+            '$defs': {
+                'nonNegativeInteger': {
+                    'type': 'integer',
+                    'minimum': 0
+                },
+                'nonNegativeIntegerDefault0': {
+                    '$ref': '#/$defs/nonNegativeInteger',
+                    'default': 0
+                },
+                'simpleTypes': {
+                    'enum': [
+                        'array',
+                        'boolean',
+                        'integer',
+                        'null',
+                        'number',
+                        'object',
+                        'string'
+                    ]
+                },
+                'stringArray': {
+                    'type': 'array',
+                    'items': { 'type': 'string' },
+                    'uniqueItems': true,
+                    'default': []
+                }
+            }
+        },
+        {
+            '$schema': 'https://json-schema.org/draft/2019-09/schema',
+            '$id': 'https://json-schema.org/draft/2019-09/meta/meta-data',
+            '$recursiveAnchor': true,
+            'title': 'Meta-data vocabulary meta-schema',
+            'type': ['object', 'boolean'],
+            'properties': {
+                'title': {
+                    'type': 'string'
+                },
+                'description': {
+                    'type': 'string'
+                },
+                'default': true,
+                'deprecated': {
+                    'type': 'boolean',
+                    'default': false
+                },
+                'readOnly': {
+                    'type': 'boolean',
+                    'default': false
+                },
+                'writeOnly': {
+                    'type': 'boolean',
+                    'default': false
+                },
+                'examples': {
+                    'type': 'array',
+                    'items': true
+                }
+            }
+        },
+        {
+            '$schema': 'https://json-schema.org/draft/2019-09/schema',
+            '$id': 'https://json-schema.org/draft/2019-09/meta/format',
+            '$recursiveAnchor': true,
+            'title': 'Format vocabulary meta-schema',
+            'type': ['object', 'boolean'],
+            'properties': {
+                'format': { 'type': 'string' }
+            }
+        },
+        {
+            '$schema': 'https://json-schema.org/draft/2019-09/schema',
+            '$id': 'https://json-schema.org/draft/2019-09/meta/content',
+            '$recursiveAnchor': true,
+            'title': 'Content vocabulary meta-schema',
+            'type': ['object', 'boolean'],
+            'properties': {
+                'contentMediaType': { 'type': 'string' },
+                'contentEncoding': { 'type': 'string' },
+                'contentSchema': { '$recursiveRef': '#' }
+            }
+        }
+    ],
+    'type': ['object', 'boolean'],
+    'properties': {
+        'definitions': {
+            '$comment': 'While no longer an official keyword as it is replaced by $defs, this keyword is retained in the meta-schema to prevent incompatible extensions as it remains in common use.',
+            'type': 'object',
+            'additionalProperties': { '$recursiveRef': '#' },
+            'default': {}
+        },
+        'dependencies': {
+            '$comment': '"dependencies" is no longer a keyword, but schema authors should avoid redefining it to facilitate a smooth transition to "dependentSchemas" and "dependentRequired"',
+            'type': 'object',
+            'additionalProperties': {
+                'anyOf': [
+                    { '$recursiveRef': '#' },
+                    { '$ref': 'meta/validation#/$defs/stringArray' }
+                ]
+            }
+        }
+    }
+};

package/build/schema/meta/draft_2020_12.d.mts

@@ -0,0 +1,2 @@
+import type { XMetaSchemaObject } from './schema.mjs';
+export declare const Draft_2020_12: XMetaSchemaObject;