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

package/build/schema/meta/draft_6.mjs

@@ -0,0 +1,155 @@
+export const Draft_6 = {
+    '$schema': 'http://json-schema.org/draft-06/schema#',
+    '$id': 'http://json-schema.org/draft-06/schema#',
+    'title': 'Core schema meta-schema',
+    'definitions': {
+        'schemaArray': {
+            'type': 'array',
+            'minItems': 1,
+            'items': { '$ref': '#' }
+        },
+        'nonNegativeInteger': {
+            'type': 'integer',
+            'minimum': 0
+        },
+        'nonNegativeIntegerDefault0': {
+            'allOf': [
+                { '$ref': '#/definitions/nonNegativeInteger' },
+                { 'default': 0 }
+            ]
+        },
+        'simpleTypes': {
+            'enum': [
+                'array',
+                'boolean',
+                'integer',
+                'null',
+                'number',
+                'object',
+                'string'
+            ]
+        },
+        'stringArray': {
+            'type': 'array',
+            'items': { 'type': 'string' },
+            'uniqueItems': true,
+            'default': []
+        }
+    },
+    'type': ['object', 'boolean'],
+    'properties': {
+        '$id': {
+            'type': 'string',
+            'format': 'uri-reference'
+        },
+        '$schema': {
+            'type': 'string',
+            'format': 'uri'
+        },
+        '$ref': {
+            'type': 'string',
+            'format': 'uri-reference'
+        },
+        'title': {
+            'type': 'string'
+        },
+        'description': {
+            'type': 'string'
+        },
+        'default': {},
+        'examples': {
+            'type': 'array',
+            'items': {}
+        },
+        'multipleOf': {
+            'type': 'number',
+            'exclusiveMinimum': 0
+        },
+        'maximum': {
+            'type': 'number'
+        },
+        'exclusiveMaximum': {
+            'type': 'number'
+        },
+        'minimum': {
+            'type': 'number'
+        },
+        'exclusiveMinimum': {
+            'type': 'number'
+        },
+        'maxLength': { '$ref': '#/definitions/nonNegativeInteger' },
+        'minLength': { '$ref': '#/definitions/nonNegativeIntegerDefault0' },
+        'pattern': {
+            'type': 'string',
+            'format': 'regex'
+        },
+        'additionalItems': { '$ref': '#' },
+        'items': {
+            'anyOf': [
+                { '$ref': '#' },
+                { '$ref': '#/definitions/schemaArray' }
+            ],
+            'default': {}
+        },
+        'maxItems': { '$ref': '#/definitions/nonNegativeInteger' },
+        'minItems': { '$ref': '#/definitions/nonNegativeIntegerDefault0' },
+        'uniqueItems': {
+            'type': 'boolean',
+            'default': false
+        },
+        'contains': { '$ref': '#' },
+        'maxProperties': { '$ref': '#/definitions/nonNegativeInteger' },
+        'minProperties': { '$ref': '#/definitions/nonNegativeIntegerDefault0' },
+        'required': { '$ref': '#/definitions/stringArray' },
+        'additionalProperties': { '$ref': '#' },
+        'definitions': {
+            'type': 'object',
+            'additionalProperties': { '$ref': '#' },
+            'default': {}
+        },
+        'properties': {
+            'type': 'object',
+            'additionalProperties': { '$ref': '#' },
+            'default': {}
+        },
+        'patternProperties': {
+            'type': 'object',
+            'additionalProperties': { '$ref': '#' },
+            'propertyNames': { 'format': 'regex' },
+            'default': {}
+        },
+        'dependencies': {
+            'type': 'object',
+            'additionalProperties': {
+                'anyOf': [
+                    { '$ref': '#' },
+                    { '$ref': '#/definitions/stringArray' }
+                ]
+            }
+        },
+        'propertyNames': { '$ref': '#' },
+        'const': {},
+        'enum': {
+            'type': 'array',
+            'minItems': 1,
+            'uniqueItems': true
+        },
+        'type': {
+            'anyOf': [
+                { '$ref': '#/definitions/simpleTypes' },
+                {
+                    'type': 'array',
+                    'items': { '$ref': '#/definitions/simpleTypes' },
+                    'minItems': 1,
+                    'uniqueItems': true
+                }
+            ]
+        },
+        'format': { 'type': 'string' },
+        'allOf': { '$ref': '#/definitions/schemaArray' },
+        'anyOf': { '$ref': '#/definitions/schemaArray' },
+        'oneOf': { '$ref': '#/definitions/schemaArray' },
+        'not': { '$ref': '#' }
+    },
+    'default': {}
+};

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

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

package/build/schema/meta/draft_7.mjs

@@ -0,0 +1,172 @@
+export const Draft_7 = {
+    '$schema': 'http://json-schema.org/draft-07/schema#',
+    '$id': 'http://json-schema.org/draft-07/schema#',
+    'title': 'Core schema meta-schema',
+    'definitions': {
+        'schemaArray': {
+            'type': 'array',
+            'minItems': 1,
+            'items': { '$ref': '#' }
+        },
+        'nonNegativeInteger': {
+            'type': 'integer',
+            'minimum': 0
+        },
+        'nonNegativeIntegerDefault0': {
+            'allOf': [
+                { '$ref': '#/definitions/nonNegativeInteger' },
+                { 'default': 0 }
+            ]
+        },
+        'simpleTypes': {
+            'enum': [
+                'array',
+                'boolean',
+                'integer',
+                'null',
+                'number',
+                'object',
+                'string'
+            ]
+        },
+        'stringArray': {
+            'type': 'array',
+            'items': { 'type': 'string' },
+            'uniqueItems': true,
+            'default': []
+        }
+    },
+    'type': ['object', 'boolean'],
+    'properties': {
+        '$id': {
+            'type': 'string',
+            'format': 'uri-reference'
+        },
+        '$schema': {
+            'type': 'string',
+            'format': 'uri'
+        },
+        '$ref': {
+            'type': 'string',
+            'format': 'uri-reference'
+        },
+        '$comment': {
+            'type': 'string'
+        },
+        'title': {
+            'type': 'string'
+        },
+        'description': {
+            'type': 'string'
+        },
+        'default': true,
+        'readOnly': {
+            'type': 'boolean',
+            'default': false
+        },
+        'writeOnly': {
+            'type': 'boolean',
+            'default': false
+        },
+        'examples': {
+            'type': 'array',
+            'items': true
+        },
+        'multipleOf': {
+            'type': 'number',
+            'exclusiveMinimum': 0
+        },
+        'maximum': {
+            'type': 'number'
+        },
+        'exclusiveMaximum': {
+            'type': 'number'
+        },
+        'minimum': {
+            'type': 'number'
+        },
+        'exclusiveMinimum': {
+            'type': 'number'
+        },
+        'maxLength': { '$ref': '#/definitions/nonNegativeInteger' },
+        'minLength': { '$ref': '#/definitions/nonNegativeIntegerDefault0' },
+        'pattern': {
+            'type': 'string',
+            'format': 'regex'
+        },
+        'additionalItems': { '$ref': '#' },
+        'items': {
+            'anyOf': [
+                { '$ref': '#' },
+                { '$ref': '#/definitions/schemaArray' }
+            ],
+            'default': true
+        },
+        'maxItems': { '$ref': '#/definitions/nonNegativeInteger' },
+        'minItems': { '$ref': '#/definitions/nonNegativeIntegerDefault0' },
+        'uniqueItems': {
+            'type': 'boolean',
+            'default': false
+        },
+        'contains': { '$ref': '#' },
+        'maxProperties': { '$ref': '#/definitions/nonNegativeInteger' },
+        'minProperties': { '$ref': '#/definitions/nonNegativeIntegerDefault0' },
+        'required': { '$ref': '#/definitions/stringArray' },
+        'additionalProperties': { '$ref': '#' },
+        'definitions': {
+            'type': 'object',
+            'additionalProperties': { '$ref': '#' },
+            'default': {}
+        },
+        'properties': {
+            'type': 'object',
+            'additionalProperties': { '$ref': '#' },
+            'default': {}
+        },
+        'patternProperties': {
+            'type': 'object',
+            'additionalProperties': { '$ref': '#' },
+            'propertyNames': { 'format': 'regex' },
+            'default': {}
+        },
+        'dependencies': {
+            'type': 'object',
+            'additionalProperties': {
+                'anyOf': [
+                    { '$ref': '#' },
+                    { '$ref': '#/definitions/stringArray' }
+                ]
+            }
+        },
+        'propertyNames': { '$ref': '#' },
+        'const': true,
+        'enum': {
+            'type': 'array',
+            'items': true,
+            'minItems': 1,
+            'uniqueItems': true
+        },
+        'type': {
+            'anyOf': [
+                { '$ref': '#/definitions/simpleTypes' },
+                {
+                    'type': 'array',
+                    'items': { '$ref': '#/definitions/simpleTypes' },
+                    'minItems': 1,
+                    'uniqueItems': true
+                }
+            ]
+        },
+        'format': { 'type': 'string' },
+        'contentMediaType': { 'type': 'string' },
+        'contentEncoding': { 'type': 'string' },
+        'if': { '$ref': '#' },
+        'then': { '$ref': '#' },
+        'else': { '$ref': '#' },
+        'allOf': { '$ref': '#/definitions/schemaArray' },
+        'anyOf': { '$ref': '#/definitions/schemaArray' },
+        'oneOf': { '$ref': '#/definitions/schemaArray' },
+        'not': { '$ref': '#' }
+    },
+    'default': true
+};

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

@@ -0,0 +1,2 @@
+export * from './schema.mjs';
+export * from './meta.mjs';

package/build/schema/meta/index.mjs

@@ -0,0 +1,2 @@
+export * from './schema.mjs';
+export * from './meta.mjs';

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

@@ -0,0 +1,9 @@
+/** A collection of all meta schemas. */
+export declare const Meta: {
+    'http://json-schema.org/draft-03/schema#': import("./schema.mjs").XMetaSchemaObject;
+    'http://json-schema.org/draft-04/schema#': import("./schema.mjs").XMetaSchemaObject;
+    'http://json-schema.org/draft-06/schema#': import("./schema.mjs").XMetaSchemaObject;
+    'http://json-schema.org/draft-07/schema#': import("./schema.mjs").XMetaSchemaObject;
+    'https://json-schema.org/draft/2019-09/schema': import("./schema.mjs").XMetaSchemaObject;
+    'https://json-schema.org/draft/2020-12/schema': import("./schema.mjs").XMetaSchemaObject;
+};

package/build/schema/meta/meta.mjs

@@ -0,0 +1,15 @@
+import { Draft_2020_12 } from './draft_2020_12.mjs';
+import { Draft_2019_09 } from './draft_2019_09.mjs';
+import { Draft_7 } from './draft_7.mjs';
+import { Draft_6 } from './draft_6.mjs';
+import { Draft_4 } from './draft_4.mjs';
+import { Draft_3 } from './draft_3.mjs';
+/** A collection of all meta schemas. */
+export const Meta = {
+    'http://json-schema.org/draft-03/schema#': Draft_3,
+    'http://json-schema.org/draft-04/schema#': Draft_4,
+    'http://json-schema.org/draft-06/schema#': Draft_6,
+    'http://json-schema.org/draft-07/schema#': Draft_7,
+    'https://json-schema.org/draft/2019-09/schema': Draft_2019_09,
+    'https://json-schema.org/draft/2020-12/schema': Draft_2020_12
+};

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

@@ -0,0 +1,6 @@
+import type { XSchema } from '../types/schema.mjs';
+/** Represents a JSON Schema meta-schema that infers as XSchema. */
+export type XMetaSchemaObject = {
+    $schema: string;
+    ['~unsafe']: XSchema;
+};

package/build/schema/meta/schema.mjs

@@ -0,0 +1 @@
+export {};

package/build/schema/parse.mjs

@@ -1,5 +1,6 @@
 // deno-fmt-ignore-file
 // deno-lint-ignore-file
+import { EnableParseErrors, DisableParseErrors } from '../system/settings/internal.mjs';
 import { Arguments } from '../system/arguments/index.mjs';
 import { Check } from './check.mjs';
 import { Errors } from './errors.mjs';
@@ -17,7 +18,9 @@ export class ParseError {
 // ThrowParseError
 // ------------------------------------------------------------------
 export function ThrowParseError(context, schema, value) {
+    EnableParseErrors();
     const result = Errors(context, schema, value);
+    DisableParseErrors();
     throw new ParseError(schema, value, result[1]);
 }
 /** Parses a value against the provided schema */

package/build/schema/pointer/pointer.d.mts

@@ -1,10 +1,5 @@
-/** Returns an array of path indices for the given pointer */
 export declare function Indices(pointer: string): string[];
-/** Returns true if a value exists at the current pointer */
-export declare function Has(value: unknown, pointer: string): unknown;
-/** Gets a value at the pointer, or undefined if not exists */
+export declare function Has(value: unknown, pointer: string): boolean;
 export declare function Get(value: unknown, pointer: string): unknown;
-/** Sets a value at the given pointer. May throw if the target value is not indexable */
 export declare function Set(value: unknown, pointer: string, next: unknown): unknown;
-/** Deletes the value at the given pointer. May throw if the target value is not indexable */
 export declare function Delete(value: unknown, pointer: string): unknown;

package/build/schema/pointer/pointer.mjs

@@ -1,106 +1,89 @@
 // deno-fmt-ignore-file
 import { Guard } from '../../guard/index.mjs';
 // ------------------------------------------------------------------
-// Asserts
+// Throw
 // ------------------------------------------------------------------
-function AssertNotRoot(indices) {
-    if (indices.length === 0)
-        throw Error('Cannot set root');
+function Throw(message) {
+    throw Error(message);
 }
-function AssertCanSet(value) {
-    if (!Guard.IsObject(value))
-        throw Error('Cannot set value');
+function ThrowUnsafePropertyKey() {
+    Throw('Pointer contains unsafe property key');
 }
-function AssertIndex(index) {
-    if (Guard.IsUnsafePropertyKey(index))
-        throw Error('Pointer contains unsafe property key');
-}
-function AssertIndices(indices) {
-    for (const index of indices)
-        AssertIndex(index);
-}
-// ------------------------------------------------------------------
-// Indices
-// ------------------------------------------------------------------
-function IsNumericIndex(index) {
-    return /^(0|[1-9]\d*)$/.test(index);
-}
-function TakeIndexRight(indices) {
-    return [
-        indices.slice(0, indices.length - 1),
-        indices.slice(indices.length - 1)[0]
-    ];
-}
-function HasIndex(index, value) {
-    return Guard.IsObject(value) && Guard.HasPropertyKey(value, index);
-}
-function GetIndex(index, value) {
-    return Guard.IsObject(value) && !Guard.IsUnsafePropertyKey(index) ? value[index] : undefined;
-}
-function GetIndices(indices, value) {
-    return indices.reduce((value, index) => GetIndex(index, value), value);
+function ThrowCannotSetRoot() {
+    Throw('Cannot set value');
 }
 // ------------------------------------------------------------------
 // Indices
 // ------------------------------------------------------------------
-/** Returns an array of path indices for the given pointer */
 export function Indices(pointer) {
-    if (Guard.IsEqual(pointer.length, 0))
-        return [];
-    const indices = pointer.split("/").map(index => index.replace(/~1/g, "/").replace(/~0/g, "~"));
-    return (indices.length > 0 && indices[0] === '') ? indices.slice(1) : indices;
+    const indices = pointer.split('/').map(index => index.replace(/~1/g, '/').replace(/~0/g, '~'));
+    return indices[0] === '' ? indices.slice(1) : indices;
 }
 // ------------------------------------------------------------------
 // Has
 // ------------------------------------------------------------------
-/** Returns true if a value exists at the current pointer */
 export function Has(value, pointer) {
     let current = value;
-    return Indices(pointer).every(index => {
-        if (!HasIndex(index, current))
+    for (const index of Indices(pointer)) {
+        if (!Guard.IsObject(current) || !Guard.HasPropertyKey(current, index))
             return false;
         current = current[index];
-        return true;
-    });
+    }
+    return true;
 }
 // ------------------------------------------------------------------
 // Get
 // ------------------------------------------------------------------
-/** Gets a value at the pointer, or undefined if not exists */
 export function Get(value, pointer) {
-    const indices = Indices(pointer);
-    return GetIndices(indices, value);
+    let current = value;
+    for (const index of Indices(pointer)) {
+        if (!Guard.IsObject(current) || Guard.IsUnsafePropertyKey(index))
+            return undefined;
+        current = current[index];
+    }
+    return current;
+}
+// ------------------------------------------------------------------
+// Get
+// ------------------------------------------------------------------
+function Parent(value, indices, last) {
+    let current = value;
+    for (const index of indices) {
+        if (Guard.IsUnsafePropertyKey(index))
+            ThrowUnsafePropertyKey();
+        current = Guard.IsObject(current) ? current[index] : undefined;
+    }
+    if (Guard.IsUnsafePropertyKey(last))
+        ThrowUnsafePropertyKey();
+    if (!Guard.IsObject(current))
+        ThrowCannotSetRoot();
+    return current;
 }
 // ------------------------------------------------------------------
 // Set
 // ------------------------------------------------------------------
-/** Sets a value at the given pointer. May throw if the target value is not indexable */
 export function Set(value, pointer, next) {
     const indices = Indices(pointer);
-    AssertNotRoot(indices);
-    AssertIndices(indices);
-    const [head, index] = TakeIndexRight(indices);
-    const parent = GetIndices(head, value);
-    AssertCanSet(parent);
-    parent[index] = next;
+    const last = indices.pop();
+    if (Guard.IsUndefined(last))
+        ThrowCannotSetRoot();
+    Parent(value, indices, last)[last] = next;
     return value;
 }
 // ------------------------------------------------------------------
 // Delete
 // ------------------------------------------------------------------
-/** Deletes the value at the given pointer. May throw if the target value is not indexable */
 export function Delete(value, pointer) {
     const indices = Indices(pointer);
-    AssertNotRoot(indices);
-    AssertIndices(indices);
-    const [head, index] = TakeIndexRight(indices);
-    const parent = GetIndices(head, value);
-    AssertCanSet(parent);
-    if (Guard.IsArray(parent) && IsNumericIndex(index)) {
-        parent.splice(+index, 1);
+    const last = indices.pop();
+    if (Guard.IsUndefined(last))
+        ThrowCannotSetRoot();
+    const parent = Parent(value, indices, last);
+    if (Guard.IsArray(parent) && /^(0|[1-9]\d*)$/.test(last)) {
+        parent.splice(Number(last), 1);
     }
     else {
-        delete parent[index];
+        delete parent[last];
     }
     return value;
 }

package/build/schema/resolve/resolve.d.mts

@@ -1,35 +1,9 @@
 import * as Schema from '../types/index.mjs';
-export declare const DefaultBase = "https://json-schema.org";
-export interface StackFrame {
-    context: Record<string, Schema.XSchema>;
-    root: Schema.XSchemaObject;
-    lexicalSchema: Schema.XSchemaObject;
-    lexicalBase: string;
-    referenceBase: string;
-    resourceBase: string;
-    ids: Schema.XId[];
-    recursiveAnchors: Schema.XRecursiveAnchor[];
-    dynamicAnchors: Schema.XDynamicAnchor[];
-    inRetrievedFrame: boolean;
-}
-export interface RetrievedResource {
-    target: Schema.XSchemaObject;
-    base: string;
-    root: Schema.XSchemaObject;
-}
-export interface ResolvedResource {
-    target: Schema.XSchemaObject;
-    resource: Schema.XId;
-}
-export interface RefResult {
+import * as Stack from '../engine/_stack.mjs';
+export interface XRefResult {
     schema: Schema.XSchema | undefined;
-    retrievedResource?: RetrievedResource;
-    resolvedResource?: ResolvedResource;
+    stack: Stack.XStack;
 }
-export declare function Base(schema: Schema.XSchemaObject, base: string, target: Schema.XSchema): string | undefined;
-export declare function Resource(context: Record<string, Schema.XSchema>, schema: Schema.XSchemaObject, base: string, ref: string): Schema.XId | undefined;
-export declare function Ref(remotes: Record<string, Schema.XSchema>, schema: Schema.XSchemaObject, base: string, ref: string, applySchemaId?: boolean): Schema.XSchema | undefined;
-export declare function DynamicRef(context: Record<string, Schema.XSchema>, root: Schema.XSchemaObject, base: string, schema: Schema.XSchemaObject, dynamicRef: Schema.XDynamicRef, dynamicAnchors: Schema.XDynamicAnchor[]): Schema.XSchema | undefined;
-export declare function ResolveRef(stackframe: StackFrame, ref: Schema.XRef): RefResult;
-export declare function ResolveRecursiveRef(stackframe: StackFrame, recursiveRef: Schema.XRecursiveRef): Schema.XSchema | undefined;
-export declare function ResolveDynamicRef(stackframe: StackFrame, dynamicRef: Schema.XDynamicRef): Schema.XSchema | undefined;
+export declare function Ref(stack: Stack.XStack, ref: Schema.XRef): XRefResult;
+export declare function RecursiveRef(stack: Stack.XStack, recursiveRef: Schema.XRecursiveRef): Schema.XSchema | undefined;
+export declare function DynamicRef(stack: Stack.XStack, dynamicRef: Schema.XDynamicRef): Schema.XSchema | undefined;