@sinclair/typebox 0.28.17 → 0.28.19

package/compiler/compiler.d.ts

@@ -27,7 +27,7 @@ export declare class TypeCompilerTypeGuardError extends Error {
     constructor(schema: Types.TSchema);
 }
 export interface TypeCompilerOptions {
-    language: 'typescript' | 'javascript';
+    language?: 'typescript' | 'javascript';
 }
 /** Compiles Types for Runtime Type Checking */
 export declare namespace TypeCompiler {

package/compiler/compiler.js

@@ -207,7 +207,7 @@ var TypeCompiler;
         if (schema.uniqueItems === true)
             yield `((function() { const set = new Set(); for(const element of ${value}) { const hashed = hash(element); if(set.has(hashed)) { return false } else { set.add(hashed) } } return true })())`;
         const expression = CreateExpression(schema.items, references, 'value');
-        const parameter = CreateParameter('value');
+        const parameter = CreateParameter('value', 'any');
         yield `${value}.every((${parameter}) => ${expression})`;
     }
     function* BigInt(schema, references, value) {
@@ -521,20 +521,24 @@ var TypeCompiler;
         functions: new Set(),
         customs: new Map(), // custom type data
     };
-    function CreateExpression(schema, references, value) {
-        return `(${[...Visit(schema, references, value)].join(' && ')})`;
-    }
     function CreateFunctionName($id) {
         return `check_${Identifier.Encode($id)}`;
     }
-    function CreateParameter(name) {
-        const annotation = state.language === 'typescript' ? ': any' : '';
+    function CreateExpression(schema, references, value) {
+        return `(${[...Visit(schema, references, value)].join(' && ')})`;
+    }
+    function CreateParameter(name, type) {
+        const annotation = state.language === 'typescript' ? `: ${type}` : '';
         return `${name}${annotation}`;
     }
+    function CreateReturns(type) {
+        return state.language === 'typescript' ? `: ${type}` : '';
+    }
     function CreateFunction(name, schema, references, value) {
         const expression = [...Visit(schema, references, value, true)].map((condition) => `    ${condition}`).join(' &&\n');
-        const parameter = CreateParameter('value');
-        return `function ${name}(${parameter}) {\n  return (\n${expression}\n )\n}`;
+        const parameter = CreateParameter('value', 'any');
+        const returns = CreateReturns('boolean');
+        return `function ${name}(${parameter})${returns} {\n  return (\n${expression}\n )\n}`;
     }
     function PushFunction(functionBody) {
         state.variables.add(functionBody);
@@ -553,10 +557,11 @@ var TypeCompiler;
     function Build(schema, references) {
         const check = CreateFunction('check', schema, references, 'value'); // interior visit
         const locals = GetLocals();
-        const parameter = CreateParameter('value');
+        const parameter = CreateParameter('value', 'any');
+        const returns = CreateReturns('boolean');
         // prettier-ignore
         return IsString(schema.$id) // ensure top level schemas with $id's are hoisted
-            ? `${locals.join('\n')}\nreturn function check(${parameter}) {\n  return ${CreateFunctionName(schema.$id)}(value)\n}`
+            ? `${locals.join('\n')}\nreturn function check(${parameter})${returns} {\n  return ${CreateFunctionName(schema.$id)}(value)\n}`
             : `${locals.join('\n')}\nreturn ${check}`;
     }
     /** Returns the generated assertion code used to validate this type. */

package/package.json

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