@sinclair/typebox 0.34.10 → 0.34.11

package/build/cjs/compiler/compiler.js

@@ -13,10 +13,11 @@ const index_8 = require("../type/registry/index");
 const index_9 = require("../type/keyof/index");
 const extends_undefined_1 = require("../type/extends/extends-undefined");
 const index_10 = require("../type/never/index");
+const index_11 = require("../type/ref/index");
 // ------------------------------------------------------------------
 // ValueGuard
 // ------------------------------------------------------------------
-const index_11 = require("../value/guard/index");
+const index_12 = require("../value/guard/index");
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
@@ -211,17 +212,17 @@ var TypeCompiler;
     function* FromArray(schema, references, value) {
         yield `Array.isArray(${value})`;
         const [parameter, accumulator] = [CreateParameter('value', 'any'), CreateParameter('acc', 'number')];
-        if ((0, index_11.IsNumber)(schema.maxItems))
+        if ((0, index_12.IsNumber)(schema.maxItems))
             yield `${value}.length <= ${schema.maxItems}`;
-        if ((0, index_11.IsNumber)(schema.minItems))
+        if ((0, index_12.IsNumber)(schema.minItems))
             yield `${value}.length >= ${schema.minItems}`;
         const elementExpression = CreateExpression(schema.items, references, 'value');
         yield `${value}.every((${parameter}) => ${elementExpression})`;
-        if ((0, type_1.IsSchema)(schema.contains) || (0, index_11.IsNumber)(schema.minContains) || (0, index_11.IsNumber)(schema.maxContains)) {
+        if ((0, type_1.IsSchema)(schema.contains) || (0, index_12.IsNumber)(schema.minContains) || (0, index_12.IsNumber)(schema.maxContains)) {
             const containsSchema = (0, type_1.IsSchema)(schema.contains) ? schema.contains : (0, index_10.Never)();
             const checkExpression = CreateExpression(containsSchema, references, 'value');
-            const checkMinContains = (0, index_11.IsNumber)(schema.minContains) ? [`(count >= ${schema.minContains})`] : [];
-            const checkMaxContains = (0, index_11.IsNumber)(schema.maxContains) ? [`(count <= ${schema.maxContains})`] : [];
+            const checkMinContains = (0, index_12.IsNumber)(schema.minContains) ? [`(count >= ${schema.minContains})`] : [];
+            const checkMaxContains = (0, index_12.IsNumber)(schema.maxContains) ? [`(count <= ${schema.maxContains})`] : [];
             const checkCount = `const count = value.reduce((${accumulator}, ${parameter}) => ${checkExpression} ? acc + 1 : acc, 0)`;
             const check = [`(count > 0)`, ...checkMinContains, ...checkMaxContains].join(' && ');
             yield `((${parameter}) => { ${checkCount}; return ${check}})(${value})`;
@@ -237,15 +238,15 @@ var TypeCompiler;
     }
     function* FromBigInt(schema, references, value) {
         yield `(typeof ${value} === 'bigint')`;
-        if ((0, index_11.IsBigInt)(schema.exclusiveMaximum))
+        if ((0, index_12.IsBigInt)(schema.exclusiveMaximum))
             yield `${value} < BigInt(${schema.exclusiveMaximum})`;
-        if ((0, index_11.IsBigInt)(schema.exclusiveMinimum))
+        if ((0, index_12.IsBigInt)(schema.exclusiveMinimum))
             yield `${value} > BigInt(${schema.exclusiveMinimum})`;
-        if ((0, index_11.IsBigInt)(schema.maximum))
+        if ((0, index_12.IsBigInt)(schema.maximum))
             yield `${value} <= BigInt(${schema.maximum})`;
-        if ((0, index_11.IsBigInt)(schema.minimum))
+        if ((0, index_12.IsBigInt)(schema.minimum))
             yield `${value} >= BigInt(${schema.minimum})`;
-        if ((0, index_11.IsBigInt)(schema.multipleOf))
+        if ((0, index_12.IsBigInt)(schema.multipleOf))
             yield `(${value} % BigInt(${schema.multipleOf})) === 0`;
     }
     function* FromBoolean(schema, references, value) {
@@ -256,36 +257,37 @@ var TypeCompiler;
     }
     function* FromDate(schema, references, value) {
         yield `(${value} instanceof Date) && Number.isFinite(${value}.getTime())`;
-        if ((0, index_11.IsNumber)(schema.exclusiveMaximumTimestamp))
+        if ((0, index_12.IsNumber)(schema.exclusiveMaximumTimestamp))
             yield `${value}.getTime() < ${schema.exclusiveMaximumTimestamp}`;
-        if ((0, index_11.IsNumber)(schema.exclusiveMinimumTimestamp))
+        if ((0, index_12.IsNumber)(schema.exclusiveMinimumTimestamp))
             yield `${value}.getTime() > ${schema.exclusiveMinimumTimestamp}`;
-        if ((0, index_11.IsNumber)(schema.maximumTimestamp))
+        if ((0, index_12.IsNumber)(schema.maximumTimestamp))
             yield `${value}.getTime() <= ${schema.maximumTimestamp}`;
-        if ((0, index_11.IsNumber)(schema.minimumTimestamp))
+        if ((0, index_12.IsNumber)(schema.minimumTimestamp))
             yield `${value}.getTime() >= ${schema.minimumTimestamp}`;
-        if ((0, index_11.IsNumber)(schema.multipleOfTimestamp))
+        if ((0, index_12.IsNumber)(schema.multipleOfTimestamp))
             yield `(${value}.getTime() % ${schema.multipleOfTimestamp}) === 0`;
     }
     function* FromFunction(schema, references, value) {
         yield `(typeof ${value} === 'function')`;
     }
     function* FromImport(schema, references, value) {
-        const definitions = globalThis.Object.values(schema.$defs);
-        const target = schema.$defs[schema.$ref];
-        yield* Visit(target, [...references, ...definitions], value);
+        const members = globalThis.Object.getOwnPropertyNames(schema.$defs).reduce((result, key) => {
+            return [...result, schema.$defs[key]];
+        }, []);
+        yield* Visit((0, index_11.Ref)(schema.$ref), [...references, ...members], value);
     }
     function* FromInteger(schema, references, value) {
         yield `Number.isInteger(${value})`;
-        if ((0, index_11.IsNumber)(schema.exclusiveMaximum))
+        if ((0, index_12.IsNumber)(schema.exclusiveMaximum))
             yield `${value} < ${schema.exclusiveMaximum}`;
-        if ((0, index_11.IsNumber)(schema.exclusiveMinimum))
+        if ((0, index_12.IsNumber)(schema.exclusiveMinimum))
             yield `${value} > ${schema.exclusiveMinimum}`;
-        if ((0, index_11.IsNumber)(schema.maximum))
+        if ((0, index_12.IsNumber)(schema.maximum))
             yield `${value} <= ${schema.maximum}`;
-        if ((0, index_11.IsNumber)(schema.minimum))
+        if ((0, index_12.IsNumber)(schema.minimum))
             yield `${value} >= ${schema.minimum}`;
-        if ((0, index_11.IsNumber)(schema.multipleOf))
+        if ((0, index_12.IsNumber)(schema.multipleOf))
             yield `(${value} % ${schema.multipleOf}) === 0`;
     }
     function* FromIntersect(schema, references, value) {
@@ -327,22 +329,22 @@ var TypeCompiler;
     }
     function* FromNumber(schema, references, value) {
         yield Policy.IsNumberLike(value);
-        if ((0, index_11.IsNumber)(schema.exclusiveMaximum))
+        if ((0, index_12.IsNumber)(schema.exclusiveMaximum))
             yield `${value} < ${schema.exclusiveMaximum}`;
-        if ((0, index_11.IsNumber)(schema.exclusiveMinimum))
+        if ((0, index_12.IsNumber)(schema.exclusiveMinimum))
             yield `${value} > ${schema.exclusiveMinimum}`;
-        if ((0, index_11.IsNumber)(schema.maximum))
+        if ((0, index_12.IsNumber)(schema.maximum))
             yield `${value} <= ${schema.maximum}`;
-        if ((0, index_11.IsNumber)(schema.minimum))
+        if ((0, index_12.IsNumber)(schema.minimum))
             yield `${value} >= ${schema.minimum}`;
-        if ((0, index_11.IsNumber)(schema.multipleOf))
+        if ((0, index_12.IsNumber)(schema.multipleOf))
             yield `(${value} % ${schema.multipleOf}) === 0`;
     }
     function* FromObject(schema, references, value) {
         yield Policy.IsObjectLike(value);
-        if ((0, index_11.IsNumber)(schema.minProperties))
+        if ((0, index_12.IsNumber)(schema.minProperties))
             yield `Object.getOwnPropertyNames(${value}).length >= ${schema.minProperties}`;
-        if ((0, index_11.IsNumber)(schema.maxProperties))
+        if ((0, index_12.IsNumber)(schema.maxProperties))
             yield `Object.getOwnPropertyNames(${value}).length <= ${schema.maxProperties}`;
         const knownKeys = Object.getOwnPropertyNames(schema.properties);
         for (const knownKey of knownKeys) {
@@ -378,9 +380,9 @@ var TypeCompiler;
     }
     function* FromRecord(schema, references, value) {
         yield Policy.IsRecordLike(value);
-        if ((0, index_11.IsNumber)(schema.minProperties))
+        if ((0, index_12.IsNumber)(schema.minProperties))
             yield `Object.getOwnPropertyNames(${value}).length >= ${schema.minProperties}`;
-        if ((0, index_11.IsNumber)(schema.maxProperties))
+        if ((0, index_12.IsNumber)(schema.maxProperties))
             yield `Object.getOwnPropertyNames(${value}).length <= ${schema.maxProperties}`;
         const [patternKey, patternSchema] = Object.entries(schema.patternProperties)[0];
         const variable = CreateVariable(`${new RegExp(patternKey)}`);
@@ -392,29 +394,25 @@ var TypeCompiler;
     function* FromRef(schema, references, value) {
         const target = (0, index_5.Deref)(schema, references);
         // Reference: If we have seen this reference before we can just yield and return the function call.
-        // If this isn't the case we defer to visit to generate and set the _recursion_end_for_ for subsequent
-        // passes. This operation is very awkward as we are using the functions state to store values to
-        // enable self referential types to terminate. This needs to be refactored.
-        const recursiveEnd = `_recursion_end_for_${schema.$ref}`;
-        if (state.functions.has(recursiveEnd))
+        // If this isn't the case we defer to visit to generate and set the function for subsequent passes.
+        if (state.functions.has(schema.$ref))
             return yield `${CreateFunctionName(schema.$ref)}(${value})`;
-        state.functions.set(recursiveEnd, ''); // terminate recursion here by setting the name.
         yield* Visit(target, references, value);
     }
     function* FromRegExp(schema, references, value) {
         const variable = CreateVariable(`${new RegExp(schema.source, schema.flags)};`);
         yield `(typeof ${value} === 'string')`;
-        if ((0, index_11.IsNumber)(schema.maxLength))
+        if ((0, index_12.IsNumber)(schema.maxLength))
             yield `${value}.length <= ${schema.maxLength}`;
-        if ((0, index_11.IsNumber)(schema.minLength))
+        if ((0, index_12.IsNumber)(schema.minLength))
             yield `${value}.length >= ${schema.minLength}`;
         yield `${variable}.test(${value})`;
     }
     function* FromString(schema, references, value) {
         yield `(typeof ${value} === 'string')`;
-        if ((0, index_11.IsNumber)(schema.maxLength))
+        if ((0, index_12.IsNumber)(schema.maxLength))
             yield `${value}.length <= ${schema.maxLength}`;
-        if ((0, index_11.IsNumber)(schema.minLength))
+        if ((0, index_12.IsNumber)(schema.minLength))
             yield `${value}.length >= ${schema.minLength}`;
         if (schema.pattern !== undefined) {
             const variable = CreateVariable(`${new RegExp(schema.pattern)};`);
@@ -455,9 +453,9 @@ var TypeCompiler;
     }
     function* FromUint8Array(schema, references, value) {
         yield `${value} instanceof Uint8Array`;
-        if ((0, index_11.IsNumber)(schema.maxByteLength))
+        if ((0, index_12.IsNumber)(schema.maxByteLength))
             yield `(${value}.length <= ${schema.maxByteLength})`;
-        if ((0, index_11.IsNumber)(schema.minByteLength))
+        if ((0, index_12.IsNumber)(schema.minByteLength))
             yield `(${value}.length >= ${schema.minByteLength})`;
     }
     function* FromUnknown(schema, references, value) {
@@ -472,17 +470,21 @@ var TypeCompiler;
         yield `kind('${schema[index_7.Kind]}', ${instance}, ${value})`;
     }
     function* Visit(schema, references, value, useHoisting = true) {
-        const references_ = (0, index_11.IsString)(schema.$id) ? [...references, schema] : references;
+        const references_ = (0, index_12.IsString)(schema.$id) ? [...references, schema] : references;
         const schema_ = schema;
         // --------------------------------------------------------------
         // Hoisting
         // --------------------------------------------------------------
-        if (useHoisting && (0, index_11.IsString)(schema.$id)) {
+        if (useHoisting && (0, index_12.IsString)(schema.$id)) {
             const functionName = CreateFunctionName(schema.$id);
             if (state.functions.has(functionName)) {
                 return yield `${functionName}(${value})`;
             }
             else {
+                // Note: In the case of cyclic types, we need to create a 'functions' record
+                // to prevent infinitely re-visiting the CreateFunction. Subsequent attempts
+                // to visit will be caught by the above condition.
+                state.functions.set(functionName, '<deferred>');
                 const functionCode = CreateFunction(functionName, schema, references, 'value', false);
                 state.functions.set(functionName, functionCode);
                 return yield `${functionName}(${value})`;
@@ -607,7 +609,7 @@ var TypeCompiler;
         const functions = [...state.functions.values()];
         const variables = [...state.variables.values()];
         // prettier-ignore
-        const checkFunction = (0, index_11.IsString)(schema.$id) // ensure top level schemas with $id's are hoisted
+        const checkFunction = (0, index_12.IsString)(schema.$id) // ensure top level schemas with $id's are hoisted
             ? `return function check(${parameter})${returns} {\n  return ${CreateFunctionName(schema.$id)}(value)\n}`
             : `return ${functionCode}`;
         return [...variables, ...functions, checkFunction].join('\n');
@@ -616,8 +618,8 @@ var TypeCompiler;
     function Code(...args) {
         const defaults = { language: 'javascript' };
         // prettier-ignore
-        const [schema, references, options] = (args.length === 2 && (0, index_11.IsArray)(args[1]) ? [args[0], args[1], defaults] :
-            args.length === 2 && !(0, index_11.IsArray)(args[1]) ? [args[0], [], args[1]] :
+        const [schema, references, options] = (args.length === 2 && (0, index_12.IsArray)(args[1]) ? [args[0], args[1], defaults] :
+            args.length === 2 && !(0, index_12.IsArray)(args[1]) ? [args[0], [], args[1]] :
                 args.length === 3 ? [args[0], args[1], args[2]] :
                     args.length === 1 ? [args[0], [], defaults] :
                         [null, [], defaults]);

package/build/esm/compiler/compiler.mjs

@@ -9,6 +9,7 @@ import { TypeRegistry, FormatRegistry } from '../type/registry/index.mjs';
 import { KeyOfPattern } from '../type/keyof/index.mjs';
 import { ExtendsUndefinedCheck } from '../type/extends/extends-undefined.mjs';
 import { Never } from '../type/never/index.mjs';
+import { Ref } from '../type/ref/index.mjs';
 // ------------------------------------------------------------------
 // ValueGuard
 // ------------------------------------------------------------------
@@ -264,9 +265,10 @@ export var TypeCompiler;
         yield `(typeof ${value} === 'function')`;
     }
     function* FromImport(schema, references, value) {
-        const definitions = globalThis.Object.values(schema.$defs);
-        const target = schema.$defs[schema.$ref];
-        yield* Visit(target, [...references, ...definitions], value);
+        const members = globalThis.Object.getOwnPropertyNames(schema.$defs).reduce((result, key) => {
+            return [...result, schema.$defs[key]];
+        }, []);
+        yield* Visit(Ref(schema.$ref), [...references, ...members], value);
     }
     function* FromInteger(schema, references, value) {
         yield `Number.isInteger(${value})`;
@@ -385,13 +387,9 @@ export var TypeCompiler;
     function* FromRef(schema, references, value) {
         const target = Deref(schema, references);
         // Reference: If we have seen this reference before we can just yield and return the function call.
-        // If this isn't the case we defer to visit to generate and set the _recursion_end_for_ for subsequent
-        // passes. This operation is very awkward as we are using the functions state to store values to
-        // enable self referential types to terminate. This needs to be refactored.
-        const recursiveEnd = `_recursion_end_for_${schema.$ref}`;
-        if (state.functions.has(recursiveEnd))
+        // If this isn't the case we defer to visit to generate and set the function for subsequent passes.
+        if (state.functions.has(schema.$ref))
             return yield `${CreateFunctionName(schema.$ref)}(${value})`;
-        state.functions.set(recursiveEnd, ''); // terminate recursion here by setting the name.
         yield* Visit(target, references, value);
     }
     function* FromRegExp(schema, references, value) {
@@ -476,6 +474,10 @@ export var TypeCompiler;
                 return yield `${functionName}(${value})`;
             }
             else {
+                // Note: In the case of cyclic types, we need to create a 'functions' record
+                // to prevent infinitely re-visiting the CreateFunction. Subsequent attempts
+                // to visit will be caught by the above condition.
+                state.functions.set(functionName, '<deferred>');
                 const functionCode = CreateFunction(functionName, schema, references, 'value', false);
                 state.functions.set(functionName, functionCode);
                 return yield `${functionName}(${value})`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.34.10",
+  "version": "0.34.11",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",