@sinclair/typebox 0.25.24 → 0.26.0-dev.1

package/value/check.js

@@ -30,10 +30,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ValueCheck = exports.ValueCheckUnknownTypeError = void 0;
 const Types = require("../typebox");
 const index_1 = require("../system/index");
-const extends_1 = require("../guard/extends");
-const index_2 = require("../format/index");
-const index_3 = require("../custom/index");
-const index_4 = require("../hash/index");
+const hash_1 = require("./hash");
 class ValueCheckUnknownTypeError extends Error {
     constructor(schema) {
         super(`ValueCheck: ${schema[Types.Kind] ? `Unknown type '${schema[Types.Kind]}'` : 'Unknown type'}`);
@@ -46,16 +43,19 @@ var ValueCheck;
     // --------------------------------------------------------
     // Guards
     // --------------------------------------------------------
+    function IsBigInt(value) {
+        return typeof value === 'bigint';
+    }
     function IsNumber(value) {
-        return typeof value === 'number' && !isNaN(value);
+        return typeof value === 'number' && globalThis.Number.isFinite(value);
     }
     // --------------------------------------------------------
     // Guards
     // --------------------------------------------------------
-    function Any(schema, references, value) {
+    function Any(schema, value) {
         return true;
     }
-    function Array(schema, references, value) {
+    function Array(schema, value) {
         if (!globalThis.Array.isArray(value)) {
             return false;
         }
@@ -67,7 +67,7 @@ var ValueCheck;
         }
         // prettier-ignore
         if (schema.uniqueItems === true && !((function () { const set = new Set(); for (const element of value) {
-            const hashed = index_4.ValueHash.Create(element);
+            const hashed = hash_1.ValueHash.Create(element);
             if (set.has(hashed)) {
                 return false;
             }
@@ -77,19 +77,40 @@ var ValueCheck;
         } return true; })())) {
             return false;
         }
-        return value.every((val) => Visit(schema.items, references, val));
+        return value.every((value) => Visit(schema.items, value));
     }
-    function Boolean(schema, references, value) {
+    function BigInt(schema, value) {
+        if (typeof value !== 'bigint') {
+            return false;
+        }
+        if (IsBigInt(schema.multipleOf) && !(value % schema.multipleOf === globalThis.BigInt(0))) {
+            return false;
+        }
+        if (IsBigInt(schema.exclusiveMinimum) && !(value > schema.exclusiveMinimum)) {
+            return false;
+        }
+        if (IsBigInt(schema.exclusiveMaximum) && !(value < schema.exclusiveMaximum)) {
+            return false;
+        }
+        if (IsBigInt(schema.minimum) && !(value >= schema.minimum)) {
+            return false;
+        }
+        if (IsBigInt(schema.maximum) && !(value <= schema.maximum)) {
+            return false;
+        }
+        return true;
+    }
+    function Boolean(schema, value) {
         return typeof value === 'boolean';
     }
-    function Constructor(schema, references, value) {
-        return Visit(schema.returns, references, value.prototype);
+    function Constructor(schema, value) {
+        return Visit(schema.returns, value.prototype);
     }
-    function Date(schema, references, value) {
+    function Date(schema, value) {
         if (!(value instanceof globalThis.Date)) {
             return false;
         }
-        if (isNaN(value.getTime())) {
+        if (!globalThis.Number.isFinite(value.getTime())) {
             return false;
         }
         if (IsNumber(schema.exclusiveMinimumTimestamp) && !(value.getTime() > schema.exclusiveMinimumTimestamp)) {
@@ -106,10 +127,10 @@ var ValueCheck;
         }
         return true;
     }
-    function Function(schema, references, value) {
+    function Function(schema, value) {
         return typeof value === 'function';
     }
-    function Integer(schema, references, value) {
+    function Integer(schema, value) {
         if (!(typeof value === 'number' && globalThis.Number.isInteger(value))) {
             return false;
         }
@@ -130,23 +151,44 @@ var ValueCheck;
         }
         return true;
     }
-    function Literal(schema, references, value) {
+    function Intersect(schema, value) {
+        if (!schema.allOf.every((schema) => Visit(schema, value))) {
+            return false;
+        }
+        else if (schema.unevaluatedProperties === false) {
+            const schemaKeys = Types.KeyResolver.Resolve(schema);
+            const valueKeys = globalThis.Object.getOwnPropertyNames(value);
+            return valueKeys.every((key) => schemaKeys.includes(key));
+        }
+        else if (Types.TypeGuard.TSchema(schema.unevaluatedProperties)) {
+            const schemaKeys = Types.KeyResolver.Resolve(schema);
+            const valueKeys = globalThis.Object.getOwnPropertyNames(value);
+            return valueKeys.every((key) => schemaKeys.includes(key) || Visit(schema.unevaluatedProperties, value[key]));
+        }
+        else {
+            return true;
+        }
+    }
+    function Literal(schema, value) {
         return value === schema.const;
     }
-    function Never(schema, references, value) {
+    function Never(schema, value) {
         return false;
     }
-    function Null(schema, references, value) {
+    function Not(schema, value) {
+        return !Visit(schema.allOf[0].not, value) && Visit(schema.allOf[1], value);
+    }
+    function Null(schema, value) {
         return value === null;
     }
-    function Number(schema, references, value) {
+    function Number(schema, value) {
         if (index_1.TypeSystem.AllowNaN) {
             if (!(typeof value === 'number')) {
                 return false;
             }
         }
         else {
-            if (!(typeof value === 'number' && !isNaN(value))) {
+            if (!(typeof value === 'number' && globalThis.Number.isFinite(value))) {
                 return false;
             }
         }
@@ -167,7 +209,7 @@ var ValueCheck;
         }
         return true;
     }
-    function Object(schema, references, value) {
+    function Object(schema, value) {
         if (index_1.TypeSystem.AllowArrayObjects) {
             if (!(typeof value === 'object' && value !== null)) {
                 return false;
@@ -184,54 +226,45 @@ var ValueCheck;
         if (IsNumber(schema.maxProperties) && !(globalThis.Object.getOwnPropertyNames(value).length <= schema.maxProperties)) {
             return false;
         }
-        const propertyKeys = globalThis.Object.getOwnPropertyNames(schema.properties);
-        if (schema.additionalProperties === false) {
-            // optimization: If the property key length matches the required keys length
-            // then we only need check that the values property key length matches that
-            // of the property key length. This is because exhaustive testing for values
-            // will occur in subsequent property tests.
-            if (schema.required && schema.required.length === propertyKeys.length && !(globalThis.Object.getOwnPropertyNames(value).length === propertyKeys.length)) {
-                return false;
-            }
-            else {
-                if (!globalThis.Object.getOwnPropertyNames(value).every((key) => propertyKeys.includes(key))) {
+        const schemaKeys = globalThis.Object.getOwnPropertyNames(schema.properties);
+        for (const schemaKey of schemaKeys) {
+            const property = schema.properties[schemaKey];
+            if (schema.required && schema.required.includes(schemaKey)) {
+                if (!Visit(property, value[schemaKey])) {
                     return false;
                 }
+                if (Types.ExtendsUndefined.Check(property)) {
+                    return schemaKey in value;
+                }
             }
-        }
-        if (typeof schema.additionalProperties === 'object') {
-            for (const objectKey of globalThis.Object.getOwnPropertyNames(value)) {
-                if (propertyKeys.includes(objectKey))
-                    continue;
-                if (!Visit(schema.additionalProperties, references, value[objectKey])) {
+            else {
+                if (schemaKey in value && !Visit(property, value[schemaKey])) {
                     return false;
                 }
             }
         }
-        for (const propertyKey of propertyKeys) {
-            const propertySchema = schema.properties[propertyKey];
-            if (schema.required && schema.required.includes(propertyKey)) {
-                if (!Visit(propertySchema, references, value[propertyKey])) {
-                    return false;
-                }
-                if (extends_1.TypeExtends.Undefined(propertySchema)) {
-                    return propertyKey in value;
-                }
+        if (schema.additionalProperties === false) {
+            const valueKeys = globalThis.Object.getOwnPropertyNames(value);
+            // optimization: value is valid if schemaKey length matches the valueKey length
+            if (schema.required && schema.required.length === schemaKeys.length && valueKeys.length === schemaKeys.length) {
+                return true;
             }
             else {
-                if (value[propertyKey] !== undefined) {
-                    if (!Visit(propertySchema, references, value[propertyKey])) {
-                        return false;
-                    }
-                }
+                return valueKeys.every((valueKey) => schemaKeys.includes(valueKey));
             }
         }
-        return true;
+        else if (typeof schema.additionalProperties === 'object') {
+            const valueKeys = globalThis.Object.getOwnPropertyNames(value);
+            return valueKeys.every((key) => schemaKeys.includes(key) || Visit(schema.additionalProperties, value[key]));
+        }
+        else {
+            return true;
+        }
     }
-    function Promise(schema, references, value) {
+    function Promise(schema, value) {
         return typeof value === 'object' && typeof value.then === 'function';
     }
-    function Record(schema, references, value) {
+    function Record(schema, value) {
         if (index_1.TypeSystem.AllowArrayObjects) {
             if (!(typeof value === 'object' && value !== null && !(value instanceof globalThis.Date))) {
                 return false;
@@ -248,24 +281,18 @@ var ValueCheck;
             return false;
         }
         for (const propValue of globalThis.Object.values(value)) {
-            if (!Visit(valueSchema, references, propValue))
+            if (!Visit(valueSchema, propValue))
                 return false;
         }
         return true;
     }
-    function Ref(schema, references, value) {
-        const reference = references.find((reference) => reference.$id === schema.$ref);
-        if (reference === undefined)
-            throw new Error(`ValueCheck.Ref: Cannot find schema with $id '${schema.$ref}'.`);
-        return Visit(reference, references, value);
+    function Ref(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 Error(`ValueCheck.Self: Cannot find schema with $id '${schema.$ref}'.`);
-        return Visit(reference, references, value);
+    function Self(schema, value) {
+        return Visit(Types.ReferenceRegistry.DerefOne(schema), value);
     }
-    function String(schema, references, value) {
+    function String(schema, value) {
         if (!(typeof value === 'string')) {
             return false;
         }
@@ -283,14 +310,20 @@ var ValueCheck;
                 return false;
         }
         if (schema.format !== undefined) {
-            if (!index_2.Format.Has(schema.format))
+            if (!Types.FormatRegistry.Has(schema.format))
                 return false;
-            const func = index_2.Format.Get(schema.format);
+            const func = Types.FormatRegistry.Get(schema.format);
             return func(value);
         }
         return true;
     }
-    function Tuple(schema, references, value) {
+    function Symbol(schema, value) {
+        if (!(typeof value === 'symbol')) {
+            return false;
+        }
+        return true;
+    }
+    function Tuple(schema, value) {
         if (!globalThis.Array.isArray(value)) {
             return false;
         }
@@ -304,18 +337,18 @@ var ValueCheck;
             return true;
         }
         for (let i = 0; i < schema.items.length; i++) {
-            if (!Visit(schema.items[i], references, value[i]))
+            if (!Visit(schema.items[i], value[i]))
                 return false;
         }
         return true;
     }
-    function Undefined(schema, references, value) {
+    function Undefined(schema, value) {
         return value === undefined;
     }
-    function Union(schema, references, value) {
-        return schema.anyOf.some((inner) => Visit(inner, references, value));
+    function Union(schema, value) {
+        return schema.anyOf.some((inner) => Visit(inner, value));
     }
-    function Uint8Array(schema, references, value) {
+    function Uint8Array(schema, value) {
         if (!(value instanceof globalThis.Uint8Array)) {
             return false;
         }
@@ -327,79 +360,91 @@ var ValueCheck;
         }
         return true;
     }
-    function Unknown(schema, references, value) {
+    function Unknown(schema, value) {
         return true;
     }
-    function Void(schema, references, value) {
-        return value === null;
+    function Void(schema, value) {
+        if (index_1.TypeSystem.AllowVoidNull) {
+            return value === undefined || value === null;
+        }
+        else {
+            return value === undefined;
+        }
     }
-    function UserDefined(schema, references, value) {
-        if (!index_3.Custom.Has(schema[Types.Kind]))
+    function UserDefined(schema, value) {
+        if (!Types.TypeRegistry.Has(schema[Types.Kind]))
             return false;
-        const func = index_3.Custom.Get(schema[Types.Kind]);
+        const func = Types.TypeRegistry.Get(schema[Types.Kind]);
         return func(schema, value);
     }
-    function Visit(schema, references, value) {
-        const anyReferences = schema.$id === undefined ? references : [schema, ...references];
+    function Visit(schema, value) {
         const anySchema = schema;
         switch (anySchema[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_3.Custom.Has(anySchema[Types.Kind]))
+                if (!Types.TypeRegistry.Has(anySchema[Types.Kind]))
                     throw new ValueCheckUnknownTypeError(anySchema);
-                return UserDefined(anySchema, anyReferences, value);
+                return UserDefined(anySchema, value);
         }
     }
     // -------------------------------------------------------------------------
     // Check
     // -------------------------------------------------------------------------
-    function Check(schema, references, value) {
-        return schema.$id === undefined ? Visit(schema, references, value) : Visit(schema, [schema, ...references], value);
+    function Check(schema, value) {
+        return Visit(schema, value);
     }
     ValueCheck.Check = Check;
 })(ValueCheck = exports.ValueCheck || (exports.ValueCheck = {}));

package/value/convert.d.ts

@@ -0,0 +1,13 @@
+import * as Types from '../typebox';
+export declare class ValueConvertReferenceTypeError extends Error {
+    readonly schema: Types.TRef | Types.TSelf;
+    constructor(schema: Types.TRef | Types.TSelf);
+}
+export declare class ValueConvertUnknownTypeError extends Error {
+    readonly schema: Types.TSchema;
+    constructor(schema: Types.TSchema);
+}
+export declare namespace ValueConvert {
+    function Visit(schema: Types.TSchema, value: any): unknown;
+    function Convert<T extends Types.TSchema>(schema: T, value: any): unknown;
+}