@sinclair/typebox 0.28.18 → 0.28.20

package/errors/errors.d.ts

@@ -33,7 +33,7 @@ export declare enum ValueErrorType {
     NumberMultipleOf = 30,
     NumberExclusiveMinimum = 31,
     NumberExclusiveMaximum = 32,
-    NumberMinumum = 33,
+    NumberMinimum = 33,
     NumberMaximum = 34,
     Object = 35,
     ObjectMinProperties = 36,

package/errors/errors.js

@@ -69,7 +69,7 @@ var ValueErrorType;
     ValueErrorType[ValueErrorType["NumberMultipleOf"] = 30] = "NumberMultipleOf";
     ValueErrorType[ValueErrorType["NumberExclusiveMinimum"] = 31] = "NumberExclusiveMinimum";
     ValueErrorType[ValueErrorType["NumberExclusiveMaximum"] = 32] = "NumberExclusiveMaximum";
-    ValueErrorType[ValueErrorType["NumberMinumum"] = 33] = "NumberMinumum";
+    ValueErrorType[ValueErrorType["NumberMinimum"] = 33] = "NumberMinimum";
     ValueErrorType[ValueErrorType["NumberMaximum"] = 34] = "NumberMaximum";
     ValueErrorType[ValueErrorType["Object"] = 35] = "Object";
     ValueErrorType[ValueErrorType["ObjectMinProperties"] = 36] = "ObjectMinProperties";
@@ -337,10 +337,10 @@ var ValueErrors;
             yield { type: ValueErrorType.NumberExclusiveMaximum, schema, path, value, message: `Expected number to be less than ${schema.exclusiveMaximum}` };
         }
         if (IsDefined(schema.minimum) && !(value >= schema.minimum)) {
-            yield { type: ValueErrorType.NumberMaximum, schema, path, value, message: `Expected number to be greater or equal to ${schema.minimum}` };
+            yield { type: ValueErrorType.NumberMinimum, schema, path, value, message: `Expected number to be greater or equal to ${schema.minimum}` };
         }
         if (IsDefined(schema.maximum) && !(value <= schema.maximum)) {
-            yield { type: ValueErrorType.NumberMinumum, schema, path, value, message: `Expected number to be less or equal to ${schema.maximum}` };
+            yield { type: ValueErrorType.NumberMaximum, schema, path, value, message: `Expected number to be less or equal to ${schema.maximum}` };
         }
     }
     function* Object(schema, references, path, value) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.28.18",
+  "version": "0.28.20",
   "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;