@sinclair/typebox 0.30.3 → 0.31.0-dev-1

package/value/cast.d.ts

@@ -1,29 +1,23 @@
 import * as Types from '../typebox';
-export declare class ValueCastReferenceTypeError extends Error {
-    readonly schema: Types.TRef | Types.TThis;
-    constructor(schema: Types.TRef | Types.TThis);
-}
-export declare class ValueCastArrayUniqueItemsTypeError extends Error {
+export declare class ValueCastArrayUniqueItemsTypeError extends Types.TypeBoxError {
     readonly schema: Types.TSchema;
     readonly value: unknown;
     constructor(schema: Types.TSchema, value: unknown);
 }
-export declare class ValueCastNeverTypeError extends Error {
+export declare class ValueCastNeverTypeError extends Types.TypeBoxError {
     readonly schema: Types.TSchema;
     constructor(schema: Types.TSchema);
 }
-export declare class ValueCastRecursiveTypeError extends Error {
+export declare class ValueCastRecursiveTypeError extends Types.TypeBoxError {
     readonly schema: Types.TSchema;
     constructor(schema: Types.TSchema);
 }
-export declare class ValueCastUnknownTypeError extends Error {
+export declare class ValueCastUnknownTypeError extends Types.TypeBoxError {
     readonly schema: Types.TSchema;
     constructor(schema: Types.TSchema);
 }
-export declare class ValueCastDereferenceError extends Error {
-    readonly schema: Types.TRef | Types.TThis;
-    constructor(schema: Types.TRef | Types.TThis);
-}
+export declare function DefaultClone(schema: Types.TSchema, references: Types.TSchema[], value: any): any;
+export declare function Default(schema: Types.TSchema, references: Types.TSchema[], value: any): any;
 /** Casts a value into a given type and references. The return value will retain as much information of the original value as possible. */
 export declare function Cast<T extends Types.TSchema>(schema: T, references: Types.TSchema[], value: unknown): Types.Static<T>;
 /** Casts a value into a given type. The return value will retain as much information of the original value as possible. */

package/value/cast.js

@@ -27,58 +27,45 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Cast = exports.ValueCastDereferenceError = exports.ValueCastUnknownTypeError = exports.ValueCastRecursiveTypeError = exports.ValueCastNeverTypeError = exports.ValueCastArrayUniqueItemsTypeError = exports.ValueCastReferenceTypeError = void 0;
+exports.Cast = exports.Default = exports.DefaultClone = exports.ValueCastUnknownTypeError = exports.ValueCastRecursiveTypeError = exports.ValueCastNeverTypeError = exports.ValueCastArrayUniqueItemsTypeError = void 0;
+const guard_1 = require("./guard");
+const create_1 = require("./create");
+const check_1 = require("./check");
+const clone_1 = require("./clone");
+const deref_1 = require("./deref");
 const Types = require("../typebox");
-const ValueCreate = require("./create");
-const ValueCheck = require("./check");
-const ValueClone = require("./clone");
-const ValueGuard = require("./guard");
 // --------------------------------------------------------------------------
 // Errors
 // --------------------------------------------------------------------------
-class ValueCastReferenceTypeError extends Error {
-    constructor(schema) {
-        super(`ValueCast: Cannot locate referenced schema with $id '${schema.$ref}'`);
-        this.schema = schema;
-    }
-}
-exports.ValueCastReferenceTypeError = ValueCastReferenceTypeError;
-class ValueCastArrayUniqueItemsTypeError extends Error {
+class ValueCastArrayUniqueItemsTypeError extends Types.TypeBoxError {
     constructor(schema, value) {
-        super('ValueCast: Array cast produced invalid data due to uniqueItems constraint');
+        super('Array cast produced invalid data due to uniqueItems constraint');
         this.schema = schema;
         this.value = value;
     }
 }
 exports.ValueCastArrayUniqueItemsTypeError = ValueCastArrayUniqueItemsTypeError;
-class ValueCastNeverTypeError extends Error {
+class ValueCastNeverTypeError extends Types.TypeBoxError {
     constructor(schema) {
-        super('ValueCast: Never types cannot be cast');
+        super('Never types cannot be cast');
         this.schema = schema;
     }
 }
 exports.ValueCastNeverTypeError = ValueCastNeverTypeError;
-class ValueCastRecursiveTypeError extends Error {
+class ValueCastRecursiveTypeError extends Types.TypeBoxError {
     constructor(schema) {
-        super('ValueCast.Recursive: Cannot cast recursive schemas');
+        super('Cannot cast recursive schemas');
         this.schema = schema;
     }
 }
 exports.ValueCastRecursiveTypeError = ValueCastRecursiveTypeError;
-class ValueCastUnknownTypeError extends Error {
+class ValueCastUnknownTypeError extends Types.TypeBoxError {
     constructor(schema) {
-        super('ValueCast: Unknown type');
+        super('Unknown type');
         this.schema = schema;
     }
 }
 exports.ValueCastUnknownTypeError = ValueCastUnknownTypeError;
-class ValueCastDereferenceError extends Error {
-    constructor(schema) {
-        super(`ValueCast: Unable to dereference type with $id '${schema.$ref}'`);
-        this.schema = schema;
-    }
-}
-exports.ValueCastDereferenceError = ValueCastDereferenceError;
 // --------------------------------------------------------------------------
 // The following will score a schema against a value. For objects, the score
 // is the tally of points awarded for each property of the value. Property
@@ -89,20 +76,20 @@ exports.ValueCastDereferenceError = ValueCastDereferenceError;
 var UnionCastCreate;
 (function (UnionCastCreate) {
     function Score(schema, references, value) {
-        if (schema[Types.Kind] === 'Object' && typeof value === 'object' && !ValueGuard.IsNull(value)) {
+        if (schema[Types.Kind] === 'Object' && typeof value === 'object' && !(0, guard_1.IsNull)(value)) {
             const object = schema;
             const keys = Object.getOwnPropertyNames(value);
             const entries = Object.entries(object.properties);
             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 = ValueCheck.Check(schema, references, value[key]) ? point : 0;
+                const checks = (0, check_1.Check)(schema, references, value[key]) ? point : 0;
                 const exists = keys.includes(key) ? point : 0;
                 return acc + (literal + checks + exists);
             }, 0);
         }
         else {
-            return ValueCheck.Check(schema, references, value) ? 1 : 0;
+            return (0, check_1.Check)(schema, references, value) ? 1 : 0;
         }
     }
     function Select(union, references, value) {
@@ -128,37 +115,36 @@ var UnionCastCreate;
     UnionCastCreate.Create = Create;
 })(UnionCastCreate || (UnionCastCreate = {}));
 // --------------------------------------------------------------------------
-// Cast
+// Default
 // --------------------------------------------------------------------------
-function TAny(schema, references, value) {
-    return ValueCheck.Check(schema, references, value) ? ValueClone.Clone(value) : ValueCreate.Create(schema, references);
+function DefaultClone(schema, references, value) {
+    return (0, check_1.Check)(schema, references, value) ? (0, clone_1.Clone)(value) : (0, create_1.Create)(schema, references);
 }
+exports.DefaultClone = DefaultClone;
+function Default(schema, references, value) {
+    return (0, check_1.Check)(schema, references, value) ? value : (0, create_1.Create)(schema, references);
+}
+exports.Default = Default;
+// --------------------------------------------------------------------------
+// Cast
+// --------------------------------------------------------------------------
 function TArray(schema, references, value) {
-    if (ValueCheck.Check(schema, references, value))
-        return ValueClone.Clone(value);
-    const created = ValueGuard.IsArray(value) ? ValueClone.Clone(value) : ValueCreate.Create(schema, references);
-    const minimum = ValueGuard.IsNumber(schema.minItems) && created.length < schema.minItems ? [...created, ...Array.from({ length: schema.minItems - created.length }, () => null)] : created;
-    const maximum = ValueGuard.IsNumber(schema.maxItems) && minimum.length > schema.maxItems ? minimum.slice(0, schema.maxItems) : minimum;
+    if ((0, check_1.Check)(schema, references, value))
+        return (0, clone_1.Clone)(value);
+    const created = (0, guard_1.IsArray)(value) ? (0, clone_1.Clone)(value) : (0, create_1.Create)(schema, references);
+    const minimum = (0, guard_1.IsNumber)(schema.minItems) && created.length < schema.minItems ? [...created, ...Array.from({ length: schema.minItems - created.length }, () => null)] : created;
+    const maximum = (0, guard_1.IsNumber)(schema.maxItems) && minimum.length > schema.maxItems ? minimum.slice(0, schema.maxItems) : minimum;
     const casted = maximum.map((value) => Visit(schema.items, references, value));
     if (schema.uniqueItems !== true)
         return casted;
     const unique = [...new Set(casted)];
-    if (!ValueCheck.Check(schema, references, unique))
+    if (!(0, check_1.Check)(schema, references, unique))
         throw new ValueCastArrayUniqueItemsTypeError(schema, unique);
     return unique;
 }
-function TAsyncIterator(schema, references, value) {
-    return ValueCheck.Check(schema, references, value) ? value : ValueCreate.Create(schema, references);
-}
-function TBigInt(schema, references, value) {
-    return ValueCheck.Check(schema, references, value) ? value : ValueCreate.Create(schema, references);
-}
-function TBoolean(schema, references, value) {
-    return ValueCheck.Check(schema, references, value) ? value : ValueCreate.Create(schema, references);
-}
 function TConstructor(schema, references, value) {
-    if (ValueCheck.Check(schema, references, value))
-        return ValueCreate.Create(schema, references);
+    if ((0, check_1.Check)(schema, references, value))
+        return (0, create_1.Create)(schema, references);
     const required = new Set(schema.returns.required || []);
     const result = function () { };
     for (const [key, property] of Object.entries(schema.returns.properties)) {
@@ -168,43 +154,19 @@ function TConstructor(schema, references, value) {
     }
     return result;
 }
-function TDate(schema, references, value) {
-    return ValueCheck.Check(schema, references, value) ? ValueClone.Clone(value) : ValueCreate.Create(schema, references);
-}
-function TFunction(schema, references, value) {
-    return ValueCheck.Check(schema, references, value) ? value : ValueCreate.Create(schema, references);
-}
-function TInteger(schema, references, value) {
-    return ValueCheck.Check(schema, references, value) ? value : ValueCreate.Create(schema, references);
-}
 function TIntersect(schema, references, value) {
-    const created = ValueCreate.Create(schema, references);
-    const mapped = ValueGuard.IsPlainObject(created) && ValueGuard.IsPlainObject(value) ? { ...created, ...value } : value;
-    return ValueCheck.Check(schema, references, mapped) ? mapped : ValueCreate.Create(schema, references);
-}
-function TIterator(schema, references, value) {
-    return ValueCheck.Check(schema, references, value) ? value : ValueCreate.Create(schema, references);
-}
-function TLiteral(schema, references, value) {
-    return ValueCheck.Check(schema, references, value) ? value : ValueCreate.Create(schema, references);
+    const created = (0, create_1.Create)(schema, references);
+    const mapped = (0, guard_1.IsPlainObject)(created) && (0, guard_1.IsPlainObject)(value) ? { ...created, ...value } : value;
+    return (0, check_1.Check)(schema, references, mapped) ? mapped : (0, create_1.Create)(schema, references);
 }
 function TNever(schema, references, value) {
     throw new ValueCastNeverTypeError(schema);
 }
-function TNot(schema, references, value) {
-    return ValueCheck.Check(schema, references, value) ? value : ValueCreate.Create(schema, references);
-}
-function TNull(schema, references, value) {
-    return ValueCheck.Check(schema, references, value) ? value : ValueCreate.Create(schema, references);
-}
-function TNumber(schema, references, value) {
-    return ValueCheck.Check(schema, references, value) ? value : ValueCreate.Create(schema, references);
-}
 function TObject(schema, references, value) {
-    if (ValueCheck.Check(schema, references, value))
+    if ((0, check_1.Check)(schema, references, value))
         return value;
     if (value === null || typeof value !== 'object')
-        return ValueCreate.Create(schema, references);
+        return (0, create_1.Create)(schema, references);
     const required = new Set(schema.required || []);
     const result = {};
     for (const [key, property] of Object.entries(schema.properties)) {
@@ -223,14 +185,11 @@ function TObject(schema, references, value) {
     }
     return result;
 }
-function TPromise(schema, references, value) {
-    return ValueCheck.Check(schema, references, value) ? value : ValueCreate.Create(schema, references);
-}
 function TRecord(schema, references, value) {
-    if (ValueCheck.Check(schema, references, value))
-        return ValueClone.Clone(value);
+    if ((0, check_1.Check)(schema, references, value))
+        return (0, clone_1.Clone)(value);
     if (value === null || typeof value !== 'object' || Array.isArray(value) || value instanceof Date)
-        return ValueCreate.Create(schema, references);
+        return (0, create_1.Create)(schema, references);
     const subschemaPropertyName = Object.getOwnPropertyNames(schema.patternProperties)[0];
     const subschema = schema.patternProperties[subschemaPropertyName];
     const result = {};
@@ -240,123 +199,82 @@ function TRecord(schema, references, value) {
     return result;
 }
 function TRef(schema, references, value) {
-    const index = references.findIndex((foreign) => foreign.$id === schema.$ref);
-    if (index === -1)
-        throw new ValueCastDereferenceError(schema);
-    const target = references[index];
-    return Visit(target, references, value);
-}
-function TString(schema, references, value) {
-    return ValueCheck.Check(schema, references, value) ? value : ValueCreate.Create(schema, references);
-}
-function TSymbol(schema, references, value) {
-    return ValueCheck.Check(schema, references, value) ? ValueClone.Clone(value) : ValueCreate.Create(schema, references);
-}
-function TTemplateLiteral(schema, references, value) {
-    return ValueCheck.Check(schema, references, value) ? ValueClone.Clone(value) : ValueCreate.Create(schema, references);
+    return Visit((0, deref_1.Deref)(schema, references), references, value);
 }
 function TThis(schema, references, value) {
-    const index = references.findIndex((foreign) => foreign.$id === schema.$ref);
-    if (index === -1)
-        throw new ValueCastDereferenceError(schema);
-    const target = references[index];
-    return Visit(target, references, value);
+    return Visit((0, deref_1.Deref)(schema, references), references, value);
 }
 function TTuple(schema, references, value) {
-    if (ValueCheck.Check(schema, references, value))
-        return ValueClone.Clone(value);
-    if (!ValueGuard.IsArray(value))
-        return ValueCreate.Create(schema, references);
+    if ((0, check_1.Check)(schema, references, value))
+        return (0, clone_1.Clone)(value);
+    if (!(0, guard_1.IsArray)(value))
+        return (0, create_1.Create)(schema, references);
     if (schema.items === undefined)
         return [];
     return schema.items.map((schema, index) => Visit(schema, references, value[index]));
 }
-function TUndefined(schema, references, value) {
-    return ValueCheck.Check(schema, references, value) ? ValueClone.Clone(value) : ValueCreate.Create(schema, references);
-}
 function TUnion(schema, references, value) {
-    return ValueCheck.Check(schema, references, value) ? ValueClone.Clone(value) : UnionCastCreate.Create(schema, references, value);
-}
-function TUint8Array(schema, references, value) {
-    return ValueCheck.Check(schema, references, value) ? ValueClone.Clone(value) : ValueCreate.Create(schema, references);
-}
-function TUnknown(schema, references, value) {
-    return ValueCheck.Check(schema, references, value) ? ValueClone.Clone(value) : ValueCreate.Create(schema, references);
-}
-function TVoid(schema, references, value) {
-    return ValueCheck.Check(schema, references, value) ? ValueClone.Clone(value) : ValueCreate.Create(schema, references);
-}
-function TKind(schema, references, value) {
-    return ValueCheck.Check(schema, references, value) ? ValueClone.Clone(value) : ValueCreate.Create(schema, references);
+    return (0, check_1.Check)(schema, references, value) ? (0, clone_1.Clone)(value) : UnionCastCreate.Create(schema, references, value);
 }
 function Visit(schema, references, value) {
-    const references_ = ValueGuard.IsString(schema.$id) ? [...references, schema] : references;
+    const references_ = (0, guard_1.IsString)(schema.$id) ? [...references, schema] : references;
     const schema_ = schema;
     switch (schema[Types.Kind]) {
-        case 'Any':
-            return TAny(schema_, references_, value);
+        // ------------------------------------------------------
+        // Structural
+        // ------------------------------------------------------
         case 'Array':
             return TArray(schema_, references_, value);
-        case 'AsyncIterator':
-            return TAsyncIterator(schema_, references_, value);
-        case 'BigInt':
-            return TBigInt(schema_, references_, value);
-        case 'Boolean':
-            return TBoolean(schema_, references_, value);
         case 'Constructor':
             return TConstructor(schema_, references_, value);
-        case 'Date':
-            return TDate(schema_, references_, value);
-        case 'Function':
-            return TFunction(schema_, references_, value);
-        case 'Integer':
-            return TInteger(schema_, references_, value);
         case 'Intersect':
             return TIntersect(schema_, references_, value);
-        case 'Iterator':
-            return TIterator(schema_, references_, value);
-        case 'Literal':
-            return TLiteral(schema_, references_, value);
         case 'Never':
             return TNever(schema_, references_, value);
-        case 'Not':
-            return TNot(schema_, references_, value);
-        case 'Null':
-            return TNull(schema_, references_, value);
-        case 'Number':
-            return TNumber(schema_, references_, value);
         case 'Object':
             return TObject(schema_, references_, value);
-        case 'Promise':
-            return TPromise(schema_, references_, value);
         case 'Record':
             return TRecord(schema_, references_, value);
         case 'Ref':
             return TRef(schema_, references_, value);
-        case 'String':
-            return TString(schema_, references_, value);
-        case 'Symbol':
-            return TSymbol(schema_, references_, value);
-        case 'TemplateLiteral':
-            return TTemplateLiteral(schema_, references_, value);
         case 'This':
             return TThis(schema_, references_, value);
         case 'Tuple':
             return TTuple(schema_, references_, value);
-        case 'Undefined':
-            return TUndefined(schema_, references_, value);
         case 'Union':
             return TUnion(schema_, references_, value);
+        // ------------------------------------------------------
+        // DefaultClone
+        // ------------------------------------------------------
+        case 'Date':
+        case 'Symbol':
         case 'Uint8Array':
-            return TUint8Array(schema_, references_, value);
+            return DefaultClone(schema, references, value);
+        // ------------------------------------------------------
+        // Default
+        // ------------------------------------------------------
+        case 'Any':
+        case 'AsyncIterator':
+        case 'BigInt':
+        case 'Boolean':
+        case 'Function':
+        case 'Integer':
+        case 'Iterator':
+        case 'Literal':
+        case 'Not':
+        case 'Null':
+        case 'Number':
+        case 'Promise':
+        case 'String':
+        case 'TemplateLiteral':
+        case 'Undefined':
         case 'Unknown':
-            return TUnknown(schema_, references_, value);
         case 'Void':
-            return TVoid(schema_, references_, value);
+            return Default(schema_, references_, value);
         default:
             if (!Types.TypeRegistry.Has(schema_[Types.Kind]))
                 throw new ValueCastUnknownTypeError(schema_);
-            return TKind(schema_, references_, value);
+            return Default(schema_, references_, value);
     }
 }
 /** Casts a value into a given type. The return value will retain as much information of the original value as possible. */

package/value/check.d.ts

@@ -1,12 +1,8 @@
 import * as Types from '../typebox';
-export declare class ValueCheckUnknownTypeError extends Error {
+export declare class ValueCheckUnknownTypeError extends Types.TypeBoxError {
     readonly schema: Types.TSchema;
     constructor(schema: Types.TSchema);
 }
-export declare class ValueCheckDereferenceError extends Error {
-    readonly schema: Types.TRef | Types.TThis;
-    constructor(schema: Types.TRef | Types.TThis);
-}
 /** Returns true if the value matches the given type. */
 export declare function Check<T extends Types.TSchema>(schema: T, references: Types.TSchema[], value: unknown): value is Types.Static<T>;
 /** Returns true if the value matches the given type. */