@sinclair/typebox 0.30.3 → 0.31.0-dev-1

package/value/check.js

@@ -27,28 +27,22 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Check = exports.ValueCheckDereferenceError = exports.ValueCheckUnknownTypeError = void 0;
+exports.Check = exports.ValueCheckUnknownTypeError = void 0;
+const guard_1 = require("./guard");
 const index_1 = require("../system/index");
+const deref_1 = require("./deref");
+const hash_1 = require("./hash");
 const Types = require("../typebox");
-const ValueGuard = require("./guard");
-const ValueHash = require("./hash");
 // --------------------------------------------------------------------------
 // Errors
 // --------------------------------------------------------------------------
-class ValueCheckUnknownTypeError extends Error {
+class ValueCheckUnknownTypeError extends Types.TypeBoxError {
     constructor(schema) {
-        super(`ValueCheck: ${schema[Types.Kind] ? `Unknown type '${schema[Types.Kind]}'` : 'Unknown type'}`);
+        super(`Unknown type`);
         this.schema = schema;
     }
 }
 exports.ValueCheckUnknownTypeError = ValueCheckUnknownTypeError;
-class ValueCheckDereferenceError extends Error {
-    constructor(schema) {
-        super(`ValueCheck: Unable to dereference type with $id '${schema.$ref}'`);
-        this.schema = schema;
-    }
-}
-exports.ValueCheckDereferenceError = ValueCheckDereferenceError;
 // --------------------------------------------------------------------------
 // TypeGuards
 // --------------------------------------------------------------------------
@@ -62,36 +56,14 @@ function IsDefined(value) {
     return value !== undefined;
 }
 // --------------------------------------------------------------------------
-// Policies
-// --------------------------------------------------------------------------
-function IsExactOptionalProperty(value, key) {
-    return index_1.TypeSystem.ExactOptionalPropertyTypes ? key in value : value[key] !== undefined;
-}
-function IsObject(value) {
-    const isObject = ValueGuard.IsObject(value);
-    return index_1.TypeSystem.AllowArrayObjects ? isObject : isObject && !ValueGuard.IsArray(value);
-}
-function IsRecordObject(value) {
-    return IsObject(value) && !(value instanceof Date) && !(value instanceof Uint8Array);
-}
-function IsNumber(value) {
-    const isNumber = ValueGuard.IsNumber(value);
-    return index_1.TypeSystem.AllowNaN ? isNumber : isNumber && Number.isFinite(value);
-}
-function IsVoid(value) {
-    const isUndefined = ValueGuard.IsUndefined(value);
-    return index_1.TypeSystem.AllowVoidNull ? isUndefined || value === null : isUndefined;
-}
-// --------------------------------------------------------------------------
 // Types
 // --------------------------------------------------------------------------
 function TAny(schema, references, value) {
     return true;
 }
 function TArray(schema, references, value) {
-    if (!Array.isArray(value)) {
+    if (!(0, guard_1.IsArray)(value))
         return false;
-    }
     if (IsDefined(schema.minItems) && !(value.length >= schema.minItems)) {
         return false;
     }
@@ -103,7 +75,7 @@ function TArray(schema, references, value) {
     }
     // prettier-ignore
     if (schema.uniqueItems === true && !((function () { const set = new Set(); for (const element of value) {
-        const hashed = ValueHash.Hash(element);
+        const hashed = (0, hash_1.Hash)(element);
         if (set.has(hashed)) {
             return false;
         }
@@ -114,7 +86,7 @@ function TArray(schema, references, value) {
         return false;
     }
     // contains
-    if (!(IsDefined(schema.contains) || IsNumber(schema.minContains) || IsNumber(schema.maxContains))) {
+    if (!(IsDefined(schema.contains) || (0, guard_1.IsNumber)(schema.minContains) || (0, guard_1.IsNumber)(schema.maxContains))) {
         return true; // exit
     }
     const containsSchema = IsDefined(schema.contains) ? schema.contains : Types.Type.Never();
@@ -122,85 +94,83 @@ function TArray(schema, references, value) {
     if (containsCount === 0) {
         return false;
     }
-    if (IsNumber(schema.minContains) && containsCount < schema.minContains) {
+    if ((0, guard_1.IsNumber)(schema.minContains) && containsCount < schema.minContains) {
         return false;
     }
-    if (IsNumber(schema.maxContains) && containsCount > schema.maxContains) {
+    if ((0, guard_1.IsNumber)(schema.maxContains) && containsCount > schema.maxContains) {
         return false;
     }
     return true;
 }
 function TAsyncIterator(schema, references, value) {
-    return IsObject(value) && Symbol.asyncIterator in value;
+    return (0, guard_1.IsAsyncIterator)(value);
 }
 function TBigInt(schema, references, value) {
-    if (!ValueGuard.IsBigInt(value)) {
+    if (!(0, guard_1.IsBigInt)(value))
         return false;
-    }
-    if (IsDefined(schema.multipleOf) && !(value % schema.multipleOf === BigInt(0))) {
+    if (IsDefined(schema.exclusiveMaximum) && !(value < schema.exclusiveMaximum)) {
         return false;
     }
     if (IsDefined(schema.exclusiveMinimum) && !(value > schema.exclusiveMinimum)) {
         return false;
     }
-    if (IsDefined(schema.exclusiveMaximum) && !(value < schema.exclusiveMaximum)) {
+    if (IsDefined(schema.maximum) && !(value <= schema.maximum)) {
         return false;
     }
     if (IsDefined(schema.minimum) && !(value >= schema.minimum)) {
         return false;
     }
-    if (IsDefined(schema.maximum) && !(value <= schema.maximum)) {
+    if (IsDefined(schema.multipleOf) && !(value % schema.multipleOf === BigInt(0))) {
         return false;
     }
     return true;
 }
 function TBoolean(schema, references, value) {
-    return typeof value === 'boolean';
+    return (0, guard_1.IsBoolean)(value);
 }
 function TConstructor(schema, references, value) {
     return Visit(schema.returns, references, value.prototype);
 }
 function TDate(schema, references, value) {
-    if (!(value instanceof Date)) {
+    if (!(0, guard_1.IsDate)(value))
         return false;
-    }
-    if (!IsNumber(value.getTime())) {
+    if (IsDefined(schema.exclusiveMaximumTimestamp) && !(value.getTime() < schema.exclusiveMaximumTimestamp)) {
         return false;
     }
     if (IsDefined(schema.exclusiveMinimumTimestamp) && !(value.getTime() > schema.exclusiveMinimumTimestamp)) {
         return false;
     }
-    if (IsDefined(schema.exclusiveMaximumTimestamp) && !(value.getTime() < schema.exclusiveMaximumTimestamp)) {
+    if (IsDefined(schema.maximumTimestamp) && !(value.getTime() <= schema.maximumTimestamp)) {
         return false;
     }
     if (IsDefined(schema.minimumTimestamp) && !(value.getTime() >= schema.minimumTimestamp)) {
         return false;
     }
-    if (IsDefined(schema.maximumTimestamp) && !(value.getTime() <= schema.maximumTimestamp)) {
+    if (IsDefined(schema.multipleOfTimestamp) && !(value.getTime() % schema.multipleOfTimestamp === 0)) {
         return false;
     }
     return true;
 }
 function TFunction(schema, references, value) {
-    return typeof value === 'function';
+    return (0, guard_1.IsFunction)(value);
 }
 function TInteger(schema, references, value) {
-    if (!ValueGuard.IsInteger(value)) {
+    if (!(0, guard_1.IsInteger)(value)) {
         return false;
     }
-    if (IsDefined(schema.multipleOf) && !(value % schema.multipleOf === 0)) {
+    if (IsDefined(schema.exclusiveMaximum) && !(value < schema.exclusiveMaximum)) {
         return false;
     }
     if (IsDefined(schema.exclusiveMinimum) && !(value > schema.exclusiveMinimum)) {
         return false;
     }
-    if (IsDefined(schema.exclusiveMaximum) && !(value < schema.exclusiveMaximum)) {
+    if (IsDefined(schema.maximum) && !(value <= schema.maximum)) {
         return false;
     }
     if (IsDefined(schema.minimum) && !(value >= schema.minimum)) {
         return false;
     }
-    if (IsDefined(schema.maximum) && !(value <= schema.maximum)) {
+    if (IsDefined(schema.multipleOf) && !(value % schema.multipleOf === 0)) {
         return false;
     }
     return true;
@@ -222,7 +192,7 @@ function TIntersect(schema, references, value) {
     }
 }
 function TIterator(schema, references, value) {
-    return IsObject(value) && Symbol.iterator in value;
+    return (0, guard_1.IsIterator)(value);
 }
 function TLiteral(schema, references, value) {
     return value === schema.const;
@@ -234,33 +204,31 @@ function TNot(schema, references, value) {
     return !Visit(schema.not, references, value);
 }
 function TNull(schema, references, value) {
-    return value === null;
+    return (0, guard_1.IsNull)(value);
 }
 function TNumber(schema, references, value) {
-    if (!IsNumber(value)) {
+    if (!index_1.TypeSystemPolicy.IsNumberLike(value))
         return false;
-    }
-    if (IsDefined(schema.multipleOf) && !(value % schema.multipleOf === 0)) {
+    if (IsDefined(schema.exclusiveMaximum) && !(value < schema.exclusiveMaximum)) {
         return false;
     }
     if (IsDefined(schema.exclusiveMinimum) && !(value > schema.exclusiveMinimum)) {
         return false;
     }
-    if (IsDefined(schema.exclusiveMaximum) && !(value < schema.exclusiveMaximum)) {
-        return false;
-    }
     if (IsDefined(schema.minimum) && !(value >= schema.minimum)) {
         return false;
     }
     if (IsDefined(schema.maximum) && !(value <= schema.maximum)) {
         return false;
     }
+    if (IsDefined(schema.multipleOf) && !(value % schema.multipleOf === 0)) {
+        return false;
+    }
     return true;
 }
 function TObject(schema, references, value) {
-    if (!IsObject(value)) {
+    if (!index_1.TypeSystemPolicy.IsObjectLike(value))
         return false;
-    }
     if (IsDefined(schema.minProperties) && !(Object.getOwnPropertyNames(value).length >= schema.minProperties)) {
         return false;
     }
@@ -279,7 +247,7 @@ function TObject(schema, references, value) {
             }
         }
         else {
-            if (IsExactOptionalProperty(value, knownKey) && !Visit(property, references, value[knownKey])) {
+            if (index_1.TypeSystemPolicy.IsExactOptionalProperty(value, knownKey) && !Visit(property, references, value[knownKey])) {
                 return false;
             }
         }
@@ -303,10 +271,10 @@ function TObject(schema, references, value) {
     }
 }
 function TPromise(schema, references, value) {
-    return typeof value === 'object' && typeof value.then === 'function';
+    return (0, guard_1.IsPromise)(value);
 }
 function TRecord(schema, references, value) {
-    if (!IsRecordObject(value)) {
+    if (!index_1.TypeSystemPolicy.IsRecordLike(value)) {
         return false;
     }
     if (IsDefined(schema.minProperties) && !(Object.getOwnPropertyNames(value).length >= schema.minProperties)) {
@@ -317,28 +285,26 @@ function TRecord(schema, references, value) {
     }
     const [patternKey, patternSchema] = Object.entries(schema.patternProperties)[0];
     const regex = new RegExp(patternKey);
-    return Object.entries(value).every(([key, value]) => {
-        if (regex.test(key)) {
-            return Visit(patternSchema, references, value);
-        }
-        if (typeof schema.additionalProperties === 'object') {
-            return Visit(schema.additionalProperties, references, value);
-        }
-        if (schema.additionalProperties === false) {
-            return false;
-        }
-        return true;
+    // prettier-ignore
+    const check1 = Object.entries(value).every(([key, value]) => {
+        return (regex.test(key)) ? Visit(patternSchema, references, value) : true;
     });
+    // prettier-ignore
+    const check2 = typeof schema.additionalProperties === 'object' ? Object.entries(value).every(([key, value]) => {
+        return (!regex.test(key)) ? Visit(schema.additionalProperties, references, value) : true;
+    }) : true;
+    const check3 = schema.additionalProperties === false
+        ? Object.getOwnPropertyNames(value).every((key) => {
+            return regex.test(key);
+        })
+        : true;
+    return check1 && check2 && check3;
 }
 function TRef(schema, references, value) {
-    const index = references.findIndex((foreign) => foreign.$id === schema.$ref);
-    if (index === -1)
-        throw new ValueCheckDereferenceError(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) {
-    if (!ValueGuard.IsString(value)) {
+    if (!(0, guard_1.IsString)(value)) {
         return false;
     }
     if (IsDefined(schema.minLength)) {
@@ -363,26 +329,16 @@ function TString(schema, references, value) {
     return true;
 }
 function TSymbol(schema, references, value) {
-    if (!(typeof value === 'symbol')) {
-        return false;
-    }
-    return true;
+    return (0, guard_1.IsSymbol)(value);
 }
 function TTemplateLiteral(schema, references, value) {
-    if (!ValueGuard.IsString(value)) {
-        return false;
-    }
-    return new RegExp(schema.pattern).test(value);
+    return (0, guard_1.IsString)(value) && new RegExp(schema.pattern).test(value);
 }
 function TThis(schema, references, value) {
-    const index = references.findIndex((foreign) => foreign.$id === schema.$ref);
-    if (index === -1)
-        throw new ValueCheckDereferenceError(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)) {
+    if (!(0, guard_1.IsArray)(value)) {
         return false;
     }
     if (schema.items === undefined && !(value.length === 0)) {
@@ -401,13 +357,13 @@ function TTuple(schema, references, value) {
     return true;
 }
 function TUndefined(schema, references, value) {
-    return value === undefined;
+    return (0, guard_1.IsUndefined)(value);
 }
 function TUnion(schema, references, value) {
     return schema.anyOf.some((inner) => Visit(inner, references, value));
 }
 function TUint8Array(schema, references, value) {
-    if (!(value instanceof Uint8Array)) {
+    if (!(0, guard_1.IsUint8Array)(value)) {
         return false;
     }
     if (IsDefined(schema.maxByteLength) && !(value.length <= schema.maxByteLength)) {
@@ -422,7 +378,7 @@ function TUnknown(schema, references, value) {
     return true;
 }
 function TVoid(schema, references, value) {
-    return IsVoid(value);
+    return index_1.TypeSystemPolicy.IsVoidLike(value);
 }
 function TKind(schema, references, value) {
     if (!Types.TypeRegistry.Has(schema[Types.Kind]))

package/value/clone.js

@@ -28,7 +28,7 @@ THE SOFTWARE.
 ---------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Clone = void 0;
-const ValueGuard = require("./guard");
+const guard_1 = require("./guard");
 // --------------------------------------------------------------------------
 // Clonable
 // --------------------------------------------------------------------------
@@ -49,42 +49,19 @@ function ValueType(value) {
     return value;
 }
 // --------------------------------------------------------------------------
-// Non-Clonable
-// --------------------------------------------------------------------------
-function AsyncIteratorType(value) {
-    return value;
-}
-function IteratorType(value) {
-    return value;
-}
-function FunctionType(value) {
-    return value;
-}
-function PromiseType(value) {
-    return value;
-}
-// --------------------------------------------------------------------------
 // Clone
 // --------------------------------------------------------------------------
 /** Returns a clone of the given value */
 function Clone(value) {
-    if (ValueGuard.IsArray(value))
+    if ((0, guard_1.IsArray)(value))
         return ArrayType(value);
-    if (ValueGuard.IsAsyncIterator(value))
-        return AsyncIteratorType(value);
-    if (ValueGuard.IsFunction(value))
-        return FunctionType(value);
-    if (ValueGuard.IsIterator(value))
-        return IteratorType(value);
-    if (ValueGuard.IsPromise(value))
-        return PromiseType(value);
-    if (ValueGuard.IsDate(value))
+    if ((0, guard_1.IsDate)(value))
         return DateType(value);
-    if (ValueGuard.IsPlainObject(value))
+    if ((0, guard_1.IsPlainObject)(value))
         return ObjectType(value);
-    if (ValueGuard.IsTypedArray(value))
+    if ((0, guard_1.IsTypedArray)(value))
         return TypedArrayType(value);
-    if (ValueGuard.IsValueType(value))
+    if ((0, guard_1.IsValueType)(value))
         return ValueType(value);
     throw new Error('ValueClone: Unable to clone value');
 }

package/value/convert.d.ts

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