@sinclair/typebox 0.31.28 → 0.32.0-dev-1

package/value/clean/clean.d.ts

@@ -0,0 +1,5 @@
+import type { TSchema } from '../../type/schema/index';
+/** `[Mutable]` Removes excess properties from a value and returns the result. This function does not check the value and returns an unknown type. You should Check the result before use. Clean is a mutable operation. To avoid mutation, Clone the value first. */
+export declare function Clean<T extends TSchema>(schema: T, references: TSchema[], value: unknown): unknown;
+/** `[Mutable]` Removes excess properties from a value and returns the result. This function does not check the value and returns an unknown type. You should Check the result before use. Clean is a mutable operation. To avoid mutation, Clone the value first. */
+export declare function Clean<T extends TSchema>(schema: T): unknown;

package/value/clean/clean.js

@@ -0,0 +1,167 @@
+"use strict";
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/value
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Clean = void 0;
+const index_1 = require("../guard/index");
+const type_1 = require("../../type/guard/type");
+const keyof_string_1 = require("../../type/keyof/keyof-string");
+const index_2 = require("../check/index");
+const index_3 = require("../clone/index");
+const index_4 = require("../deref/index");
+const index_5 = require("../../type/symbols/index");
+// ------------------------------------------------------------------
+// IsSchema
+// ------------------------------------------------------------------
+function IsSchema(schema) {
+    return (0, type_1.TSchema)(schema);
+}
+// ------------------------------------------------------------------
+// IsCheckable
+// ------------------------------------------------------------------
+function IsCheckable(schema) {
+    return (0, type_1.TSchema)(schema) && schema[index_5.Kind] !== 'Unsafe';
+}
+// ------------------------------------------------------------------
+// Types
+// ------------------------------------------------------------------
+function TArray(schema, references, value) {
+    if (!(0, index_1.IsArray)(value))
+        return value;
+    return value.map((value) => Visit(schema.items, references, value));
+}
+function TIntersect(schema, references, value) {
+    const unevaluatedProperties = schema.unevaluatedProperties;
+    const intersections = schema.allOf.map((schema) => Visit(schema, references, (0, index_3.Clone)(value)));
+    const composite = intersections.reduce((acc, value) => ((0, index_1.IsObject)(value) ? { ...acc, ...value } : value), {});
+    if (!(0, index_1.IsObject)(value) || !(0, index_1.IsObject)(composite) || !IsSchema(unevaluatedProperties))
+        return composite;
+    const knownkeys = (0, keyof_string_1.KeyOfStringResolve)(schema);
+    for (const key of Object.getOwnPropertyNames(value)) {
+        if (knownkeys.includes(key))
+            continue;
+        if ((0, index_2.Check)(unevaluatedProperties, references, value[key])) {
+            composite[key] = Visit(unevaluatedProperties, references, value[key]);
+        }
+    }
+    return composite;
+}
+function TObject(schema, references, value) {
+    if (!(0, index_1.IsObject)(value) || (0, index_1.IsArray)(value))
+        return value; // Check IsArray for AllowArrayObject configuration
+    const additionalProperties = schema.additionalProperties;
+    for (const key of Object.getOwnPropertyNames(value)) {
+        if (key in schema.properties) {
+            value[key] = Visit(schema.properties[key], references, value[key]);
+            continue;
+        }
+        if (IsSchema(additionalProperties) && (0, index_2.Check)(additionalProperties, references, value[key])) {
+            value[key] = Visit(additionalProperties, references, value[key]);
+            continue;
+        }
+        delete value[key];
+    }
+    return value;
+}
+function TRecord(schema, references, value) {
+    if (!(0, index_1.IsObject)(value))
+        return value;
+    const additionalProperties = schema.additionalProperties;
+    const propertyKeys = Object.keys(value);
+    const [propertyKey, propertySchema] = Object.entries(schema.patternProperties)[0];
+    const propertyKeyTest = new RegExp(propertyKey);
+    for (const key of propertyKeys) {
+        if (propertyKeyTest.test(key)) {
+            value[key] = Visit(propertySchema, references, value[key]);
+            continue;
+        }
+        if (IsSchema(additionalProperties) && (0, index_2.Check)(additionalProperties, references, value[key])) {
+            value[key] = Visit(additionalProperties, references, value[key]);
+            continue;
+        }
+        delete value[key];
+    }
+    return value;
+}
+function TRef(schema, references, value) {
+    return Visit((0, index_4.Deref)(schema, references), references, value);
+}
+function TThis(schema, references, value) {
+    return Visit((0, index_4.Deref)(schema, references), references, value);
+}
+function TTuple(schema, references, value) {
+    if (!(0, index_1.IsArray)(value))
+        return value;
+    if ((0, index_1.IsUndefined)(schema.items))
+        return [];
+    const length = Math.min(value.length, schema.items.length);
+    for (let i = 0; i < length; i++) {
+        value[i] = Visit(schema.items[i], references, value[i]);
+    }
+    // prettier-ignore
+    return value.length > length
+        ? value.slice(0, length)
+        : value;
+}
+function TUnion(schema, references, value) {
+    for (const inner of schema.anyOf) {
+        if (IsCheckable(inner) && (0, index_2.Check)(inner, value)) {
+            return Visit(inner, references, value);
+        }
+    }
+    return value;
+}
+function Visit(schema, references, value) {
+    const references_ = (0, index_1.IsString)(schema.$id) ? [...references, schema] : references;
+    const schema_ = schema;
+    switch (schema_[index_5.Kind]) {
+        case 'Array':
+            return TArray(schema_, references_, value);
+        case 'Intersect':
+            return TIntersect(schema_, references_, value);
+        case 'Object':
+            return TObject(schema_, references_, value);
+        case 'Record':
+            return TRecord(schema_, references_, value);
+        case 'Ref':
+            return TRef(schema_, references_, value);
+        case 'This':
+            return TThis(schema_, references_, value);
+        case 'Tuple':
+            return TTuple(schema_, references_, value);
+        case 'Union':
+            return TUnion(schema_, references_, value);
+        default:
+            return value;
+    }
+}
+/** `[Mutable]` Removes excess properties from a value and returns the result. This function does not check the value and returns an unknown type. You should Check the result before use. Clean is a mutable operation. To avoid mutation, Clone the value first. */
+function Clean(...args) {
+    return args.length === 3 ? Visit(args[0], args[1], args[2]) : Visit(args[0], [], args[1]);
+}
+exports.Clean = Clean;

package/value/clean/index.d.ts

@@ -0,0 +1 @@
+export * from './clean';

package/value/clean/index.js

@@ -0,0 +1,44 @@
+"use strict";
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/value
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./clean"), exports);

package/value/{clone.js → clone/clone.js}

@@ -28,7 +28,7 @@ THE SOFTWARE.
 ---------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Clone = void 0;
-const guard_1 = require("./guard");
+const index_1 = require("../guard/index");
 // --------------------------------------------------------------------------
 // Clonable
 // --------------------------------------------------------------------------
@@ -53,15 +53,15 @@ function ValueType(value) {
 // --------------------------------------------------------------------------
 /** Returns a clone of the given value */
 function Clone(value) {
-    if ((0, guard_1.IsArray)(value))
+    if ((0, index_1.IsArray)(value))
         return ArrayType(value);
-    if ((0, guard_1.IsDate)(value))
+    if ((0, index_1.IsDate)(value))
         return DateType(value);
-    if ((0, guard_1.IsPlainObject)(value))
+    if ((0, index_1.IsPlainObject)(value))
         return ObjectType(value);
-    if ((0, guard_1.IsTypedArray)(value))
+    if ((0, index_1.IsTypedArray)(value))
         return TypedArrayType(value);
-    if ((0, guard_1.IsValueType)(value))
+    if ((0, index_1.IsValueType)(value))
         return ValueType(value);
     throw new Error('ValueClone: Unable to clone value');
 }

package/value/clone/index.d.ts

@@ -0,0 +1 @@
+export * from './clone';

package/value/clone/index.js

@@ -0,0 +1,44 @@
+"use strict";
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/value
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./clone"), exports);

package/value/convert/convert.d.ts

@@ -0,0 +1,9 @@
+import type { TSchema } from '../../type/schema/index';
+export declare class ValueConvertUnknownTypeError extends Error {
+    readonly schema: TSchema;
+    constructor(schema: TSchema);
+}
+/** Converts any type mismatched values to their target type if a reasonable conversion is possible. */
+export declare function Convert<T extends TSchema>(schema: T, references: TSchema[], value: unknown): unknown;
+/** Converts any type mismatched values to their target type if a reasonable conversion is possible. */
+export declare function Convert<T extends TSchema>(schema: T, value: unknown): unknown;

package/value/{convert.js → convert/convert.js}

@@ -27,55 +27,57 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
-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");
-// --------------------------------------------------------------------------
+exports.Convert = exports.ValueConvertUnknownTypeError = void 0;
+const index_1 = require("../guard/index");
+const index_2 = require("../clone/index");
+const index_3 = require("../check/index");
+const index_4 = require("../deref/index");
+const type_1 = require("../../type/guard/type");
+const index_5 = require("../../type/symbols/index");
+const index_6 = require("../../type/composite/index");
+// ------------------------------------------------------------------
 // Errors
-// --------------------------------------------------------------------------
-class ValueConvertUnknownTypeError extends Types.TypeBoxError {
+// ------------------------------------------------------------------
+class ValueConvertUnknownTypeError extends Error {
     constructor(schema) {
         super('Unknown type');
         this.schema = schema;
     }
 }
 exports.ValueConvertUnknownTypeError = ValueConvertUnknownTypeError;
-// --------------------------------------------------------------------------
+// ------------------------------------------------------------------
 // Conversions
-// --------------------------------------------------------------------------
+// ------------------------------------------------------------------
 function IsStringNumeric(value) {
-    return (0, guard_1.IsString)(value) && !isNaN(value) && !isNaN(parseFloat(value));
+    return (0, index_1.IsString)(value) && !isNaN(value) && !isNaN(parseFloat(value));
 }
 function IsValueToString(value) {
-    return (0, guard_1.IsBigInt)(value) || (0, guard_1.IsBoolean)(value) || (0, guard_1.IsNumber)(value);
+    return (0, index_1.IsBigInt)(value) || (0, index_1.IsBoolean)(value) || (0, index_1.IsNumber)(value);
 }
 function IsValueTrue(value) {
-    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'));
+    return value === true || ((0, index_1.IsNumber)(value) && value === 1) || ((0, index_1.IsBigInt)(value) && value === BigInt('1')) || ((0, index_1.IsString)(value) && (value.toLowerCase() === 'true' || value === '1'));
 }
 function IsValueFalse(value) {
-    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'));
+    return value === false || ((0, index_1.IsNumber)(value) && (value === 0 || Object.is(value, -0))) || ((0, index_1.IsBigInt)(value) && value === BigInt('0')) || ((0, index_1.IsString)(value) && (value.toLowerCase() === 'false' || value === '0' || value === '-0'));
 }
 function IsTimeStringWithTimeZone(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);
+    return (0, index_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 (0, guard_1.IsString)(value) && /^(?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)?$/i.test(value);
+    return (0, index_1.IsString)(value) && /^(?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)?$/i.test(value);
 }
 function IsDateTimeStringWithTimeZone(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);
+    return (0, index_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 (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);
+    return (0, index_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 (0, guard_1.IsString)(value) && /^\d\d\d\d-[0-1]\d-[0-3]\d$/i.test(value);
+    return (0, index_1.IsString)(value) && /^\d\d\d\d-[0-1]\d-[0-3]\d$/i.test(value);
 }
-// --------------------------------------------------------------------------
+// ------------------------------------------------------------------
 // Convert
-// --------------------------------------------------------------------------
+// ------------------------------------------------------------------
 function TryConvertLiteralString(value, target) {
     const conversion = TryConvertString(value);
     return conversion === target ? conversion : value;
@@ -88,82 +90,66 @@ function TryConvertLiteralBoolean(value, target) {
     const conversion = TryConvertBoolean(value);
     return conversion === target ? conversion : value;
 }
+// prettier-ignore
 function TryConvertLiteral(schema, value) {
-    if (typeof schema.const === 'string') {
-        return TryConvertLiteralString(value, schema.const);
-    }
-    else if (typeof schema.const === 'number') {
-        return TryConvertLiteralNumber(value, schema.const);
-    }
-    else if (typeof schema.const === 'boolean') {
-        return TryConvertLiteralBoolean(value, schema.const);
-    }
-    else {
-        return (0, clone_1.Clone)(value);
-    }
+    return ((0, index_1.IsString)(schema.const) ? TryConvertLiteralString(value, schema.const) :
+        (0, index_1.IsNumber)(schema.const) ? TryConvertLiteralNumber(value, schema.const) :
+            (0, index_1.IsBoolean)(schema.const) ? TryConvertLiteralBoolean(value, schema.const) :
+                (0, index_2.Clone)(value));
 }
 function TryConvertBoolean(value) {
     return IsValueTrue(value) ? true : IsValueFalse(value) ? false : value;
 }
 function TryConvertBigInt(value) {
-    return IsStringNumeric(value) ? BigInt(parseInt(value)) : (0, guard_1.IsNumber)(value) ? BigInt(value | 0) : IsValueFalse(value) ? BigInt(0) : IsValueTrue(value) ? BigInt(1) : value;
+    return IsStringNumeric(value) ? BigInt(parseInt(value)) : (0, index_1.IsNumber)(value) ? BigInt(value | 0) : IsValueFalse(value) ? BigInt(0) : IsValueTrue(value) ? BigInt(1) : value;
 }
 function TryConvertString(value) {
-    return IsValueToString(value) ? value.toString() : (0, guard_1.IsSymbol)(value) && value.description !== undefined ? value.description.toString() : value;
+    return IsValueToString(value) ? value.toString() : (0, index_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) : (0, guard_1.IsNumber)(value) ? value | 0 : IsValueTrue(value) ? 1 : IsValueFalse(value) ? 0 : value;
+    return IsStringNumeric(value) ? parseInt(value) : (0, index_1.IsNumber)(value) ? value | 0 : IsValueTrue(value) ? 1 : IsValueFalse(value) ? 0 : value;
 }
 function TryConvertNull(value) {
-    return (0, guard_1.IsString)(value) && value.toLowerCase() === 'null' ? null : value;
+    return (0, index_1.IsString)(value) && value.toLowerCase() === 'null' ? null : value;
 }
 function TryConvertUndefined(value) {
-    return (0, guard_1.IsString)(value) && value === 'undefined' ? undefined : value;
-}
+    return (0, index_1.IsString)(value) && value === 'undefined' ? undefined : 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.
+// ------------------------------------------------------------------
+// prettier-ignore
 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 (0, guard_1.IsDate)(value)
-        ? value
-        : (0, guard_1.IsNumber)(value)
-            ? new Date(value)
-            : IsValueTrue(value)
-                ? new Date(1)
-                : IsValueFalse(value)
-                    ? new Date(0)
-                    : IsStringNumeric(value)
-                        ? new Date(parseInt(value))
-                        : IsTimeStringWithoutTimeZone(value)
-                            ? new Date(`1970-01-01T${value}.000Z`)
-                            : IsTimeStringWithTimeZone(value)
-                                ? new Date(`1970-01-01T${value}`)
-                                : IsDateTimeStringWithoutTimeZone(value)
-                                    ? new Date(`${value}.000Z`)
-                                    : IsDateTimeStringWithTimeZone(value)
-                                        ? new Date(value)
-                                        : IsDateString(value)
-                                            ? new Date(`${value}T00:00:00.000Z`)
-                                            : value;
-}
-// --------------------------------------------------------------------------
+    return ((0, index_1.IsDate)(value) ? value :
+        (0, index_1.IsNumber)(value) ? new Date(value) :
+            IsValueTrue(value) ? new Date(1) :
+                IsValueFalse(value) ? new Date(0) :
+                    IsStringNumeric(value) ? new Date(parseInt(value)) :
+                        IsTimeStringWithoutTimeZone(value) ? new Date(`1970-01-01T${value}.000Z`) :
+                            IsTimeStringWithTimeZone(value) ? new Date(`1970-01-01T${value}`) :
+                                IsDateTimeStringWithoutTimeZone(value) ? new Date(`${value}.000Z`) :
+                                    IsDateTimeStringWithTimeZone(value) ? new Date(value) :
+                                        IsDateString(value) ? new Date(`${value}T00:00:00.000Z`) :
+                                            value);
+}
+// ------------------------------------------------------------------
 // Default
-// --------------------------------------------------------------------------
+// ------------------------------------------------------------------
 function Default(value) {
     return value;
 }
-exports.Default = Default;
-// --------------------------------------------------------------------------
+// ------------------------------------------------------------------
 // Convert
-// --------------------------------------------------------------------------
+// ------------------------------------------------------------------
 function TArray(schema, references, value) {
-    if ((0, guard_1.IsArray)(value)) {
+    if ((0, index_1.IsArray)(value)) {
         return value.map((value) => Visit(schema.items, references, value));
     }
     return value;
@@ -180,11 +166,12 @@ function TDate(schema, references, value) {
 function TInteger(schema, references, value) {
     return TryConvertInteger(value);
 }
+// prettier-ignore
 function TIntersect(schema, references, value) {
-    // prettier-ignore
-    return (schema.allOf.every(schema => Types.TypeGuard.TObject(schema)))
-        ? Visit(Types.Type.Composite(schema.allOf), references, value)
-        : Visit(schema.allOf[0], references, value);
+    const allObjects = schema.allOf.every(schema => (0, type_1.TObject)(schema));
+    if (allObjects)
+        return Visit((0, index_6.Composite)(schema.allOf), references, value);
+    return Visit(schema.allOf[0], references, value); // todo: fix this
 }
 function TLiteral(schema, references, value) {
     return TryConvertLiteral(schema, value);
@@ -195,12 +182,16 @@ function TNull(schema, references, value) {
 function TNumber(schema, references, value) {
     return TryConvertNumber(value);
 }
+// prettier-ignore
 function TObject(schema, references, 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;
+    const isConvertable = (0, index_1.IsObject)(value);
+    if (!isConvertable)
+        return value;
+    return Object.getOwnPropertyNames(schema.properties).reduce((value, key) => {
+        return !(0, index_1.IsUndefined)(value[key])
+            ? ({ ...value, [key]: Visit(schema.properties[key], references, value[key]) })
+            : ({ ...value });
+    }, value);
 }
 function TRecord(schema, references, value) {
     const propertyKey = Object.getOwnPropertyNames(schema.patternProperties)[0];
@@ -212,24 +203,27 @@ function TRecord(schema, references, value) {
     return result;
 }
 function TRef(schema, references, value) {
-    return Visit((0, deref_1.Deref)(schema, references), references, value);
+    return Visit((0, index_4.Deref)(schema, references), references, value);
 }
 function TString(schema, references, value) {
     return TryConvertString(value);
 }
 function TSymbol(schema, references, value) {
-    return (0, guard_1.IsString)(value) || (0, guard_1.IsNumber)(value) ? Symbol(value) : value;
+    return (0, index_1.IsString)(value) || (0, index_1.IsNumber)(value) ? Symbol(value) : value;
 }
 function TThis(schema, references, value) {
-    return Visit((0, deref_1.Deref)(schema, references), references, value);
+    return Visit((0, index_4.Deref)(schema, references), references, value);
 }
+// prettier-ignore
 function TTuple(schema, references, value) {
-    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;
-        });
-    }
-    return value;
+    const isConvertable = (0, index_1.IsArray)(value) && !(0, index_1.IsUndefined)(schema.items);
+    if (!isConvertable)
+        return value;
+    return value.map((value, index) => {
+        return (index < schema.items.length)
+            ? Visit(schema.items[index], references, value)
+            : value;
+    });
 }
 function TUndefined(schema, references, value) {
     return TryConvertUndefined(value);
@@ -237,19 +231,16 @@ function TUndefined(schema, references, value) {
 function TUnion(schema, references, value) {
     for (const subschema of schema.anyOf) {
         const converted = Visit(subschema, references, value);
-        if ((0, check_1.Check)(subschema, references, converted)) {
+        if ((0, index_3.Check)(subschema, references, converted)) {
             return converted;
         }
     }
     return value;
 }
 function Visit(schema, references, value) {
-    const references_ = (0, guard_1.IsString)(schema.$id) ? [...references, schema] : references;
+    const references_ = (0, index_1.IsString)(schema.$id) ? [...references, schema] : references;
     const schema_ = schema;
-    switch (schema[Types.Kind]) {
-        // ------------------------------------------------------
-        // Structural
-        // ------------------------------------------------------
+    switch (schema[index_5.Kind]) {
         case 'Array':
             return TArray(schema_, references_, value);
         case 'BigInt':
@@ -286,29 +277,15 @@ 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 'Iterator':
-        case 'Never':
-        case 'Promise':
-        case 'TemplateLiteral':
-        case 'Uint8Array':
-        case 'Unknown':
-        case 'Void':
-            return Default(value);
         default:
-            if (!Types.TypeRegistry.Has(schema_[Types.Kind]))
-                throw new ValueConvertUnknownTypeError(schema_);
             return Default(value);
     }
 }
 /** Converts any type mismatched values to their target type if a reasonable conversion is possible. */
+// prettier-ignore
 function Convert(...args) {
-    return args.length === 3 ? Visit(args[0], args[1], args[2]) : Visit(args[0], [], args[1]);
+    return args.length === 3
+        ? Visit(args[0], args[1], args[2])
+        : Visit(args[0], [], args[1]);
 }
 exports.Convert = Convert;

package/value/convert/index.d.ts

@@ -0,0 +1 @@
+export * from './convert';