@sinclair/typebox 0.28.15 → 0.28.17

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

@@ -199,14 +199,16 @@ var TypeCompiler;
         yield 'true';
     }
     function* Array(schema, references, value) {
-        const expression = CreateExpression(schema.items, references, 'value');
+        yield `Array.isArray(${value})`;
         if (IsNumber(schema.minItems))
             yield `${value}.length >= ${schema.minItems}`;
         if (IsNumber(schema.maxItems))
             yield `${value}.length <= ${schema.maxItems}`;
         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 })())`;
-        yield `Array.isArray(${value}) && ${value}.every(value => ${expression})`;
+        const expression = CreateExpression(schema.items, references, 'value');
+        const parameter = CreateParameter('value');
+        yield `${value}.every((${parameter}) => ${expression})`;
     }
     function* BigInt(schema, references, value) {
         yield `(typeof ${value} === 'bigint')`;
@@ -222,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`);
@@ -239,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}))`;
@@ -259,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) {
@@ -287,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);
@@ -358,10 +360,10 @@ var TypeCompiler;
         if (index === -1)
             throw new TypeCompilerDereferenceError(schema);
         const target = references[index];
-        // 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. Consider for refactor.
-        if (state_local_function_names.has(schema.$ref))
+        // 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.functions.has(schema.$ref))
             return yield `${CreateFunctionName(schema.$ref)}(${value})`;
         yield* Visit(target, references, value);
     }
@@ -392,7 +394,7 @@ var TypeCompiler;
         yield `${func}(${value})`;
     }
     function* Tuple(schema, references, value) {
-        yield `(Array.isArray(${value}))`;
+        yield `Array.isArray(${value})`;
         if (schema.items === undefined)
             return yield `${value}.length === 0`;
         yield `(${value}.length === ${schema.maxItems})`;
@@ -422,21 +424,24 @@ 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) {
         const references_ = IsString(schema.$id) ? [...references, schema] : references;
         const schema_ = schema;
-        // Rule: Types with identifiers are hoisted into their own functions. The following will generate a function for the schema
-        // and yield the call to that function. This call is only made if NOT the root type which allows the generated function to
-        // yield its expression. The root argument is only true when making calls via CreateFunction(). Note there is potential to
-        // omit the root argument and conditional by refactoring the logic below. Consider for review.
+        // Rule: Types with identifiers are hoisted into their own functions.
+        // The following will generate a function for the schema and yield the
+        // call to that function. This call is only made if NOT the root type
+        // which allows the generated function to yield its expression. The
+        // root argument is only true when making calls via CreateFunction().
+        // Note there is potential to omit the root argument and conditional
+        // 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);
             }
@@ -509,49 +514,58 @@ 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 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' : '';
+        return `${name}${annotation}`;
+    }
     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');
+        return `function ${name}(${parameter}) {\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');
         // 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}) {\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)
@@ -562,13 +576,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.15",
+  "version": "0.28.17",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",

package/readme.md

@@ -483,7 +483,7 @@ The following table lists the Standard TypeBox types. These types are fully comp
 │ ])                             │                             │   ],                           │
 │ const T = Type.Tuple([         │                             │   additionalItems: false,      │
 |   ...Type.Rest(A),             │                             │   minItems: 4,                 │
-|   ...Type.Test(B)              │                             │   maxItems: 4                  │
+|   ...Type.Rest(B)              │                             │   maxItems: 4                  │
 │ ])                             │                             │ }                              │
 │                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
@@ -870,7 +870,7 @@ const T = Type.Object({                              // const T = {
   z: Type.Boolean()                                  //   properties: {
 })                                                   //     x: { type: 'number' },
                                                      //     y: { type: 'string' },
-                                                     //     z: { type: 'string' },
+                                                     //     z: { type: 'string' }
                                                      //   }
                                                      // }
 
@@ -896,7 +896,7 @@ const C = Type.Index(T, Type.KeyOf(T))               // const C = {
 
 ### Rest Types
 
-Rest parameters are supported with `Type.Rest`. This function is used to extract interior type elements from tuples which enables them to compose with the JavaScript spread operator `...`. This type can be used for tuple concatination as well as for variadic functions.
+Rest parameters are supported with `Type.Rest`. This function is used to extract interior type elements from tuples which enables them to compose with the JavaScript spread operator `...`. This type can be used for tuple concatenation as well as for variadic functions.
 
 ```typescript
 // TypeScript
@@ -908,14 +908,14 @@ type C = [...T, number]                              // type C = [number, number
 type F = (...param: C) => void                       // type F = (
                                                      //   param0: number,
                                                      //   param1: number,
-                                                     //   param2: number,
+                                                     //   param2: number
                                                      // ) => void
 
 // TypeBox
 
 const T = Type.Tuple([                               // const T: TTuple<[
   Type.Number(),                                     //   TNumber,
-  Type.Number()                                      //   TNumber,
+  Type.Number()                                      //   TNumber
 ])                                                   // ]>
 
 const C = Type.Tuple([                               // const C: TTuple<[
@@ -1335,7 +1335,7 @@ console.log(C.Code())                                // return function check(va
 
 ## TypeSystem
 
-The TypeBox TypeSystem module provides functionality to define types above and beyond the Standard and Extended type sets as well as control various assertion polices. Configurations made to the TypeSystem module are observed by both `TypeCompiler` and `Value` modules.
+The TypeBox TypeSystem module provides functionality to define types above and beyond the Standard and Extended type sets as well as control various assertion policies. Configurations made to the TypeSystem module are observed by both `TypeCompiler` and `Value` modules.
 
 The TypeSystem module is provided as an optional import.