@sinclair/typebox 0.24.5 → 0.24.8

package/value/check.js

@@ -27,206 +27,260 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CheckValue = void 0;
+exports.ValueCheck = void 0;
 const Types = require("../typebox");
-var CheckValue;
-(function (CheckValue) {
-    const referenceMap = new Map();
-    function Any(schema, value) {
+var ValueCheck;
+(function (ValueCheck) {
+    function Any(schema, references, value) {
         return true;
     }
-    function Array(schema, value) {
-        if (typeof value !== 'object' || !globalThis.Array.isArray(value))
+    function Array(schema, references, value) {
+        if (!globalThis.Array.isArray(value)) {
             return false;
-        for (let i = 0; i < value.length; i++) {
-            if (!Visit(schema.items, value[i]))
-                return false;
         }
-        return true;
+        return value.every((val) => Visit(schema.items, references, val));
     }
-    function Boolean(schema, value) {
+    function Boolean(schema, references, value) {
         return typeof value === 'boolean';
     }
-    function Constructor(schema, value) {
-        return Visit(schema.returns, value.prototype); // check return type only (as an object)
-    }
-    function Enum(schema, value) {
-        for (const subschema of schema.anyOf) {
-            if (subschema.const === value)
-                return true;
-        }
-        return false;
+    function Constructor(schema, references, value) {
+        return Visit(schema.returns, references, value);
     }
-    function Function(schema, value) {
+    function Function(schema, references, value) {
         return typeof value === 'function';
     }
-    function Integer(schema, value) {
-        return typeof value === 'number' && globalThis.Number.isInteger(value);
-    }
-    function Intersect(schema, value) {
-        return Object(schema, value);
+    function Integer(schema, references, value) {
+        if (!(typeof value === 'number')) {
+            return false;
+        }
+        if (!globalThis.Number.isInteger(value)) {
+            return false;
+        }
+        if (schema.multipleOf && !(value % schema.multipleOf === 0)) {
+            return false;
+        }
+        if (schema.exclusiveMinimum && !(value > schema.exclusiveMinimum)) {
+            return false;
+        }
+        if (schema.exclusiveMaximum && !(value < schema.exclusiveMaximum)) {
+            return false;
+        }
+        if (schema.minimum && !(value >= schema.minimum)) {
+            return false;
+        }
+        if (schema.maximum && !(value <= schema.maximum)) {
+            return false;
+        }
+        return true;
     }
-    function Literal(schema, value) {
-        return schema.const === value;
+    function Literal(schema, references, value) {
+        return value === schema.const;
     }
-    function Null(schema, value) {
+    function Null(schema, references, value) {
         return value === null;
     }
-    function Number(schema, value) {
-        return typeof value === 'number';
+    function Number(schema, references, value) {
+        if (!(typeof value === 'number')) {
+            return false;
+        }
+        if (schema.multipleOf && !(value % schema.multipleOf === 0)) {
+            return false;
+        }
+        if (schema.exclusiveMinimum && !(value > schema.exclusiveMinimum)) {
+            return false;
+        }
+        if (schema.exclusiveMaximum && !(value < schema.exclusiveMaximum)) {
+            return false;
+        }
+        if (schema.minimum && !(value >= schema.minimum)) {
+            return false;
+        }
+        if (schema.maximum && !(value <= schema.maximum)) {
+            return false;
+        }
+        return true;
     }
-    function Object(schema, value) {
-        if (typeof value !== 'object' || value === null)
+    function Object(schema, references, value) {
+        if (!(typeof value === 'object' && value !== null && !globalThis.Array.isArray(value))) {
+            return false;
+        }
+        if (schema.minProperties !== undefined && !(globalThis.Object.keys(value).length >= schema.minProperties)) {
+            return false;
+        }
+        if (schema.maxProperties !== undefined && !(globalThis.Object.keys(value).length <= schema.maxProperties)) {
             return false;
+        }
         const propertyKeys = globalThis.Object.keys(schema.properties);
         if (schema.additionalProperties === false) {
-            const valueKeys = globalThis.Object.keys(value);
-            for (const valueKey of valueKeys) {
-                if (!propertyKeys.includes(valueKey))
+            // 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.keys(value).length === propertyKeys.length)) {
+                return false;
+            }
+            else {
+                if (!globalThis.Object.keys(value).every((key) => propertyKeys.includes(key))) {
                     return false;
+                }
             }
         }
         for (const propertyKey of propertyKeys) {
             const propertySchema = schema.properties[propertyKey];
-            const propertyValue = value[propertyKey];
-            if (propertyValue === undefined && schema.required !== undefined && !schema.required.includes(propertyKey))
-                return true;
-            if (!Visit(propertySchema, propertyValue))
-                return false;
+            if (schema.required && schema.required.includes(propertyKey)) {
+                if (!Visit(propertySchema, references, value[propertyKey])) {
+                    return false;
+                }
+            }
+            else {
+                if (value[propertyKey] !== undefined) {
+                    if (!Visit(propertySchema, references, value[propertyKey])) {
+                        return false;
+                    }
+                }
+            }
         }
         return true;
     }
-    function Promise(schema, value) {
-        return typeof value === 'object' && typeof value['then'] === 'function';
+    function Promise(schema, references, value) {
+        return typeof value === 'object' && typeof value.then === 'function';
     }
-    function Record(schema, value) {
-        if (typeof value !== 'object' || value === null)
+    function Record(schema, references, value) {
+        if (!(typeof value === 'object' && value !== null && !globalThis.Array.isArray(value))) {
             return false;
-        const propertySchema = globalThis.Object.values(schema.patternProperties)[0];
-        for (const key of globalThis.Object.keys(value)) {
-            const propertyValue = value[key];
-            if (!Visit(propertySchema, propertyValue))
+        }
+        const [keyPattern, valueSchema] = globalThis.Object.entries(schema.patternProperties)[0];
+        const regex = new RegExp(keyPattern);
+        if (!globalThis.Object.keys(value).every((key) => regex.test(key))) {
+            return false;
+        }
+        for (const propValue of globalThis.Object.values(value)) {
+            if (!Visit(valueSchema, references, propValue))
                 return false;
         }
         return true;
     }
-    function Recursive(schema, value) {
-        throw new Error('Cannot typeof recursive types');
-    }
-    function Ref(schema, value) {
-        throw new Error('Cannot typeof reference types');
+    function Ref(schema, references, value) {
+        const reference = references.find((reference) => reference.$id === schema.$ref);
+        if (reference === undefined)
+            throw new Error(`CheckValue.Ref: Cannot find schema with $id '${schema.$ref}'.`);
+        return Visit(reference, references, value);
     }
-    function Self(schema, value) {
-        if (!referenceMap.has(schema.$ref))
-            throw new Error(`Check: Cannot locate schema with $id '${schema.$id}' for referenced type`);
-        const referenced = referenceMap.get(schema.$ref);
-        return Visit(referenced, value);
+    function Self(schema, references, value) {
+        const reference = references.find((reference) => reference.$id === schema.$ref);
+        if (reference === undefined)
+            throw new Error(`CheckValue.Self: Cannot find schema with $id '${schema.$ref}'.`);
+        return Visit(reference, references, value);
     }
-    function String(schema, value) {
-        if (typeof value !== 'string')
+    function String(schema, references, value) {
+        if (!(typeof value === 'string')) {
             return false;
+        }
         if (schema.pattern !== undefined) {
             const regex = new RegExp(schema.pattern);
-            return value.match(regex) !== null;
+            if (!regex.test(value))
+                return false;
         }
         return true;
     }
-    function Tuple(schema, value) {
-        if (typeof value !== 'object' || !globalThis.Array.isArray(value))
+    function Tuple(schema, references, value) {
+        if (!global.Array.isArray(value)) {
             return false;
-        if (schema.items === undefined && value.length === 0)
-            return true;
-        if (schema.items === undefined)
+        }
+        if (schema.items === undefined && !(value.length === 0)) {
             return false;
-        if (value.length < schema.minItems || value.length > schema.maxItems)
+        }
+        if (!(value.length === schema.maxItems)) {
             return false;
+        }
+        if (!schema.items) {
+            return true;
+        }
         for (let i = 0; i < schema.items.length; i++) {
-            if (!Visit(schema.items[i], value[i]))
+            if (!Visit(schema.items[i], references, value[i]))
                 return false;
         }
         return true;
     }
-    function Undefined(schema, value) {
+    function Undefined(schema, references, value) {
         return value === undefined;
     }
-    function Union(schema, value) {
-        for (let i = 0; i < schema.anyOf.length; i++) {
-            if (Visit(schema.anyOf[i], value))
-                return true;
-        }
-        return false;
+    function Union(schema, references, value) {
+        return schema.anyOf.some((inner) => Visit(inner, references, value));
     }
-    function Uint8Array(schema, value) {
-        return value instanceof globalThis.Uint8Array;
+    function Uint8Array(schema, references, value) {
+        if (!(value instanceof globalThis.Uint8Array)) {
+            return false;
+        }
+        if (schema.maxByteLength && !(value.length <= schema.maxByteLength)) {
+            return false;
+        }
+        if (schema.minByteLength && !(value.length >= schema.minByteLength)) {
+            return false;
+        }
+        return true;
     }
-    function Unknown(schema, value) {
+    function Unknown(schema, references, value) {
         return true;
     }
-    function Void(schema, value) {
+    function Void(schema, references, value) {
         return value === null;
     }
-    function Visit(schema, value) {
-        if (schema.$id !== undefined)
-            referenceMap.set(schema.$id, schema);
+    function Visit(schema, references, value) {
+        const anyReferences = schema.$id === undefined ? references : [schema, ...references];
         const anySchema = schema;
         switch (anySchema[Types.Kind]) {
             case 'Any':
-                return Any(anySchema, value);
+                return Any(anySchema, anyReferences, value);
             case 'Array':
-                return Array(anySchema, value);
+                return Array(anySchema, anyReferences, value);
             case 'Boolean':
-                return Boolean(anySchema, value);
+                return Boolean(anySchema, anyReferences, value);
             case 'Constructor':
-                return Constructor(anySchema, value);
-            case 'Enum':
-                return Enum(anySchema, value);
+                return Constructor(anySchema, anyReferences, value);
             case 'Function':
-                return Function(anySchema, value);
+                return Function(anySchema, anyReferences, value);
             case 'Integer':
-                return Integer(anySchema, value);
-            case 'Intersect':
-                return Intersect(anySchema, value);
+                return Integer(anySchema, anyReferences, value);
             case 'Literal':
-                return Literal(anySchema, value);
+                return Literal(anySchema, anyReferences, value);
             case 'Null':
-                return Null(anySchema, value);
+                return Null(anySchema, anyReferences, value);
             case 'Number':
-                return Number(anySchema, value);
+                return Number(anySchema, anyReferences, value);
             case 'Object':
-                return Object(anySchema, value);
+                return Object(anySchema, anyReferences, value);
             case 'Promise':
-                return Promise(anySchema, value);
+                return Promise(anySchema, anyReferences, value);
             case 'Record':
-                return Record(anySchema, value);
-            case 'Rec':
-                return Recursive(anySchema, value);
+                return Record(anySchema, anyReferences, value);
             case 'Ref':
-                return Ref(anySchema, value);
+                return Ref(anySchema, anyReferences, value);
             case 'Self':
-                return Self(anySchema, value);
+                return Self(anySchema, anyReferences, value);
             case 'String':
-                return String(anySchema, value);
+                return String(anySchema, anyReferences, value);
             case 'Tuple':
-                return Tuple(anySchema, value);
+                return Tuple(anySchema, anyReferences, value);
             case 'Undefined':
-                return Undefined(anySchema, value);
+                return Undefined(anySchema, anyReferences, value);
             case 'Union':
-                return Union(anySchema, value);
+                return Union(anySchema, anyReferences, value);
             case 'Uint8Array':
-                return Uint8Array(anySchema, value);
+                return Uint8Array(anySchema, anyReferences, value);
             case 'Unknown':
-                return Unknown(anySchema, value);
+                return Unknown(anySchema, anyReferences, value);
             case 'Void':
-                return Void(anySchema, value);
+                return Void(anySchema, anyReferences, value);
             default:
                 throw Error(`Unknown schema kind '${schema[Types.Kind]}'`);
         }
     }
-    CheckValue.Visit = Visit;
-    function Check(schema, value) {
-        if (referenceMap.size > 0)
-            referenceMap.clear();
-        return Visit(schema, value);
+    // -------------------------------------------------------------------------
+    // Check
+    // -------------------------------------------------------------------------
+    function Check(schema, references, value) {
+        return schema.$id === undefined ? Visit(schema, references, value) : Visit(schema, [schema, ...references], value);
     }
-    CheckValue.Check = Check;
-})(CheckValue = exports.CheckValue || (exports.CheckValue = {}));
+    ValueCheck.Check = Check;
+})(ValueCheck = exports.ValueCheck || (exports.ValueCheck = {}));

package/value/create.d.ts

@@ -1,7 +1,6 @@
 import * as Types from '../typebox';
-export declare namespace CreateValue {
+export declare namespace ValueCreate {
     /** Creates a value from the given schema. If the schema specifies a default value, then that value is returned. */
-    function Visit<T extends Types.TSchema>(schema: T): Types.Static<T>;
-    /** Creates a value from the given schema. If the schema specifies a default value, then that value is returned. */
-    function Create<T extends Types.TSchema>(schema: T): Types.Static<T>;
+    function Visit<T extends Types.TSchema>(schema: T, references: Types.TSchema[]): Types.Static<T>;
+    function Create<T extends Types.TSchema, R extends Types.TSchema[]>(schema: T, references: [...R]): Types.Static<T>;
 }