@sinclair/typebox 0.24.7 → 0.24.8

package/value/create.js

@@ -27,13 +27,11 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CreateValue = void 0;
+exports.ValueCreate = void 0;
 const Types = require("../typebox");
-var CreateValue;
-(function (CreateValue) {
-    const referenceMap = new Map();
-    let recursionDepth = 0;
-    function Any(schema) {
+var ValueCreate;
+(function (ValueCreate) {
+    function Any(schema, references) {
         if (schema.default !== undefined) {
             return schema.default;
         }
@@ -41,20 +39,20 @@ var CreateValue;
             return {};
         }
     }
-    function Array(schema) {
+    function Array(schema, references) {
         if (schema.default !== undefined) {
             return schema.default;
         }
         else if (schema.minItems !== undefined) {
             return globalThis.Array.from({ length: schema.minItems }).map((item) => {
-                return CreateValue.Create(schema.items);
+                return ValueCreate.Create(schema.items, references);
             });
         }
         else {
             return [];
         }
     }
-    function Boolean(schema) {
+    function Boolean(schema, references) {
         if (schema.default !== undefined) {
             return schema.default;
         }
@@ -62,12 +60,12 @@ var CreateValue;
             return false;
         }
     }
-    function Constructor(schema) {
+    function Constructor(schema, references) {
         if (schema.default !== undefined) {
             return schema.default;
         }
         else {
-            const value = CreateValue.Create(schema.returns);
+            const value = ValueCreate.Create(schema.returns, references);
             if (typeof value === 'object' && !globalThis.Array.isArray(value)) {
                 return class {
                     constructor() {
@@ -84,7 +82,7 @@ var CreateValue;
             }
         }
     }
-    function Enum(schema) {
+    function Enum(schema, references) {
         if (schema.default !== undefined) {
             return schema.default;
         }
@@ -95,15 +93,15 @@ var CreateValue;
             return schema.anyOf[0].const;
         }
     }
-    function Function(schema) {
+    function Function(schema, references) {
         if (schema.default !== undefined) {
             return schema.default;
         }
         else {
-            return () => CreateValue.Create(schema.returns);
+            return () => ValueCreate.Create(schema.returns, references);
         }
     }
-    function Integer(schema) {
+    function Integer(schema, references) {
         if (schema.default !== undefined) {
             return schema.default;
         }
@@ -114,24 +112,13 @@ var CreateValue;
             return 0;
         }
     }
-    function Intersect(schema) {
-        if (schema.default !== undefined) {
-            return schema.default;
-        }
-        else {
-            return (schema.default ||
-                globalThis.Object.entries(schema.properties).reduce((acc, [key, schema]) => {
-                    return { ...acc, [key]: CreateValue.Create(schema) };
-                }, {}));
-        }
-    }
-    function Literal(schema) {
+    function Literal(schema, references) {
         return schema.const;
     }
-    function Null(schema) {
+    function Null(schema, references) {
         return null;
     }
-    function Number(schema) {
+    function Number(schema, references) {
         if (schema.default !== undefined) {
             return schema.default;
         }
@@ -142,35 +129,27 @@ var CreateValue;
             return 0;
         }
     }
-    function Object(schema) {
+    function Object(schema, references) {
         if (schema.default !== undefined) {
             return schema.default;
         }
         else {
-            // StackOverflow Prevention
-            if (schema['$dynamicAnchor'] !== undefined) {
-                for (const [key, value] of globalThis.Object.entries(schema.properties)) {
-                    if (value['$dynamicRef'] !== undefined && schema.required && schema.required.includes(key)) {
-                        throw Error(`Cannot create recursive object with immediate recursive property`);
-                    }
-                }
-            }
             const required = new Set(schema.required);
             return (schema.default ||
                 globalThis.Object.entries(schema.properties).reduce((acc, [key, schema]) => {
-                    return required.has(key) ? { ...acc, [key]: CreateValue.Create(schema) } : { ...acc };
+                    return required.has(key) ? { ...acc, [key]: ValueCreate.Create(schema, references) } : { ...acc };
                 }, {}));
         }
     }
-    function Promise(schema) {
+    function Promise(schema, references) {
         if (schema.default !== undefined) {
             return schema.default;
         }
         else {
-            return globalThis.Promise.resolve(CreateValue.Create(schema.item));
+            return globalThis.Promise.resolve(ValueCreate.Create(schema.item, references));
         }
     }
-    function Record(schema) {
+    function Record(schema, references) {
         const [keyPattern, valueSchema] = globalThis.Object.entries(schema.patternProperties)[0];
         if (schema.default !== undefined) {
             return schema.default;
@@ -178,14 +157,14 @@ var CreateValue;
         else if (!(keyPattern === '^.*$' || keyPattern === '^(0|[1-9][0-9]*)$')) {
             const propertyKeys = keyPattern.slice(1, keyPattern.length - 1).split('|');
             return propertyKeys.reduce((acc, key) => {
-                return { ...acc, [key]: Create(valueSchema) };
+                return { ...acc, [key]: Create(valueSchema, references) };
             }, {});
         }
         else {
             return {};
         }
     }
-    function Recursive(schema) {
+    function Recursive(schema, references) {
         if (schema.default !== undefined) {
             return schema.default;
         }
@@ -193,15 +172,29 @@ var CreateValue;
             throw new Error('Rec types require a default value');
         }
     }
-    function Ref(schema) {
+    function Ref(schema, references) {
+        if (schema.default !== undefined) {
+            return schema.default;
+        }
+        else {
+            const reference = references.find((reference) => reference.$id === schema.$ref);
+            if (reference === undefined)
+                throw new Error(`ValueCreate.Ref: Cannot find schema with $id '${schema.$ref}'.`);
+            return Visit(reference, references);
+        }
+    }
+    function Self(schema, references) {
         if (schema.default !== undefined) {
             return schema.default;
         }
         else {
-            throw new Error('Ref types require a default value');
+            const reference = references.find((reference) => reference.$id === schema.$ref);
+            if (reference === undefined)
+                throw new Error(`ValueCreate.Self: Cannot locate schema with $id '${schema.$ref}'`);
+            return Visit(reference, references);
         }
     }
-    function String(schema) {
+    function String(schema, references) {
         if (schema.pattern !== undefined) {
             if (schema.default === undefined) {
                 throw Error('String types with patterns must specify a default value');
@@ -219,7 +212,7 @@ var CreateValue;
             }
         }
     }
-    function Tuple(schema) {
+    function Tuple(schema, references) {
         if (schema.default !== undefined) {
             return schema.default;
         }
@@ -227,13 +220,13 @@ var CreateValue;
             return [];
         }
         else {
-            return globalThis.Array.from({ length: schema.minItems }).map((_, index) => CreateValue.Create(schema.items[index]));
+            return globalThis.Array.from({ length: schema.minItems }).map((_, index) => ValueCreate.Create(schema.items[index], references));
         }
     }
-    function Undefined(schema) {
+    function Undefined(schema, references) {
         return undefined;
     }
-    function Union(schema) {
+    function Union(schema, references) {
         if (schema.default !== undefined) {
             return schema.default;
         }
@@ -241,10 +234,10 @@ var CreateValue;
             throw Error('Cannot generate Union with empty set');
         }
         else {
-            return CreateValue.Create(schema.anyOf[0]);
+            return ValueCreate.Create(schema.anyOf[0], references);
         }
     }
-    function Uint8Array(schema) {
+    function Uint8Array(schema, references) {
         if (schema.default !== undefined) {
             return schema.default;
         }
@@ -255,7 +248,7 @@ var CreateValue;
             return new globalThis.Uint8Array(0);
         }
     }
-    function Unknown(schema) {
+    function Unknown(schema, references) {
         if (schema.default !== undefined) {
             return schema.default;
         }
@@ -263,75 +256,67 @@ var CreateValue;
             return {};
         }
     }
-    function Void(schema) {
+    function Void(schema, references) {
         return null;
     }
     /** Creates a value from the given schema. If the schema specifies a default value, then that value is returned. */
-    function Visit(schema) {
-        recursionDepth += 1;
-        if (recursionDepth >= 1000)
-            throw new Error('Cannot create value as schema contains a infinite expansion');
+    function Visit(schema, references) {
+        const anyReferences = schema.$id === undefined ? references : [schema, ...references];
         const anySchema = schema;
-        if (anySchema.$id !== undefined)
-            referenceMap.set(anySchema.$id, anySchema);
         switch (anySchema[Types.Kind]) {
             case 'Any':
-                return Any(anySchema);
+                return Any(anySchema, anyReferences);
             case 'Array':
-                return Array(anySchema);
+                return Array(anySchema, anyReferences);
             case 'Boolean':
-                return Boolean(anySchema);
+                return Boolean(anySchema, anyReferences);
             case 'Constructor':
-                return Constructor(anySchema);
+                return Constructor(anySchema, anyReferences);
             case 'Enum':
-                return Enum(anySchema);
+                return Enum(anySchema, anyReferences);
             case 'Function':
-                return Function(anySchema);
+                return Function(anySchema, anyReferences);
             case 'Integer':
-                return Integer(anySchema);
-            case 'Intersect':
-                return Intersect(anySchema);
+                return Integer(anySchema, anyReferences);
             case 'Literal':
-                return Literal(anySchema);
+                return Literal(anySchema, anyReferences);
             case 'Null':
-                return Null(anySchema);
+                return Null(anySchema, anyReferences);
             case 'Number':
-                return Number(anySchema);
+                return Number(anySchema, anyReferences);
             case 'Object':
-                return Object(anySchema);
+                return Object(anySchema, anyReferences);
             case 'Promise':
-                return Promise(anySchema);
+                return Promise(anySchema, anyReferences);
             case 'Record':
-                return Record(anySchema);
+                return Record(anySchema, anyReferences);
             case 'Rec':
-                return Recursive(anySchema);
+                return Recursive(anySchema, anyReferences);
             case 'Ref':
-                return Ref(anySchema);
+                return Ref(anySchema, anyReferences);
+            case 'Self':
+                return Self(anySchema, anyReferences);
             case 'String':
-                return String(anySchema);
+                return String(anySchema, anyReferences);
             case 'Tuple':
-                return Tuple(anySchema);
+                return Tuple(anySchema, anyReferences);
             case 'Undefined':
-                return Undefined(anySchema);
+                return Undefined(anySchema, anyReferences);
             case 'Union':
-                return Union(anySchema);
+                return Union(anySchema, anyReferences);
             case 'Uint8Array':
-                return Uint8Array(anySchema);
+                return Uint8Array(anySchema, anyReferences);
             case 'Unknown':
-                return Unknown(anySchema);
+                return Unknown(anySchema, anyReferences);
             case 'Void':
-                return Void(anySchema);
-            case 'Self':
-                return Visit(referenceMap.get(anySchema.$ref));
+                return Void(anySchema, anyReferences);
             default:
                 throw Error(`Unknown schema kind '${schema[Types.Kind]}'`);
         }
     }
-    CreateValue.Visit = Visit;
-    /** Creates a value from the given schema. If the schema specifies a default value, then that value is returned. */
-    function Create(schema) {
-        recursionDepth = 0;
-        return Visit(schema);
+    ValueCreate.Visit = Visit;
+    function Create(schema, references) {
+        return Visit(schema, references);
     }
-    CreateValue.Create = Create;
-})(CreateValue = exports.CreateValue || (exports.CreateValue = {}));
+    ValueCreate.Create = Create;
+})(ValueCreate = exports.ValueCreate || (exports.ValueCreate = {}));

package/value/errors.d.ts

@@ -0,0 +1,10 @@
+import * as Types from '../typebox';
+export interface ValueError {
+    schema: Types.TSchema;
+    path: string;
+    value: unknown;
+    message: string;
+}
+export declare namespace ValueErrors {
+    function Errors<T extends Types.TSchema>(schema: T, references: Types.TSchema[], value: any): IterableIterator<ValueError>;
+}