@sinclair/typebox 0.28.16 → 0.28.18

package/compiler/compiler.d.ts

@@ -26,10 +26,13 @@ export declare class TypeCompilerTypeGuardError extends Error {
     readonly schema: Types.TSchema;
     constructor(schema: Types.TSchema);
 }
+export interface TypeCompilerOptions {
+    language?: 'typescript' | 'javascript';
+}
 /** Compiles Types for Runtime Type Checking */
 export declare namespace TypeCompiler {
     /** Returns the generated assertion code used to validate this type. */
-    function Code<T extends Types.TSchema>(schema: T, references?: Types.TSchema[]): string;
+    function Code<T extends Types.TSchema>(schema: T, references?: Types.TSchema[], options?: TypeCompilerOptions): string;
     /** Compiles the given type for runtime type checking. This compiler only accepts known TypeBox types non-inclusive of unsafe types. */
     function Compile<T extends Types.TSchema>(schema: T, references?: Types.TSchema[]): TypeCheck<T>;
 }

package/compiler/compiler.js

@@ -207,7 +207,8 @@ 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');
-        yield `${value}.every(value => ${expression})`;
+        const parameter = CreateParameter('value', 'any');
+        yield `${value}.every((${parameter}) => ${expression})`;
     }
     function* BigInt(schema, references, value) {
         yield `(typeof ${value} === 'bigint')`;
@@ -223,7 +224,7 @@ var TypeCompiler;
             yield `${value} <= BigInt(${schema.maximum})`;
     }
     function* Boolean(schema, references, value) {
-        yield `typeof ${value} === 'boolean'`;
+        yield `(typeof ${value} === 'boolean')`;
     }
     function* Constructor(schema, references, value) {
         yield* Visit(schema.returns, references, `${value}.prototype`);
@@ -240,7 +241,7 @@ var TypeCompiler;
             yield `${value}.getTime() <= ${schema.maximumTimestamp}`;
     }
     function* Function(schema, references, value) {
-        yield `typeof ${value} === 'function'`;
+        yield `(typeof ${value} === 'function')`;
     }
     function* Integer(schema, references, value) {
         yield `(typeof ${value} === 'number' && Number.isInteger(${value}))`;
@@ -260,23 +261,23 @@ var TypeCompiler;
         if (schema.unevaluatedProperties === false) {
             const keyCheck = PushLocal(`${new RegExp(Types.KeyResolver.ResolvePattern(schema))};`);
             const check2 = `Object.getOwnPropertyNames(${value}).every(key => ${keyCheck}.test(key))`;
-            yield `${check1} && ${check2}`;
+            yield `(${check1} && ${check2})`;
         }
         else if (Types.TypeGuard.TSchema(schema.unevaluatedProperties)) {
             const keyCheck = PushLocal(`${new RegExp(Types.KeyResolver.ResolvePattern(schema))};`);
             const check2 = `Object.getOwnPropertyNames(${value}).every(key => ${keyCheck}.test(key) || ${CreateExpression(schema.unevaluatedProperties, references, `${value}[key]`)})`;
-            yield `${check1} && ${check2}`;
+            yield `(${check1} && ${check2})`;
         }
         else {
-            yield `${check1}`;
+            yield `(${check1})`;
         }
     }
     function* Literal(schema, references, value) {
         if (typeof schema.const === 'number' || typeof schema.const === 'boolean') {
-            yield `${value} === ${schema.const}`;
+            yield `(${value} === ${schema.const})`;
         }
         else {
-            yield `${value} === '${schema.const}'`;
+            yield `(${value} === '${schema.const}')`;
         }
     }
     function* Never(schema, references, value) {
@@ -288,7 +289,7 @@ var TypeCompiler;
         yield `!${left} && ${right}`;
     }
     function* Null(schema, references, value) {
-        yield `${value} === null`;
+        yield `(${value} === null)`;
     }
     function* Number(schema, references, value) {
         yield IsNumberCheck(value);
@@ -362,7 +363,7 @@ var TypeCompiler;
         // 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 function for subsequent passes.
-        if (state_local_function_names.has(schema.$ref))
+        if (state.functions.has(schema.$ref))
             return yield `${CreateFunctionName(schema.$ref)}(${value})`;
         yield* Visit(target, references, value);
     }
@@ -423,8 +424,8 @@ var TypeCompiler;
         yield IsVoidCheck(value);
     }
     function* UserDefined(schema, references, value) {
-        const schema_key = `schema_key_${state_remote_custom_types.size}`;
-        state_remote_custom_types.set(schema_key, schema);
+        const schema_key = `schema_key_${state.customs.size}`;
+        state.customs.set(schema_key, schema);
         yield `custom('${schema[Types.Kind]}', '${schema_key}', ${value})`;
     }
     function* Visit(schema, references, value, root = false) {
@@ -439,8 +440,8 @@ var TypeCompiler;
         // by refactoring the logic below. Consider for review.
         if (IsString(schema.$id)) {
             const name = CreateFunctionName(schema.$id);
-            if (!state_local_function_names.has(schema.$id)) {
-                state_local_function_names.add(schema.$id);
+            if (!state.functions.has(schema.$id)) {
+                state.functions.add(schema.$id);
                 const body = CreateFunction(name, schema, references, 'value');
                 PushFunction(body);
             }
@@ -513,49 +514,63 @@ var TypeCompiler;
     // -------------------------------------------------------------------
     // Compiler State
     // -------------------------------------------------------------------
-    const state_local_variables = new Set(); // local variables and functions
-    const state_local_function_names = new Set(); // local function names used call ref validators
-    const state_remote_custom_types = new Map(); // remote custom types used during compilation
-    function ResetCompiler() {
-        state_local_variables.clear();
-        state_local_function_names.clear();
-        state_remote_custom_types.clear();
+    // prettier-ignore
+    const state = {
+        language: 'javascript',
+        variables: new Set(),
+        functions: new Set(),
+        customs: new Map(), // custom type data
+    };
+    function CreateFunctionName($id) {
+        return `check_${Identifier.Encode($id)}`;
     }
     function CreateExpression(schema, references, value) {
         return `(${[...Visit(schema, references, value)].join(' && ')})`;
     }
-    function CreateFunctionName($id) {
-        return `check_${Identifier.Encode($id)}`;
+    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');
-        return `function ${name}(value) {\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_local_variables.add(functionBody);
+        state.variables.add(functionBody);
     }
     function PushLocal(expression) {
-        const local = `local_${state_local_variables.size}`;
-        state_local_variables.add(`const ${local} = ${expression}`);
+        const local = `local_${state.variables.size}`;
+        state.variables.add(`const ${local} = ${expression}`);
         return local;
     }
     function GetLocals() {
-        return [...state_local_variables.values()];
+        return [...state.variables.values()];
     }
     // -------------------------------------------------------------------
     // Compile
     // -------------------------------------------------------------------
     function Build(schema, references) {
-        ResetCompiler();
         const check = CreateFunction('check', schema, references, 'value'); // interior visit
         const locals = GetLocals();
+        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(value) {\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. */
-    function Code(schema, references = []) {
+    function Code(schema, references = [], options = { language: 'javascript' }) {
+        // compiler-reset
+        state.language = options.language;
+        state.variables.clear();
+        state.functions.clear();
+        state.customs.clear();
         if (!Types.TypeGuard.TSchema(schema))
             throw new TypeCompilerTypeGuardError(schema);
         for (const schema of references)
@@ -566,13 +581,13 @@ var TypeCompiler;
     TypeCompiler.Code = Code;
     /** Compiles the given type for runtime type checking. This compiler only accepts known TypeBox types non-inclusive of unsafe types. */
     function Compile(schema, references = []) {
-        const code = Code(schema, references);
-        const custom_schemas = new Map(state_remote_custom_types);
+        const code = Code(schema, references, { language: 'javascript' });
+        const customs = new Map(state.customs);
         const compiledFunction = globalThis.Function('custom', 'format', 'hash', code);
         const checkFunction = compiledFunction((kind, schema_key, value) => {
-            if (!Types.TypeRegistry.Has(kind) || !custom_schemas.has(schema_key))
+            if (!Types.TypeRegistry.Has(kind) || !customs.has(schema_key))
                 return false;
-            const schema = custom_schemas.get(schema_key);
+            const schema = customs.get(schema_key);
             const func = Types.TypeRegistry.Get(kind);
             return func(schema, value);
         }, (format, value) => {

package/package.json

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