@sinclair/typebox 0.25.24 → 0.26.0-dev.1

package/value/cast.d.ts

@@ -21,6 +21,6 @@ export declare class ValueCastUnknownTypeError extends Error {
     constructor(schema: Types.TSchema);
 }
 export declare namespace ValueCast {
-    function Visit(schema: Types.TSchema, references: Types.TSchema[], value: any): any;
-    function Cast<T extends Types.TSchema, R extends Types.TSchema[]>(schema: T, references: [...R], value: any): Types.Static<T>;
+    function Visit(schema: Types.TSchema, value: any): any;
+    function Cast<T extends Types.TSchema>(schema: T, value: any): Types.Static<T>;
 }

package/value/cast.js

@@ -32,7 +32,6 @@ const Types = require("../typebox");
 const create_1 = require("./create");
 const check_1 = require("./check");
 const clone_1 = require("./clone");
-const index_1 = require("../custom/index");
 // ----------------------------------------------------------------------------------------------
 // Errors
 // ----------------------------------------------------------------------------------------------
@@ -80,7 +79,7 @@ exports.ValueCastUnknownTypeError = ValueCastUnknownTypeError;
 // ----------------------------------------------------------------------------------------------
 var UnionCastCreate;
 (function (UnionCastCreate) {
-    function Score(schema, references, value) {
+    function Score(schema, value) {
         if (schema[Types.Kind] === 'Object' && typeof value === 'object' && value !== null) {
             const object = schema;
             const keys = Object.keys(value);
@@ -88,19 +87,19 @@ var UnionCastCreate;
             const [point, max] = [1 / entries.length, entries.length];
             return entries.reduce((acc, [key, schema]) => {
                 const literal = schema[Types.Kind] === 'Literal' && schema.const === value[key] ? max : 0;
-                const checks = check_1.ValueCheck.Check(schema, references, value[key]) ? point : 0;
+                const checks = check_1.ValueCheck.Check(schema, value[key]) ? point : 0;
                 const exists = keys.includes(key) ? point : 0;
                 return acc + (literal + checks + exists);
             }, 0);
         }
         else {
-            return check_1.ValueCheck.Check(schema, references, value) ? 1 : 0;
+            return check_1.ValueCheck.Check(schema, value) ? 1 : 0;
         }
     }
-    function Select(union, references, value) {
+    function Select(union, value) {
         let [select, best] = [union.anyOf[0], 0];
         for (const schema of union.anyOf) {
-            const score = Score(schema, references, value);
+            const score = Score(schema, value);
             if (score > best) {
                 select = schema;
                 best = score;
@@ -108,13 +107,13 @@ var UnionCastCreate;
         }
         return select;
     }
-    function Create(union, references, value) {
+    function Create(union, value) {
         if (union.default !== undefined) {
             return union.default;
         }
         else {
-            const schema = Select(union, references, value);
-            return ValueCast.Cast(schema, references, value);
+            const schema = Select(union, value);
+            return ValueCast.Cast(schema, value);
         }
     }
     UnionCastCreate.Create = Create;
@@ -124,162 +123,93 @@ var ValueCast;
     // ----------------------------------------------------------------------------------------------
     // Guards
     // ----------------------------------------------------------------------------------------------
+    function IsObject(value) {
+        return typeof value === 'object' && value !== null && !globalThis.Array.isArray(value);
+    }
     function IsArray(value) {
         return typeof value === 'object' && globalThis.Array.isArray(value);
     }
-    function IsDate(value) {
-        return typeof value === 'object' && value instanceof globalThis.Date;
-    }
-    function IsString(value) {
-        return typeof value === 'string';
-    }
-    function IsBoolean(value) {
-        return typeof value === 'boolean';
-    }
-    function IsBigInt(value) {
-        return typeof value === 'bigint';
-    }
     function IsNumber(value) {
         return typeof value === 'number' && !isNaN(value);
     }
-    function IsStringNumeric(value) {
-        return IsString(value) && !isNaN(value) && !isNaN(parseFloat(value));
-    }
-    function IsValueToString(value) {
-        return IsBigInt(value) || IsBoolean(value) || IsNumber(value);
-    }
-    function IsValueTrue(value) {
-        return value === true || (IsNumber(value) && value === 1) || (IsBigInt(value) && value === globalThis.BigInt('1')) || (IsString(value) && (value.toLowerCase() === 'true' || value === '1'));
-    }
-    function IsValueFalse(value) {
-        return value === false || (IsNumber(value) && value === 0) || (IsBigInt(value) && value === globalThis.BigInt('0')) || (IsString(value) && (value.toLowerCase() === 'false' || value === '0'));
-    }
-    function IsTimeStringWithTimeZone(value) {
-        return IsString(value) && /^(?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)(?:\.\d+)?(?:z|[+-]\d\d(?::?\d\d)?)$/i.test(value);
-    }
-    function IsTimeStringWithoutTimeZone(value) {
-        return IsString(value) && /^(?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)?$/i.test(value);
-    }
-    function IsDateTimeStringWithTimeZone(value) {
-        return IsString(value) && /^\d\d\d\d-[0-1]\d-[0-3]\dt(?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)(?:\.\d+)?(?:z|[+-]\d\d(?::?\d\d)?)$/i.test(value);
-    }
-    function IsDateTimeStringWithoutTimeZone(value) {
-        return IsString(value) && /^\d\d\d\d-[0-1]\d-[0-3]\dt(?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)?$/i.test(value);
-    }
-    function IsDateString(value) {
-        return IsString(value) && /^\d\d\d\d-[0-1]\d-[0-3]\d$/i.test(value);
-    }
-    // ----------------------------------------------------------------------------------------------
-    // Convert
-    // ----------------------------------------------------------------------------------------------
-    function TryConvertString(value) {
-        return IsValueToString(value) ? value.toString() : value;
-    }
-    function TryConvertNumber(value) {
-        return IsStringNumeric(value) ? parseFloat(value) : IsValueTrue(value) ? 1 : value;
-    }
-    function TryConvertInteger(value) {
-        return IsStringNumeric(value) ? parseInt(value) : IsValueTrue(value) ? 1 : value;
-    }
-    function TryConvertBoolean(value) {
-        return IsValueTrue(value) ? true : IsValueFalse(value) ? false : value;
-    }
-    function TryConvertDate(value) {
-        // note: this function may return an invalid dates for the regex tests
-        // above. Invalid dates will however be checked during the casting
-        // function and will return a epoch date if invalid. Consider better
-        // string parsing for the iso dates in future revisions.
-        return IsDate(value)
-            ? value
-            : IsNumber(value)
-                ? new globalThis.Date(value)
-                : IsValueTrue(value)
-                    ? new globalThis.Date(1)
-                    : IsStringNumeric(value)
-                        ? new globalThis.Date(parseInt(value))
-                        : IsTimeStringWithoutTimeZone(value)
-                            ? new globalThis.Date(`1970-01-01T${value}.000Z`)
-                            : IsTimeStringWithTimeZone(value)
-                                ? new globalThis.Date(`1970-01-01T${value}`)
-                                : IsDateTimeStringWithoutTimeZone(value)
-                                    ? new globalThis.Date(`${value}.000Z`)
-                                    : IsDateTimeStringWithTimeZone(value)
-                                        ? new globalThis.Date(value)
-                                        : IsDateString(value)
-                                            ? new globalThis.Date(`${value}T00:00:00.000Z`)
-                                            : value;
-    }
     // ----------------------------------------------------------------------------------------------
     // Cast
     // ----------------------------------------------------------------------------------------------
-    function Any(schema, references, value) {
-        return check_1.ValueCheck.Check(schema, references, value) ? clone_1.ValueClone.Clone(value) : create_1.ValueCreate.Create(schema, references);
+    function Any(schema, value) {
+        return check_1.ValueCheck.Check(schema, value) ? clone_1.ValueClone.Clone(value) : create_1.ValueCreate.Create(schema);
     }
-    function Array(schema, references, value) {
-        if (check_1.ValueCheck.Check(schema, references, value))
+    function Array(schema, value) {
+        if (check_1.ValueCheck.Check(schema, value))
             return clone_1.ValueClone.Clone(value);
-        const created = IsArray(value) ? clone_1.ValueClone.Clone(value) : create_1.ValueCreate.Create(schema, references);
+        const created = IsArray(value) ? clone_1.ValueClone.Clone(value) : create_1.ValueCreate.Create(schema);
         const minimum = IsNumber(schema.minItems) && created.length < schema.minItems ? [...created, ...globalThis.Array.from({ length: schema.minItems - created.length }, () => null)] : created;
         const maximum = IsNumber(schema.maxItems) && minimum.length > schema.maxItems ? minimum.slice(0, schema.maxItems) : minimum;
-        const casted = maximum.map((value) => Visit(schema.items, references, value));
+        const casted = maximum.map((value) => Visit(schema.items, value));
         if (schema.uniqueItems !== true)
             return casted;
         const unique = [...new Set(casted)];
-        if (!check_1.ValueCheck.Check(schema, references, unique))
+        if (!check_1.ValueCheck.Check(schema, unique))
             throw new ValueCastArrayUniqueItemsTypeError(schema, unique);
         return unique;
     }
-    function Boolean(schema, references, value) {
-        const conversion = TryConvertBoolean(value);
-        return check_1.ValueCheck.Check(schema, references, conversion) ? conversion : create_1.ValueCreate.Create(schema, references);
+    function BigInt(schema, value) {
+        return check_1.ValueCheck.Check(schema, value) ? value : create_1.ValueCreate.Create(schema);
     }
-    function Constructor(schema, references, value) {
-        if (check_1.ValueCheck.Check(schema, references, value))
-            return create_1.ValueCreate.Create(schema, references);
+    function Boolean(schema, value) {
+        return check_1.ValueCheck.Check(schema, value) ? value : create_1.ValueCreate.Create(schema);
+    }
+    function Constructor(schema, value) {
+        if (check_1.ValueCheck.Check(schema, value))
+            return create_1.ValueCreate.Create(schema);
         const required = new Set(schema.returns.required || []);
         const result = function () { };
         for (const [key, property] of globalThis.Object.entries(schema.returns.properties)) {
             if (!required.has(key) && value.prototype[key] === undefined)
                 continue;
-            result.prototype[key] = Visit(property, references, value.prototype[key]);
+            result.prototype[key] = Visit(property, value.prototype[key]);
         }
         return result;
     }
-    function Date(schema, references, value) {
-        const conversion = TryConvertDate(value);
-        return check_1.ValueCheck.Check(schema, references, conversion) ? clone_1.ValueClone.Clone(conversion) : create_1.ValueCreate.Create(schema, references);
+    function Date(schema, value) {
+        return check_1.ValueCheck.Check(schema, value) ? clone_1.ValueClone.Clone(value) : create_1.ValueCreate.Create(schema);
+    }
+    function Function(schema, value) {
+        return check_1.ValueCheck.Check(schema, value) ? value : create_1.ValueCreate.Create(schema);
     }
-    function Function(schema, references, value) {
-        return check_1.ValueCheck.Check(schema, references, value) ? value : create_1.ValueCreate.Create(schema, references);
+    function Integer(schema, value) {
+        return check_1.ValueCheck.Check(schema, value) ? value : create_1.ValueCreate.Create(schema);
     }
-    function Integer(schema, references, value) {
-        const conversion = TryConvertInteger(value);
-        return check_1.ValueCheck.Check(schema, references, conversion) ? conversion : create_1.ValueCreate.Create(schema, references);
+    function Intersect(schema, value) {
+        const created = create_1.ValueCreate.Create(schema);
+        const mapped = IsObject(created) && IsObject(value) ? { ...created, ...value } : value;
+        return check_1.ValueCheck.Check(schema, mapped) ? mapped : create_1.ValueCreate.Create(schema);
     }
-    function Literal(schema, references, value) {
-        return check_1.ValueCheck.Check(schema, references, value) ? clone_1.ValueClone.Clone(value) : create_1.ValueCreate.Create(schema, references);
+    function Literal(schema, value) {
+        return check_1.ValueCheck.Check(schema, value) ? value : create_1.ValueCreate.Create(schema);
     }
-    function Never(schema, references, value) {
+    function Never(schema, value) {
         throw new ValueCastNeverTypeError(schema);
     }
-    function Null(schema, references, value) {
-        return check_1.ValueCheck.Check(schema, references, value) ? clone_1.ValueClone.Clone(value) : create_1.ValueCreate.Create(schema, references);
+    function Not(schema, value) {
+        return check_1.ValueCheck.Check(schema, value) ? value : create_1.ValueCreate.Create(schema.allOf[1]);
     }
-    function Number(schema, references, value) {
-        const conversion = TryConvertNumber(value);
-        return check_1.ValueCheck.Check(schema, references, conversion) ? conversion : create_1.ValueCreate.Create(schema, references);
+    function Null(schema, value) {
+        return check_1.ValueCheck.Check(schema, value) ? value : create_1.ValueCreate.Create(schema);
     }
-    function Object(schema, references, value) {
-        if (check_1.ValueCheck.Check(schema, references, value))
-            return clone_1.ValueClone.Clone(value);
+    function Number(schema, value) {
+        return check_1.ValueCheck.Check(schema, value) ? value : create_1.ValueCreate.Create(schema);
+    }
+    function Object(schema, value) {
+        if (check_1.ValueCheck.Check(schema, value))
+            return value;
         if (value === null || typeof value !== 'object')
-            return create_1.ValueCreate.Create(schema, references);
+            return create_1.ValueCreate.Create(schema);
         const required = new Set(schema.required || []);
         const result = {};
         for (const [key, property] of globalThis.Object.entries(schema.properties)) {
             if (!required.has(key) && value[key] === undefined)
                 continue;
-            result[key] = Visit(property, references, value[key]);
+            result[key] = Visit(property, value[key]);
         }
         // additional schema properties
         if (typeof schema.additionalProperties === 'object') {
@@ -287,129 +217,132 @@ var ValueCast;
             for (const propertyName of globalThis.Object.getOwnPropertyNames(value)) {
                 if (propertyNames.includes(propertyName))
                     continue;
-                result[propertyName] = Visit(schema.additionalProperties, references, value[propertyName]);
+                result[propertyName] = Visit(schema.additionalProperties, value[propertyName]);
             }
         }
         return result;
     }
-    function Promise(schema, references, value) {
-        return check_1.ValueCheck.Check(schema, references, value) ? value : create_1.ValueCreate.Create(schema, references);
+    function Promise(schema, value) {
+        return check_1.ValueCheck.Check(schema, value) ? value : create_1.ValueCreate.Create(schema);
     }
-    function Record(schema, references, value) {
-        if (check_1.ValueCheck.Check(schema, references, value))
+    function Record(schema, value) {
+        if (check_1.ValueCheck.Check(schema, value))
             return clone_1.ValueClone.Clone(value);
         if (value === null || typeof value !== 'object' || globalThis.Array.isArray(value) || value instanceof globalThis.Date)
-            return create_1.ValueCreate.Create(schema, references);
+            return create_1.ValueCreate.Create(schema);
         const subschemaPropertyName = globalThis.Object.getOwnPropertyNames(schema.patternProperties)[0];
         const subschema = schema.patternProperties[subschemaPropertyName];
         const result = {};
         for (const [propKey, propValue] of globalThis.Object.entries(value)) {
-            result[propKey] = Visit(subschema, references, propValue);
+            result[propKey] = Visit(subschema, propValue);
         }
         return result;
     }
-    function Ref(schema, references, value) {
-        const reference = references.find((reference) => reference.$id === schema.$ref);
-        if (reference === undefined)
-            throw new ValueCastReferenceTypeError(schema);
-        return Visit(reference, references, value);
+    function Ref(schema, value) {
+        return Visit(Types.ReferenceRegistry.DerefOne(schema), value);
+    }
+    function Self(schema, value) {
+        return Visit(Types.ReferenceRegistry.DerefOne(schema), value);
     }
-    function Self(schema, references, value) {
-        const reference = references.find((reference) => reference.$id === schema.$ref);
-        if (reference === undefined)
-            throw new ValueCastReferenceTypeError(schema);
-        return Visit(reference, references, value);
+    function String(schema, value) {
+        return check_1.ValueCheck.Check(schema, value) ? value : create_1.ValueCreate.Create(schema);
     }
-    function String(schema, references, value) {
-        const conversion = TryConvertString(value);
-        return check_1.ValueCheck.Check(schema, references, conversion) ? conversion : create_1.ValueCreate.Create(schema, references);
+    function Symbol(schema, value) {
+        return check_1.ValueCheck.Check(schema, value) ? clone_1.ValueClone.Clone(value) : create_1.ValueCreate.Create(schema);
     }
-    function Tuple(schema, references, value) {
-        if (check_1.ValueCheck.Check(schema, references, value))
+    function Tuple(schema, value) {
+        if (check_1.ValueCheck.Check(schema, value))
             return clone_1.ValueClone.Clone(value);
         if (!globalThis.Array.isArray(value))
-            return create_1.ValueCreate.Create(schema, references);
+            return create_1.ValueCreate.Create(schema);
         if (schema.items === undefined)
             return [];
-        return schema.items.map((schema, index) => Visit(schema, references, value[index]));
+        return schema.items.map((schema, index) => Visit(schema, value[index]));
     }
-    function Undefined(schema, references, value) {
-        return check_1.ValueCheck.Check(schema, references, value) ? clone_1.ValueClone.Clone(value) : create_1.ValueCreate.Create(schema, references);
+    function Undefined(schema, value) {
+        return check_1.ValueCheck.Check(schema, value) ? clone_1.ValueClone.Clone(value) : create_1.ValueCreate.Create(schema);
     }
-    function Union(schema, references, value) {
-        return check_1.ValueCheck.Check(schema, references, value) ? clone_1.ValueClone.Clone(value) : UnionCastCreate.Create(schema, references, value);
+    function Union(schema, value) {
+        return check_1.ValueCheck.Check(schema, value) ? clone_1.ValueClone.Clone(value) : UnionCastCreate.Create(schema, value);
     }
-    function Uint8Array(schema, references, value) {
-        return check_1.ValueCheck.Check(schema, references, value) ? clone_1.ValueClone.Clone(value) : create_1.ValueCreate.Create(schema, references);
+    function Uint8Array(schema, value) {
+        return check_1.ValueCheck.Check(schema, value) ? clone_1.ValueClone.Clone(value) : create_1.ValueCreate.Create(schema);
     }
-    function Unknown(schema, references, value) {
-        return check_1.ValueCheck.Check(schema, references, value) ? clone_1.ValueClone.Clone(value) : create_1.ValueCreate.Create(schema, references);
+    function Unknown(schema, value) {
+        return check_1.ValueCheck.Check(schema, value) ? clone_1.ValueClone.Clone(value) : create_1.ValueCreate.Create(schema);
     }
-    function Void(schema, references, value) {
-        return check_1.ValueCheck.Check(schema, references, value) ? clone_1.ValueClone.Clone(value) : create_1.ValueCreate.Create(schema, references);
+    function Void(schema, value) {
+        return check_1.ValueCheck.Check(schema, value) ? clone_1.ValueClone.Clone(value) : create_1.ValueCreate.Create(schema);
     }
-    function UserDefined(schema, references, value) {
-        return check_1.ValueCheck.Check(schema, references, value) ? clone_1.ValueClone.Clone(value) : create_1.ValueCreate.Create(schema, references);
+    function UserDefined(schema, value) {
+        return check_1.ValueCheck.Check(schema, value) ? clone_1.ValueClone.Clone(value) : create_1.ValueCreate.Create(schema);
     }
-    function Visit(schema, references, value) {
-        const anyReferences = schema.$id === undefined ? references : [schema, ...references];
+    function Visit(schema, value) {
         const anySchema = schema;
         switch (schema[Types.Kind]) {
             case 'Any':
-                return Any(anySchema, anyReferences, value);
+                return Any(anySchema, value);
             case 'Array':
-                return Array(anySchema, anyReferences, value);
+                return Array(anySchema, value);
+            case 'BigInt':
+                return BigInt(anySchema, value);
             case 'Boolean':
-                return Boolean(anySchema, anyReferences, value);
+                return Boolean(anySchema, value);
             case 'Constructor':
-                return Constructor(anySchema, anyReferences, value);
+                return Constructor(anySchema, value);
             case 'Date':
-                return Date(anySchema, anyReferences, value);
+                return Date(anySchema, value);
             case 'Function':
-                return Function(anySchema, anyReferences, value);
+                return Function(anySchema, value);
             case 'Integer':
-                return Integer(anySchema, anyReferences, value);
+                return Integer(anySchema, value);
+            case 'Intersect':
+                return Intersect(anySchema, value);
             case 'Literal':
-                return Literal(anySchema, anyReferences, value);
+                return Literal(anySchema, value);
             case 'Never':
-                return Never(anySchema, anyReferences, value);
+                return Never(anySchema, value);
+            case 'Not':
+                return Not(anySchema, value);
             case 'Null':
-                return Null(anySchema, anyReferences, value);
+                return Null(anySchema, value);
             case 'Number':
-                return Number(anySchema, anyReferences, value);
+                return Number(anySchema, value);
             case 'Object':
-                return Object(anySchema, anyReferences, value);
+                return Object(anySchema, value);
             case 'Promise':
-                return Promise(anySchema, anyReferences, value);
+                return Promise(anySchema, value);
             case 'Record':
-                return Record(anySchema, anyReferences, value);
+                return Record(anySchema, value);
             case 'Ref':
-                return Ref(anySchema, anyReferences, value);
+                return Ref(anySchema, value);
             case 'Self':
-                return Self(anySchema, anyReferences, value);
+                return Self(anySchema, value);
             case 'String':
-                return String(anySchema, anyReferences, value);
+                return String(anySchema, value);
+            case 'Symbol':
+                return Symbol(anySchema, value);
             case 'Tuple':
-                return Tuple(anySchema, anyReferences, value);
+                return Tuple(anySchema, value);
             case 'Undefined':
-                return Undefined(anySchema, anyReferences, value);
+                return Undefined(anySchema, value);
             case 'Union':
-                return Union(anySchema, anyReferences, value);
+                return Union(anySchema, value);
             case 'Uint8Array':
-                return Uint8Array(anySchema, anyReferences, value);
+                return Uint8Array(anySchema, value);
             case 'Unknown':
-                return Unknown(anySchema, anyReferences, value);
+                return Unknown(anySchema, value);
             case 'Void':
-                return Void(anySchema, anyReferences, value);
+                return Void(anySchema, value);
             default:
-                if (!index_1.Custom.Has(anySchema[Types.Kind]))
+                if (!Types.TypeRegistry.Has(anySchema[Types.Kind]))
                     throw new ValueCastUnknownTypeError(anySchema);
-                return UserDefined(anySchema, anyReferences, value);
+                return UserDefined(anySchema, value);
         }
     }
     ValueCast.Visit = Visit;
-    function Cast(schema, references, value) {
-        return schema.$id === undefined ? Visit(schema, references, value) : Visit(schema, [schema, ...references], value);
+    function Cast(schema, value) {
+        return Visit(schema, clone_1.ValueClone.Clone(value));
     }
     ValueCast.Cast = Cast;
 })(ValueCast = exports.ValueCast || (exports.ValueCast = {}));

package/value/check.d.ts

@@ -4,5 +4,5 @@ export declare class ValueCheckUnknownTypeError extends Error {
     constructor(schema: Types.TSchema);
 }
 export declare namespace ValueCheck {
-    function Check<T extends Types.TSchema, R extends Types.TSchema[]>(schema: T, references: [...R], value: any): boolean;
+    function Check<T extends Types.TSchema>(schema: T, value: any): boolean;
 }