@sinclair/typebox 0.30.4 → 0.31.0-dev-2

package/value/convert.js

@@ -27,57 +27,51 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Convert = exports.ValueConvertDereferenceError = exports.ValueConvertUnknownTypeError = void 0;
+exports.Convert = exports.Default = exports.ValueConvertUnknownTypeError = void 0;
+const guard_1 = require("./guard");
+const clone_1 = require("./clone");
+const check_1 = require("./check");
+const deref_1 = require("./deref");
 const Types = require("../typebox");
-const ValueClone = require("./clone");
-const ValueCheck = require("./check");
-const ValueGuard = require("./guard");
 // --------------------------------------------------------------------------
 // Errors
 // --------------------------------------------------------------------------
-class ValueConvertUnknownTypeError extends Error {
+class ValueConvertUnknownTypeError extends Types.TypeBoxError {
     constructor(schema) {
-        super('ValueConvert: Unknown type');
+        super('Unknown type');
         this.schema = schema;
     }
 }
 exports.ValueConvertUnknownTypeError = ValueConvertUnknownTypeError;
-class ValueConvertDereferenceError extends Error {
-    constructor(schema) {
-        super(`ValueConvert: Unable to dereference type with $id '${schema.$ref}'`);
-        this.schema = schema;
-    }
-}
-exports.ValueConvertDereferenceError = ValueConvertDereferenceError;
 // --------------------------------------------------------------------------
 // Conversions
 // --------------------------------------------------------------------------
 function IsStringNumeric(value) {
-    return ValueGuard.IsString(value) && !isNaN(value) && !isNaN(parseFloat(value));
+    return (0, guard_1.IsString)(value) && !isNaN(value) && !isNaN(parseFloat(value));
 }
 function IsValueToString(value) {
-    return ValueGuard.IsBigInt(value) || ValueGuard.IsBoolean(value) || ValueGuard.IsNumber(value);
+    return (0, guard_1.IsBigInt)(value) || (0, guard_1.IsBoolean)(value) || (0, guard_1.IsNumber)(value);
 }
 function IsValueTrue(value) {
-    return value === true || (ValueGuard.IsNumber(value) && value === 1) || (ValueGuard.IsBigInt(value) && value === BigInt('1')) || (ValueGuard.IsString(value) && (value.toLowerCase() === 'true' || value === '1'));
+    return value === true || ((0, guard_1.IsNumber)(value) && value === 1) || ((0, guard_1.IsBigInt)(value) && value === BigInt('1')) || ((0, guard_1.IsString)(value) && (value.toLowerCase() === 'true' || value === '1'));
 }
 function IsValueFalse(value) {
-    return value === false || (ValueGuard.IsNumber(value) && value === 0) || (ValueGuard.IsBigInt(value) && value === BigInt('0')) || (ValueGuard.IsString(value) && (value.toLowerCase() === 'false' || value === '0'));
+    return value === false || ((0, guard_1.IsNumber)(value) && (value === 0 || Object.is(value, -0))) || ((0, guard_1.IsBigInt)(value) && value === BigInt('0')) || ((0, guard_1.IsString)(value) && (value.toLowerCase() === 'false' || value === '0' || value === '-0'));
 }
 function IsTimeStringWithTimeZone(value) {
-    return ValueGuard.IsString(value) && /^(?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)(?:\.\d+)?(?:z|[+-]\d\d(?::?\d\d)?)$/i.test(value);
+    return (0, guard_1.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 ValueGuard.IsString(value) && /^(?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)?$/i.test(value);
+    return (0, guard_1.IsString)(value) && /^(?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)?$/i.test(value);
 }
 function IsDateTimeStringWithTimeZone(value) {
-    return ValueGuard.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);
+    return (0, guard_1.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 ValueGuard.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);
+    return (0, guard_1.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 ValueGuard.IsString(value) && /^\d\d\d\d-[0-1]\d-[0-3]\d$/i.test(value);
+    return (0, guard_1.IsString)(value) && /^\d\d\d\d-[0-1]\d-[0-3]\d$/i.test(value);
 }
 // --------------------------------------------------------------------------
 // Convert
@@ -105,29 +99,29 @@ function TryConvertLiteral(schema, value) {
         return TryConvertLiteralBoolean(value, schema.const);
     }
     else {
-        return ValueClone.Clone(value);
+        return (0, clone_1.Clone)(value);
     }
 }
 function TryConvertBoolean(value) {
     return IsValueTrue(value) ? true : IsValueFalse(value) ? false : value;
 }
 function TryConvertBigInt(value) {
-    return IsStringNumeric(value) ? BigInt(parseInt(value)) : ValueGuard.IsNumber(value) ? BigInt(value | 0) : IsValueFalse(value) ? 0 : IsValueTrue(value) ? 1 : value;
+    return IsStringNumeric(value) ? BigInt(parseInt(value)) : (0, guard_1.IsNumber)(value) ? BigInt(value | 0) : IsValueFalse(value) ? BigInt(0) : IsValueTrue(value) ? BigInt(1) : value;
 }
 function TryConvertString(value) {
-    return IsValueToString(value) ? value.toString() : ValueGuard.IsSymbol(value) && value.description !== undefined ? value.description.toString() : value;
+    return IsValueToString(value) ? value.toString() : (0, guard_1.IsSymbol)(value) && value.description !== undefined ? value.description.toString() : value;
 }
 function TryConvertNumber(value) {
     return IsStringNumeric(value) ? parseFloat(value) : IsValueTrue(value) ? 1 : IsValueFalse(value) ? 0 : value;
 }
 function TryConvertInteger(value) {
-    return IsStringNumeric(value) ? parseInt(value) : ValueGuard.IsNumber(value) ? value | 0 : IsValueTrue(value) ? 1 : IsValueFalse(value) ? 0 : value;
+    return IsStringNumeric(value) ? parseInt(value) : (0, guard_1.IsNumber)(value) ? value | 0 : IsValueTrue(value) ? 1 : IsValueFalse(value) ? 0 : value;
 }
 function TryConvertNull(value) {
-    return ValueGuard.IsString(value) && value.toLowerCase() === 'null' ? null : value;
+    return (0, guard_1.IsString)(value) && value.toLowerCase() === 'null' ? null : value;
 }
 function TryConvertUndefined(value) {
-    return ValueGuard.IsString(value) && value === 'undefined' ? undefined : value;
+    return (0, guard_1.IsString)(value) && value === 'undefined' ? undefined : value;
 }
 function TryConvertDate(value) {
     // --------------------------------------------------------------------------
@@ -136,9 +130,9 @@ function TryConvertDate(value) {
     // and will return a epoch date if invalid. Consider better string parsing
     // for the iso dates in future revisions.
     // --------------------------------------------------------------------------
-    return ValueGuard.IsDate(value)
+    return (0, guard_1.IsDate)(value)
         ? value
-        : ValueGuard.IsNumber(value)
+        : (0, guard_1.IsNumber)(value)
             ? new Date(value)
             : IsValueTrue(value)
                 ? new Date(1)
@@ -159,50 +153,36 @@ function TryConvertDate(value) {
                                             : value;
 }
 // --------------------------------------------------------------------------
-// Cast
+// Default
 // --------------------------------------------------------------------------
-function TAny(schema, references, value) {
+function Default(value) {
     return value;
 }
+exports.Default = Default;
+// --------------------------------------------------------------------------
+// Convert
+// --------------------------------------------------------------------------
 function TArray(schema, references, value) {
-    if (ValueGuard.IsArray(value)) {
+    if ((0, guard_1.IsArray)(value)) {
         return value.map((value) => Visit(schema.items, references, value));
     }
     return value;
 }
-function TAsyncIterator(schema, references, value) {
-    return value;
-}
 function TBigInt(schema, references, value) {
     return TryConvertBigInt(value);
 }
 function TBoolean(schema, references, value) {
     return TryConvertBoolean(value);
 }
-function TConstructor(schema, references, value) {
-    return ValueClone.Clone(value);
-}
 function TDate(schema, references, value) {
     return TryConvertDate(value);
 }
-function TFunction(schema, references, value) {
-    return value;
-}
 function TInteger(schema, references, value) {
     return TryConvertInteger(value);
 }
-function TIntersect(schema, references, value) {
-    return value;
-}
-function TIterator(schema, references, value) {
-    return value;
-}
 function TLiteral(schema, references, value) {
     return TryConvertLiteral(schema, value);
 }
-function TNever(schema, references, value) {
-    return value;
-}
 function TNull(schema, references, value) {
     return TryConvertNull(value);
 }
@@ -210,15 +190,12 @@ function TNumber(schema, references, value) {
     return TryConvertNumber(value);
 }
 function TObject(schema, references, value) {
-    if (ValueGuard.IsObject(value))
+    if ((0, guard_1.IsObject)(value))
         return Object.getOwnPropertyNames(schema.properties).reduce((acc, key) => {
             return value[key] !== undefined ? { ...acc, [key]: Visit(schema.properties[key], references, value[key]) } : { ...acc };
         }, value);
     return value;
 }
-function TPromise(schema, references, value) {
-    return value;
-}
 function TRecord(schema, references, value) {
     const propertyKey = Object.getOwnPropertyNames(schema.patternProperties)[0];
     const property = schema.patternProperties[propertyKey];
@@ -229,30 +206,19 @@ 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 ValueConvertDereferenceError(schema);
-    const target = references[index];
-    return Visit(target, references, value);
+    return Visit((0, deref_1.Deref)(schema, references), references, value);
 }
 function TString(schema, references, value) {
     return TryConvertString(value);
 }
 function TSymbol(schema, references, value) {
-    return value;
-}
-function TTemplateLiteral(schema, references, value) {
-    return value;
+    return (0, guard_1.IsString)(value) || (0, guard_1.IsNumber)(value) ? Symbol(value) : value;
 }
 function TThis(schema, references, value) {
-    const index = references.findIndex((foreign) => foreign.$id === schema.$ref);
-    if (index === -1)
-        throw new ValueConvertDereferenceError(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 (ValueGuard.IsArray(value) && !ValueGuard.IsUndefined(schema.items)) {
+    if ((0, guard_1.IsArray)(value) && !(0, guard_1.IsUndefined)(schema.items)) {
         return value.map((value, index) => {
             return index < schema.items.length ? Visit(schema.items[index], references, value) : value;
         });
@@ -265,62 +231,37 @@ function TUndefined(schema, references, value) {
 function TUnion(schema, references, value) {
     for (const subschema of schema.anyOf) {
         const converted = Visit(subschema, references, value);
-        if (ValueCheck.Check(subschema, references, converted)) {
+        if ((0, check_1.Check)(subschema, references, converted)) {
             return converted;
         }
     }
     return value;
 }
-function TUint8Array(schema, references, value) {
-    return value;
-}
-function TUnknown(schema, references, value) {
-    return value;
-}
-function TVoid(schema, references, value) {
-    return value;
-}
-function TKind(schema, references, value) {
-    return 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 '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':
@@ -329,8 +270,6 @@ function Visit(schema, references, value) {
             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':
@@ -339,16 +278,26 @@ function Visit(schema, references, value) {
             return TUndefined(schema_, references_, value);
         case 'Union':
             return TUnion(schema_, references_, value);
+        // ------------------------------------------------------
+        // Default
+        // ------------------------------------------------------
+        case 'Any':
+        case 'AsyncIterator':
+        case 'Constructor':
+        case 'Function':
+        case 'Intersect':
+        case 'Iterator':
+        case 'Never':
+        case 'Promise':
+        case 'TemplateLiteral':
         case 'Uint8Array':
-            return TUint8Array(schema_, references_, value);
         case 'Unknown':
-            return TUnknown(schema_, references_, value);
         case 'Void':
-            return TVoid(schema_, references_, value);
+            return Default(value);
         default:
             if (!Types.TypeRegistry.Has(schema_[Types.Kind]))
                 throw new ValueConvertUnknownTypeError(schema_);
-            return TKind(schema_, references_, value);
+            return Default(value);
     }
 }
 /** Converts any type mismatched values to their target type if a reasonable conversion is possible. */

package/value/create.d.ts

@@ -1,29 +1,25 @@
 import * as Types from '../typebox';
-export declare class ValueCreateUnknownTypeError extends Error {
+export declare class ValueCreateUnknownTypeError extends Types.TypeBoxError {
     readonly schema: Types.TSchema;
     constructor(schema: Types.TSchema);
 }
-export declare class ValueCreateNeverTypeError extends Error {
+export declare class ValueCreateNeverTypeError extends Types.TypeBoxError {
     readonly schema: Types.TSchema;
     constructor(schema: Types.TSchema);
 }
-export declare class ValueCreateNotTypeError extends Error {
+export declare class ValueCreateNotTypeError extends Types.TypeBoxError {
     readonly schema: Types.TSchema;
     constructor(schema: Types.TSchema);
 }
-export declare class ValueCreateIntersectTypeError extends Error {
+export declare class ValueCreateIntersectTypeError extends Types.TypeBoxError {
     readonly schema: Types.TSchema;
     constructor(schema: Types.TSchema);
 }
-export declare class ValueCreateTempateLiteralTypeError extends Error {
+export declare class ValueCreateTempateLiteralTypeError extends Types.TypeBoxError {
     readonly schema: Types.TSchema;
     constructor(schema: Types.TSchema);
 }
-export declare class ValueCreateDereferenceError extends Error {
-    readonly schema: Types.TRef | Types.TThis;
-    constructor(schema: Types.TRef | Types.TThis);
-}
-export declare class ValueCreateRecursiveInstantiationError extends Error {
+export declare class ValueCreateRecursiveInstantiationError extends Types.TypeBoxError {
     readonly schema: Types.TSchema;
     readonly recursiveMaxDepth: number;
     constructor(schema: Types.TSchema, recursiveMaxDepth: number);