@sinclair/typebox 0.26.0-dev.4 → 0.26.0-dev.5

package/typebox.js

@@ -27,106 +27,69 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Type = exports.StandardType = exports.ExtendedTypeBuilder = exports.StandardTypeBuilder = exports.TypeBuilder = exports.KeyResolver = exports.ObjectMap = exports.TypeClone = exports.TypeExtends = exports.TypeExtendsResult = exports.ExtendsUndefined = exports.TypeGuard = exports.TypeGuardUnknownTypeError = exports.FormatRegistry = exports.ReferenceRegistry = exports.TypeRegistry = exports.Kind = exports.Hint = exports.Modifier = exports.Recursive = void 0;
+exports.Type = exports.StandardType = exports.ExtendedTypeBuilder = exports.StandardTypeBuilder = exports.TypeBuilder = exports.KeyResolver = exports.ObjectMap = exports.TypeClone = exports.TypeExtends = exports.TypeExtendsResult = exports.ExtendsUndefined = exports.TypeGuard = exports.TypeGuardUnknownTypeError = exports.FormatRegistry = exports.TypeRegistry = exports.Kind = exports.Hint = exports.Modifier = void 0;
 // --------------------------------------------------------------------------
 // Compositing Symbols
 // --------------------------------------------------------------------------
-exports.Recursive = Symbol.for('TypeBox.Recursive');
 exports.Modifier = Symbol.for('TypeBox.Modifier');
 exports.Hint = Symbol.for('TypeBox.Hint');
 exports.Kind = Symbol.for('TypeBox.Kind');
 var TypeRegistry;
 (function (TypeRegistry) {
-    const types = new Map();
+    const map = new Map();
+    /** Returns the entries in this registry */
+    function Entries() {
+        return new Map(map);
+    }
+    TypeRegistry.Entries = Entries;
     /** Clears all user defined types */
     function Clear() {
-        return types.clear();
+        return map.clear();
     }
     TypeRegistry.Clear = Clear;
     /** Returns true if this registry contains this kind */
     function Has(kind) {
-        return types.has(kind);
+        return map.has(kind);
     }
     TypeRegistry.Has = Has;
     /** Sets a validation function for a user defined type */
     function Set(kind, func) {
-        types.set(kind, func);
+        map.set(kind, func);
     }
     TypeRegistry.Set = Set;
     /** Gets a custom validation function for a user defined type */
     function Get(kind) {
-        return types.get(kind);
+        return map.get(kind);
     }
     TypeRegistry.Get = Get;
 })(TypeRegistry = exports.TypeRegistry || (exports.TypeRegistry = {}));
-// --------------------------------------------------------------------------
-// ReferenceRegistry
-// --------------------------------------------------------------------------
-var ReferenceRegistry;
-(function (ReferenceRegistry) {
-    const references = new Map();
-    /** Clears the reference registry */
-    function Clear() {
-        return references.clear();
-    }
-    ReferenceRegistry.Clear = Clear;
-    /** Returns true if this registry contains this schema */
-    function Has(schema) {
-        return references.has(schema.$id);
-    }
-    ReferenceRegistry.Has = Has;
-    /** Sets this schema on this registry if a $id exists */
-    function Set(schema) {
-        const $id = typeof schema === 'object' && schema !== null && typeof schema['$id'] === 'string' ? schema['$id'] : undefined;
-        if ($id !== undefined)
-            references.set($id, schema);
-    }
-    ReferenceRegistry.Set = Set;
-    /** Dereferences the schema one level deep */
-    function DerefOne(schema) {
-        if (TypeGuard.TRef(schema) || TypeGuard.TSelf(schema)) {
-            if (!references.has(schema.$ref))
-                throw Error(`ReferenceRegistry: Cannot deref schema with $id '${schema.$ref}'`);
-            return references.get(schema.$ref);
-        }
-        else {
-            return schema;
-        }
-    }
-    ReferenceRegistry.DerefOne = DerefOne;
-    /** Dereferences the schema recursively */
-    function Deref(schema) {
-        if (TypeGuard.TRef(schema)) {
-            return Deref(DerefOne(schema));
-        }
-        else {
-            return schema;
-        }
-    }
-    ReferenceRegistry.Deref = Deref;
-})(ReferenceRegistry = exports.ReferenceRegistry || (exports.ReferenceRegistry = {}));
 /** Provides functions to create user defined string formats */
 var FormatRegistry;
 (function (FormatRegistry) {
-    const formats = new Map();
+    const map = new Map();
+    /** Returns the entries in this registry */
+    function Entries() {
+        return new Map(map);
+    }
+    FormatRegistry.Entries = Entries;
     /** Clears all user defined string formats */
     function Clear() {
-        return formats.clear();
+        return map.clear();
     }
     FormatRegistry.Clear = Clear;
     /** Returns true if the user defined string format exists */
     function Has(format) {
-        return formats.has(format);
+        return map.has(format);
     }
     FormatRegistry.Has = Has;
     /** Sets a validation function for a user defined string format */
     function Set(format, func) {
-        formats.set(format, func);
+        map.set(format, func);
     }
     FormatRegistry.Set = Set;
     /** Gets a validation function for a user defined string format */
     function Get(format) {
-        return formats.get(format);
+        return map.get(format);
     }
     FormatRegistry.Get = Get;
 })(FormatRegistry = exports.FormatRegistry || (exports.FormatRegistry = {}));
@@ -346,18 +309,7 @@ var TypeGuard;
     TypeGuard.TLiteral = TLiteral;
     /** Returns true if the given schema is TNever */
     function TNever(schema) {
-        return (TKind(schema) && schema[exports.Kind] === 'Never' && IsObject(schema.not) && globalThis.Object.getOwnPropertyNames(schema.not).length === 0
-        // IsArray(schema.allOf) &&
-        // schema.allOf.length === 2 &&
-        // IsObject(schema.allOf[0]) &&
-        // IsString(schema.allOf[0].type) &&
-        // schema.allOf[0].type === 'boolean' &&
-        // schema.allOf[0].const === false &&
-        // IsObject(schema.allOf[1]) &&
-        // IsString(schema.allOf[1].type) &&
-        // schema.allOf[1].type === 'boolean' &&
-        // schema.allOf[1].const === true
-        );
+        return TKind(schema) && schema[exports.Kind] === 'Never' && IsObject(schema.not) && globalThis.Object.getOwnPropertyNames(schema.not).length === 0;
     }
     TypeGuard.TNever = TNever;
     /** Returns true if the given schema is TNot */
@@ -621,9 +573,9 @@ var TypeGuard;
 // --------------------------------------------------------------------------
 // ExtendsUndefined
 // --------------------------------------------------------------------------
+/** Fast undefined check used for properties of type undefined */
 var ExtendsUndefined;
 (function (ExtendsUndefined) {
-    /** Fast undefined check for properties of type undefined */
     function Check(schema) {
         if (schema[exports.Kind] === 'Undefined')
             return true;
@@ -1307,56 +1259,54 @@ var TypeExtends;
         return TypeGuard.TVoid(right) ? TypeExtendsResult.True : TypeExtendsResult.False;
     }
     function Visit(left, right) {
-        const right_ = ReferenceRegistry.Deref(right);
-        const left_ = ReferenceRegistry.Deref(left);
-        if (TypeGuard.TAny(left_))
-            return Any(left_, right_);
-        if (TypeGuard.TArray(left_))
-            return Array(left_, right_);
-        if (TypeGuard.TBigInt(left_))
-            return BigInt(left_, right_);
-        if (TypeGuard.TBoolean(left_))
-            return Boolean(left_, right_);
-        if (TypeGuard.TConstructor(left_))
-            return Constructor(left_, right_);
-        if (TypeGuard.TDate(left_))
-            return Date(left_, right_);
-        if (TypeGuard.TFunction(left_))
-            return Function(left_, right_);
-        if (TypeGuard.TInteger(left_))
-            return Integer(left_, right_);
-        if (TypeGuard.TIntersect(left_))
-            return Intersect(left_, right_);
-        if (TypeGuard.TLiteral(left_))
-            return Literal(left_, right_);
-        if (TypeGuard.TNever(left_))
-            return Never(left_, right_);
-        if (TypeGuard.TNull(left_))
-            return Null(left_, right_);
-        if (TypeGuard.TNumber(left_))
-            return Number(left_, right_);
-        if (TypeGuard.TRecord(left_))
-            return Record(left_, right_);
-        if (TypeGuard.TString(left_))
-            return String(left_, right_);
-        if (TypeGuard.TSymbol(left_))
-            return Symbol(left_, right_);
-        if (TypeGuard.TObject(left_))
-            return Object(left_, right_);
-        if (TypeGuard.TTuple(left_))
-            return Tuple(left_, right_);
-        if (TypeGuard.TPromise(left_))
-            return Promise(left_, right_);
-        if (TypeGuard.TUint8Array(left_))
-            return Uint8Array(left_, right_);
-        if (TypeGuard.TUndefined(left_))
-            return Undefined(left_, right_);
-        if (TypeGuard.TUnion(left_))
-            return Union(left_, right_);
-        if (TypeGuard.TUnknown(left_))
-            return Unknown(left_, right_);
-        if (TypeGuard.TVoid(left_))
-            return Void(left_, right_);
+        if (TypeGuard.TAny(left))
+            return Any(left, right);
+        if (TypeGuard.TArray(left))
+            return Array(left, right);
+        if (TypeGuard.TBigInt(left))
+            return BigInt(left, right);
+        if (TypeGuard.TBoolean(left))
+            return Boolean(left, right);
+        if (TypeGuard.TConstructor(left))
+            return Constructor(left, right);
+        if (TypeGuard.TDate(left))
+            return Date(left, right);
+        if (TypeGuard.TFunction(left))
+            return Function(left, right);
+        if (TypeGuard.TInteger(left))
+            return Integer(left, right);
+        if (TypeGuard.TIntersect(left))
+            return Intersect(left, right);
+        if (TypeGuard.TLiteral(left))
+            return Literal(left, right);
+        if (TypeGuard.TNever(left))
+            return Never(left, right);
+        if (TypeGuard.TNull(left))
+            return Null(left, right);
+        if (TypeGuard.TNumber(left))
+            return Number(left, right);
+        if (TypeGuard.TRecord(left))
+            return Record(left, right);
+        if (TypeGuard.TString(left))
+            return String(left, right);
+        if (TypeGuard.TSymbol(left))
+            return Symbol(left, right);
+        if (TypeGuard.TObject(left))
+            return Object(left, right);
+        if (TypeGuard.TTuple(left))
+            return Tuple(left, right);
+        if (TypeGuard.TPromise(left))
+            return Promise(left, right);
+        if (TypeGuard.TUint8Array(left))
+            return Uint8Array(left, right);
+        if (TypeGuard.TUndefined(left))
+            return Undefined(left, right);
+        if (TypeGuard.TUnion(left))
+            return Union(left, right);
+        if (TypeGuard.TUnknown(left))
+            return Unknown(left, right);
+        if (TypeGuard.TVoid(left))
+            return Void(left, right);
         throw Error(`TypeExtends: Unknown left type operand '${left[exports.Kind]}'`);
     }
     function Extends(left, right) {
@@ -1367,14 +1317,11 @@ var TypeExtends;
 // --------------------------------------------------------------------------
 // TypeClone
 // --------------------------------------------------------------------------
-/** Specialized Clone for Types. Clones and removes non self-referential identifiers */
+/** Specialized Clone for Types */
 var TypeClone;
 (function (TypeClone) {
-    function IsRecursive(value) {
-        return typeof value[exports.Recursive] === 'string';
-    }
     function IsObject(value) {
-        return typeof value === 'object' && value !== null && !globalThis.Array.isArray(value);
+        return typeof value === 'object' && value !== null;
     }
     function IsArray(value) {
         return globalThis.Array.isArray(value);
@@ -1383,22 +1330,24 @@ var TypeClone;
         return value.map((value) => Visit(value));
     }
     function Object(value) {
-        const clone = globalThis.Object.getOwnPropertyNames(value).reduce((acc, key) => ({ ...acc, [key]: Visit(value[key]) }), globalThis.Object.getOwnPropertySymbols(value).reduce((acc, key) => ({ ...acc, [key]: Visit(value[key]) }), {}));
-        return clone;
+        const clonedProperties = globalThis.Object.getOwnPropertyNames(value).reduce((acc, key) => {
+            return { ...acc, [key]: Visit(value[key]) };
+        }, {});
+        const clonedSymbols = globalThis.Object.getOwnPropertySymbols(value).reduce((acc, key) => {
+            return { ...acc, [key]: Visit(value[key]) };
+        }, {});
+        return { ...clonedProperties, ...clonedSymbols };
     }
     function Visit(value) {
-        const clone = IsObject(value) ? { ...value } : IsArray(value) ? [...value] : value;
-        if (IsObject(clone) && !IsRecursive(clone))
-            delete clone['$id'];
-        if (IsObject(clone))
-            return Object(clone);
-        if (IsArray(clone))
-            return Array(clone);
-        return clone;
+        if (IsArray(value))
+            return Array(value);
+        if (IsObject(value))
+            return Object(value);
+        return value;
     }
     /** Clones a type. This function will omit non-self referential identifiers on the cloned type. */
     function Clone(schema, options) {
-        return { ...Visit({ ...schema }), ...options };
+        return { ...Visit(schema), ...options };
     }
     TypeClone.Clone = Clone;
 })(TypeClone = exports.TypeClone || (exports.TypeClone = {}));
@@ -1408,10 +1357,10 @@ var TypeClone;
 var ObjectMap;
 (function (ObjectMap) {
     function Intersect(schema, callback) {
-        return exports.Type.Intersect(schema.allOf.map((inner) => Visit(ReferenceRegistry.Deref(inner), callback)), { ...schema });
+        return exports.Type.Intersect(schema.allOf.map((inner) => Visit(inner, callback)), { ...schema });
     }
     function Union(schema, callback) {
-        return exports.Type.Union(schema.anyOf.map((inner) => Visit(ReferenceRegistry.Deref(inner), callback)), { ...schema });
+        return exports.Type.Union(schema.anyOf.map((inner) => Visit(inner, callback)), { ...schema });
     }
     function Object(schema, callback) {
         return callback(schema);
@@ -1472,7 +1421,6 @@ let TypeOrdinal = 0;
 class TypeBuilder {
     /** `[Utility]` Creates a schema without `static` and `params` types */
     Create(schema) {
-        ReferenceRegistry.Set(schema);
         return schema;
     }
     /** `[Standard]` Omits compositing symbols from this schema */
@@ -1515,8 +1463,8 @@ class StandardTypeBuilder extends TypeBuilder {
     Boolean(options = {}) {
         return this.Create({ ...options, [exports.Kind]: 'Boolean', type: 'boolean' });
     }
-    /** `[Standard]` Creates a Composite object type that will Union any overlapping properties of the given Object array */
-    Composite(schemas, options = {}) {
+    Composite(unresolved, options = {}) {
+        const schemas = TypeGuard.TIntersect(unresolved) ? unresolved.allOf : unresolved;
         const optional = new Set();
         for (const schema of schemas) {
             for (const [key, property] of globalThis.Object.entries(schema.properties)) {
@@ -1533,10 +1481,6 @@ class StandardTypeBuilder extends TypeBuilder {
         }
         return this.Object(properties, options);
     }
-    /** `[Standard]` Dereferences the given TRef to its target type */
-    Deref(schema) {
-        return ReferenceRegistry.Deref(schema);
-    }
     /** `[Standard]` Creates a Enum type */
     Enum(item, options = {}) {
         // prettier-ignore
@@ -1546,7 +1490,7 @@ class StandardTypeBuilder extends TypeBuilder {
     }
     /** `[Standard]` A conditional type expression that will return the true type if the left type extends the right */
     Extends(left, right, trueType, falseType, options = {}) {
-        switch (TypeExtends.Extends(ReferenceRegistry.Deref(left), ReferenceRegistry.Deref(right))) {
+        switch (TypeExtends.Extends(left, right)) {
             case TypeExtendsResult.Union:
                 return this.Union([TypeClone.Clone(trueType, options), TypeClone.Clone(falseType, options)]);
             case TypeExtendsResult.True:
@@ -1596,7 +1540,7 @@ class StandardTypeBuilder extends TypeBuilder {
     }
     /** `[Standard]` Creates a KeyOf type */
     KeyOf(schema, options = {}) {
-        const keys = KeyResolver.Resolve(ReferenceRegistry.Deref(schema));
+        const keys = KeyResolver.Resolve(schema);
         // prettier-ignore
         const keyof = keys.length === 0 ? this.Never(options) : this.Union(keys.map((key) => this.Literal(key)), options);
         return keyof;
@@ -1623,15 +1567,13 @@ class StandardTypeBuilder extends TypeBuilder {
     }
     /** `[Standard]` Creates an Object type */
     Object(properties, options = {}) {
-        const keys = globalThis.Object.keys(properties);
-        const optional = keys.filter((key) => TypeGuard.TOptional(properties[key]) || TypeGuard.TReadonlyOptional(properties[key]));
-        const required = keys.filter((name) => !optional.includes(name));
+        const propertyKeys = globalThis.Object.getOwnPropertyNames(properties);
+        const optionalKeys = propertyKeys.filter((key) => TypeGuard.TOptional(properties[key]) || TypeGuard.TReadonlyOptional(properties[key]));
+        const requiredKeys = propertyKeys.filter((name) => !optionalKeys.includes(name));
         const clonedAdditionalProperties = TypeGuard.TSchema(options.additionalProperties) ? { additionalProperties: TypeClone.Clone(options.additionalProperties, {}) } : {};
-        const clonedProperties = globalThis.Object.getOwnPropertyNames(properties).reduce((acc, key) => {
-            return { ...acc, [key]: TypeClone.Clone(properties[key], {}) };
-        }, {});
-        if (required.length > 0) {
-            return this.Create({ ...options, ...clonedAdditionalProperties, [exports.Kind]: 'Object', type: 'object', properties: clonedProperties, required });
+        const clonedProperties = propertyKeys.reduce((acc, key) => ({ ...acc, [key]: TypeClone.Clone(properties[key], {}) }), {});
+        if (requiredKeys.length > 0) {
+            return this.Create({ ...options, ...clonedAdditionalProperties, [exports.Kind]: 'Object', type: 'object', properties: clonedProperties, required: requiredKeys });
         }
         else {
             return this.Create({ ...options, ...clonedAdditionalProperties, [exports.Kind]: 'Object', type: 'object', properties: clonedProperties });
@@ -1644,7 +1586,7 @@ class StandardTypeBuilder extends TypeBuilder {
                 TypeGuard.TNever(unresolved) ? [] :
                     unresolved;
         // prettier-ignore
-        return ObjectMap.Map(TypeClone.Clone(ReferenceRegistry.Deref(schema), {}), (schema) => {
+        return ObjectMap.Map(TypeClone.Clone(schema, {}), (schema) => {
             if (schema.required) {
                 schema.required = schema.required.filter((key) => !keys.includes(key));
                 if (schema.required.length === 0)
@@ -1677,7 +1619,7 @@ class StandardTypeBuilder extends TypeBuilder {
             }
         }
         // prettier-ignore
-        return ObjectMap.Map(TypeClone.Clone(ReferenceRegistry.Deref(schema), {}), (schema) => {
+        return ObjectMap.Map(TypeClone.Clone(schema, {}), (schema) => {
             delete schema.required;
             globalThis.Object.keys(schema.properties).forEach(key => Apply(schema.properties[key]));
             return schema;
@@ -1690,7 +1632,7 @@ class StandardTypeBuilder extends TypeBuilder {
                 TypeGuard.TNever(unresolved) ? [] :
                     unresolved;
         // prettier-ignore
-        return ObjectMap.Map(TypeClone.Clone(ReferenceRegistry.Deref(schema), {}), (schema) => {
+        return ObjectMap.Map(TypeClone.Clone(schema, {}), (schema) => {
             if (schema.required) {
                 schema.required = schema.required.filter((key) => keys.includes(key));
                 if (schema.required.length === 0)
@@ -1733,9 +1675,8 @@ class StandardTypeBuilder extends TypeBuilder {
         if (options.$id === undefined)
             options.$id = `T${TypeOrdinal++}`;
         const self = callback({ [exports.Kind]: 'Self', $ref: `${options.$id}` });
-        const reassign = self;
-        reassign.$id = options.$id; // required as $id is readonly
-        return this.Create({ ...options, ...self, [exports.Recursive]: reassign.$id });
+        self.$id = options.$id;
+        return this.Create({ ...options, ...self });
     }
     /** `[Standard]` Creates a Ref type. The referenced type must contain a $id */
     Ref(schema, options = {}) {
@@ -1763,7 +1704,7 @@ class StandardTypeBuilder extends TypeBuilder {
             }
         }
         // prettier-ignore
-        return ObjectMap.Map(TypeClone.Clone(ReferenceRegistry.Deref(schema), {}), (schema) => {
+        return ObjectMap.Map(TypeClone.Clone(schema, {}), (schema) => {
             schema.required = globalThis.Object.keys(schema.properties);
             globalThis.Object.keys(schema.properties).forEach(key => Apply(schema.properties[key]));
             return schema;

package/value/cast.d.ts

@@ -20,7 +20,11 @@ export declare class ValueCastUnknownTypeError extends Error {
     readonly schema: Types.TSchema;
     constructor(schema: Types.TSchema);
 }
+export declare class ValueCastDereferenceError extends Error {
+    readonly schema: Types.TRef | Types.TSelf;
+    constructor(schema: Types.TRef | Types.TSelf);
+}
 export declare namespace ValueCast {
-    function Visit(schema: Types.TSchema, value: any): any;
-    function Cast<T extends Types.TSchema>(schema: T, value: any): Types.Static<T>;
+    function Visit(schema: Types.TSchema, references: Types.TSchema[], value: any): any;
+    function Cast<T extends Types.TSchema>(schema: T, references: Types.TSchema[], value: any): Types.Static<T>;
 }