@sinclair/typebox 0.28.18 → 0.28.19

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.28.18",
+  "version": "0.28.19",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",

package/value/create.d.ts

@@ -19,8 +19,14 @@ export declare class ValueCreateDereferenceError extends Error {
     readonly schema: Types.TRef | Types.TThis;
     constructor(schema: Types.TRef | Types.TThis);
 }
+export declare class ValueCreateRecursiveInstantiationError extends Error {
+    readonly schema: Types.TSchema;
+    readonly recursiveMaxDepth: number;
+    constructor(schema: Types.TSchema, recursiveMaxDepth: number);
+}
 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(schema: Types.TSchema, references: Types.TSchema[]): unknown;
+    /** Creates a value from the given schema and references */
     function Create<T extends Types.TSchema>(schema: T, references: Types.TSchema[]): Types.Static<T>;
 }

package/value/create.js

@@ -27,7 +27,7 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ValueCreate = exports.ValueCreateDereferenceError = exports.ValueCreateTempateLiteralTypeError = exports.ValueCreateIntersectTypeError = exports.ValueCreateNeverTypeError = exports.ValueCreateUnknownTypeError = void 0;
+exports.ValueCreate = exports.ValueCreateRecursiveInstantiationError = exports.ValueCreateDereferenceError = exports.ValueCreateTempateLiteralTypeError = exports.ValueCreateIntersectTypeError = exports.ValueCreateNeverTypeError = exports.ValueCreateUnknownTypeError = void 0;
 const Types = require("../typebox");
 const check_1 = require("./check");
 // --------------------------------------------------------------------------
@@ -68,6 +68,14 @@ class ValueCreateDereferenceError extends Error {
     }
 }
 exports.ValueCreateDereferenceError = ValueCreateDereferenceError;
+class ValueCreateRecursiveInstantiationError extends Error {
+    constructor(schema, recursiveMaxDepth) {
+        super('ValueCreate: Value cannot be created as recursive type may produce value of infinite size. Consider using a default.');
+        this.schema = schema;
+        this.recursiveMaxDepth = recursiveMaxDepth;
+    }
+}
+exports.ValueCreateRecursiveInstantiationError = ValueCreateRecursiveInstantiationError;
 // --------------------------------------------------------------------------
 // ValueCreate
 // --------------------------------------------------------------------------
@@ -99,7 +107,7 @@ var ValueCreate;
         }
         else if (schema.minItems !== undefined) {
             return globalThis.Array.from({ length: schema.minItems }).map((item) => {
-                return ValueCreate.Create(schema.items, references);
+                return Visit(schema.items, references);
             });
         }
         else {
@@ -127,7 +135,7 @@ var ValueCreate;
             return schema.default;
         }
         else {
-            const value = ValueCreate.Create(schema.returns, references);
+            const value = Visit(schema.returns, references);
             if (typeof value === 'object' && !globalThis.Array.isArray(value)) {
                 return class {
                     constructor() {
@@ -160,7 +168,7 @@ var ValueCreate;
             return schema.default;
         }
         else {
-            return () => ValueCreate.Create(schema.returns, references);
+            return () => Visit(schema.returns, references);
         }
     }
     function Integer(schema, references) {
@@ -237,7 +245,7 @@ var ValueCreate;
             const required = new Set(schema.required);
             return (schema.default ||
                 globalThis.Object.entries(schema.properties).reduce((acc, [key, schema]) => {
-                    return required.has(key) ? { ...acc, [key]: ValueCreate.Create(schema, references) } : { ...acc };
+                    return required.has(key) ? { ...acc, [key]: Visit(schema, references) } : { ...acc };
                 }, {}));
         }
     }
@@ -246,7 +254,7 @@ var ValueCreate;
             return schema.default;
         }
         else {
-            return globalThis.Promise.resolve(ValueCreate.Create(schema.item, references));
+            return globalThis.Promise.resolve(Visit(schema.item, references));
         }
     }
     function Record(schema, references) {
@@ -257,7 +265,7 @@ var ValueCreate;
         else if (!(keyPattern === Types.PatternStringExact || keyPattern === Types.PatternNumberExact)) {
             const propertyKeys = keyPattern.slice(1, keyPattern.length - 1).split('|');
             return propertyKeys.reduce((acc, key) => {
-                return { ...acc, [key]: Create(valueSchema, references) };
+                return { ...acc, [key]: Visit(valueSchema, references) };
             }, {});
         }
         else {
@@ -269,7 +277,7 @@ var ValueCreate;
             return schema.default;
         }
         else {
-            const index = references.findIndex((foreign) => foreign.$id === schema.$id);
+            const index = references.findIndex((foreign) => foreign.$id === schema.$ref);
             if (index === -1)
                 throw new ValueCreateDereferenceError(schema);
             const target = references[index];
@@ -329,11 +337,13 @@ var ValueCreate;
         return sequence.next().value;
     }
     function This(schema, references) {
+        if (recursiveDepth++ > recursiveMaxDepth)
+            throw new ValueCreateRecursiveInstantiationError(schema, recursiveMaxDepth);
         if ('default' in schema) {
             return schema.default;
         }
         else {
-            const index = references.findIndex((foreign) => foreign.$id === schema.$id);
+            const index = references.findIndex((foreign) => foreign.$id === schema.$ref);
             if (index === -1)
                 throw new ValueCreateDereferenceError(schema);
             const target = references[index];
@@ -348,7 +358,7 @@ var ValueCreate;
             return [];
         }
         else {
-            return globalThis.Array.from({ length: schema.minItems }).map((_, index) => ValueCreate.Create(schema.items[index], references));
+            return globalThis.Array.from({ length: schema.minItems }).map((_, index) => Visit(schema.items[index], references));
         }
     }
     function Undefined(schema, references) {
@@ -367,7 +377,7 @@ var ValueCreate;
             throw new Error('ValueCreate.Union: Cannot create Union with zero variants');
         }
         else {
-            return ValueCreate.Create(schema.anyOf[0], references);
+            return Visit(schema.anyOf[0], references);
         }
     }
     function Uint8Array(schema, references) {
@@ -473,7 +483,14 @@ var ValueCreate;
         }
     }
     ValueCreate.Visit = Visit;
+    // --------------------------------------------------------
+    // State
+    // --------------------------------------------------------
+    const recursiveMaxDepth = 512;
+    let recursiveDepth = 0;
+    /** Creates a value from the given schema and references */
     function Create(schema, references) {
+        recursiveDepth = 0;
         return Visit(schema, references);
     }
     ValueCreate.Create = Create;