@sinclair/typebox 0.24.0 → 0.24.3

package/compiler/compiler.d.ts

@@ -1,11 +1,5 @@
 import * as Types from '../typebox';
-export declare type CheckFunction = (value: unknown) => CheckOk | CheckFail;
-export interface CheckOk {
-    ok: true;
-}
-export interface CheckFail {
-    ok: false;
-}
+export declare type CheckFunction = (value: unknown) => boolean;
 export declare class TypeCheckAssertError extends Error {
     readonly schema: Types.TSchema;
     readonly value: unknown;
@@ -14,18 +8,16 @@ export declare class TypeCheckAssertError extends Error {
 export declare class TypeCheck<T extends Types.TSchema> {
     private readonly schema;
     private readonly checkFunc;
-    constructor(schema: T, checkFunc: CheckFunction);
+    private readonly code;
+    constructor(schema: T, checkFunc: CheckFunction, code: string);
+    /** Returns the compiled validation code used to check this type. */
+    Code(): string;
     /** Returns true if the value is valid. */
     Check(value: unknown): value is Types.Static<T>;
     /** Asserts the given value and throws a TypeCheckAssertError if invalid. */
     Assert(value: unknown): void;
 }
 export declare namespace TypeCompiler {
-    interface Condition {
-        schema: Types.TSchema;
-        expr: string;
-        path: string;
-    }
-    /** Compiles a type into validation function */
+    /** 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, additional?: Types.TSchema[]): TypeCheck<T>;
 }

package/compiler/compiler.js

@@ -45,22 +45,23 @@ exports.TypeCheckAssertError = TypeCheckAssertError;
 class TypeCheck {
     schema;
     checkFunc;
-    constructor(schema, checkFunc) {
+    code;
+    constructor(schema, checkFunc, code) {
         this.schema = schema;
         this.checkFunc = checkFunc;
+        this.code = code;
+    }
+    /** Returns the compiled validation code used to check this type. */
+    Code() {
+        return this.code;
     }
     /** Returns true if the value is valid. */
     Check(value) {
-        const result = this.checkFunc(value);
-        return result.ok;
+        return this.checkFunc(value);
     }
     /** Asserts the given value and throws a TypeCheckAssertError if invalid. */
     Assert(value) {
-        // The return type for this function should be 'asserts value is Static<T>' but due
-        // to a limitation in TypeScript, this currently isn't possible. See issue below.
-        // https://github.com/microsoft/TypeScript/issues/36931
-        const result = this.checkFunc(value);
-        if (!result.ok)
+        if (!this.checkFunc(value))
             throw new TypeCheckAssertError(this.schema, value);
     }
 }
@@ -70,74 +71,68 @@ exports.TypeCheck = TypeCheck;
 // -------------------------------------------------------------------
 var TypeCompiler;
 (function (TypeCompiler) {
-    // -------------------------------------------------------------------
-    // Condition
-    // -------------------------------------------------------------------
-    function CreateCondition(schema, path, expr) {
-        return { schema, path, expr };
-    }
     // -------------------------------------------------------------------
     // Schemas
     // -------------------------------------------------------------------
     function* Any(schema, path) {
-        yield CreateCondition(schema, path, '(true)');
+        yield '(true)';
     }
     function* Array(schema, path) {
-        const expr = [...Visit(schema.items, `value`)].map((condition) => condition.expr).join(' && ');
-        yield CreateCondition(schema, path, `(Array.isArray(${path}) && ${path}.every(value => ${expr}))`);
+        const expr = [...Visit(schema.items, `value`)].map((condition) => condition).join(' && ');
+        yield `(Array.isArray(${path}) && ${path}.every(value => ${expr}))`;
     }
     function* Boolean(schema, path) {
-        yield CreateCondition(schema, path, `(typeof ${path} === 'boolean')`);
+        yield `(typeof ${path} === 'boolean')`;
     }
     function* Constructor(schema, path) {
         yield* Visit(schema.yields, path);
     }
     function* Function(schema, path) {
-        yield CreateCondition(schema, path, `(typeof ${path} === 'function')`);
+        yield `(typeof ${path} === 'function')`;
     }
     function* Integer(schema, path) {
-        yield CreateCondition(schema, path, `(typeof ${path} === 'number' && Number.isInteger(${path}))`);
+        yield `(typeof ${path} === 'number' && Number.isInteger(${path}))`;
         if (schema.multipleOf)
-            yield CreateCondition(schema, path, `(${path} % ${schema.multipleOf} === 0)`);
+            yield `(${path} % ${schema.multipleOf} === 0)`;
         if (schema.exclusiveMinimum)
-            yield CreateCondition(schema, path, `(${path} < ${schema.exclusiveMinimum})`);
+            yield `(${path} < ${schema.exclusiveMinimum})`;
         if (schema.exclusiveMaximum)
-            yield CreateCondition(schema, path, `(${path} < ${schema.exclusiveMaximum})`);
+            yield `(${path} < ${schema.exclusiveMaximum})`;
         if (schema.minimum)
-            yield CreateCondition(schema, path, `(${path} >= ${schema.minimum})`);
+            yield `(${path} >= ${schema.minimum})`;
         if (schema.maximum)
-            yield CreateCondition(schema, path, `(${path} <= ${schema.maximum})`);
+            yield `(${path} <= ${schema.maximum})`;
     }
     function* Literal(schema, path) {
         if (typeof schema.const === 'string') {
-            yield CreateCondition(schema, path, `(${path} === '${schema.const}')`);
+            yield `(${path} === '${schema.const}')`;
         }
         else {
-            yield CreateCondition(schema, path, `(${path} === ${schema.const})`);
+            yield `(${path} === ${schema.const})`;
         }
     }
     function* Null(schema, path) {
-        yield CreateCondition(schema, path, `(${path} === null)`);
+        yield `(${path} === null)`;
     }
     function* Number(schema, path) {
-        yield CreateCondition(schema, path, `(typeof ${path} === 'number')`);
+        yield `(typeof ${path} === 'number')`;
         if (schema.multipleOf)
-            yield CreateCondition(schema, path, `(${path} % ${schema.multipleOf} === 0)`);
+            yield `(${path} % ${schema.multipleOf} === 0)`;
         if (schema.exclusiveMinimum)
-            yield CreateCondition(schema, path, `(${path} < ${schema.exclusiveMinimum})`);
+            yield `(${path} < ${schema.exclusiveMinimum})`;
         if (schema.exclusiveMaximum)
-            yield CreateCondition(schema, path, `(${path} < ${schema.exclusiveMaximum})`);
+            yield `(${path} < ${schema.exclusiveMaximum})`;
         if (schema.minimum)
-            yield CreateCondition(schema, path, `(${path} >= ${schema.minimum})`);
+            yield `(${path} >= ${schema.minimum})`;
         if (schema.maximum)
-            yield CreateCondition(schema, path, `(${path} <= ${schema.maximum})`);
+            yield `(${path} <= ${schema.maximum})`;
     }
     function* Object(schema, path) {
-        yield CreateCondition(schema, path, `(typeof ${path} === 'object' && ${path} !== null && !Array.isArray(${path}))`);
+        yield `(typeof ${path} === 'object' && ${path} !== null && !Array.isArray(${path}))`;
         if (schema.minProperties !== undefined)
-            yield CreateCondition(schema, path, `(Object.keys(${path}).length >= ${schema.minProperties})`);
+            yield `(Object.keys(${path}).length >= ${schema.minProperties})`;
         if (schema.maxProperties !== undefined)
-            yield CreateCondition(schema, path, `(Object.keys(${path}).length <= ${schema.maxProperties})`);
+            yield `(Object.keys(${path}).length <= ${schema.maxProperties})`;
         const propertyKeys = globalThis.Object.keys(schema.properties);
         if (schema.additionalProperties === false) {
             // optimization: If the property key length matches the required keys length
@@ -145,11 +140,11 @@ var TypeCompiler;
             // of the property key length. This is because exhaustive testing for values
             // will occur in subsequent property tests.
             if (schema.required && schema.required.length === propertyKeys.length) {
-                yield CreateCondition(schema, path, `(Object.keys(${path}).length === ${propertyKeys.length})`);
+                yield `(Object.keys(${path}).length === ${propertyKeys.length})`;
             }
             else {
                 const keys = `[${propertyKeys.map((key) => `'${key}'`).join(', ')}]`;
-                yield CreateCondition(schema, path, `(Object.keys(${path}).every(key => ${keys}.includes(key)))`);
+                yield `(Object.keys(${path}).every(key => ${keys}.includes(key)))`;
             }
         }
         for (const propertyKey of propertyKeys) {
@@ -158,21 +153,21 @@ var TypeCompiler;
                 yield* Visit(propertySchema, `${path}.${propertyKey}`);
             }
             else {
-                const expr = [...Visit(propertySchema, `${path}.${propertyKey}`)].map((condition) => condition.expr).join(' && ');
-                yield CreateCondition(schema, `${path}.${propertyKey}`, `(${path}.${propertyKey} === undefined ? true : (${expr}))`);
+                const expr = [...Visit(propertySchema, `${path}.${propertyKey}`)].map((condition) => condition).join(' && ');
+                yield `(${path}.${propertyKey} === undefined ? true : (${expr}))`;
             }
         }
     }
     function* Promise(schema, path) {
-        yield CreateCondition(schema, path, `(typeof value === 'object' && typeof ${path}.then === 'function')`);
+        yield `(typeof value === 'object' && typeof ${path}.then === 'function')`;
     }
     function* Record(schema, path) {
-        yield CreateCondition(schema, path, `(typeof ${path} === 'object' && ${path} !== null && !Array.isArray(${path}))`);
+        yield `(typeof ${path} === 'object' && ${path} !== null && !Array.isArray(${path}))`;
         const [keyPattern, valueSchema] = globalThis.Object.entries(schema.patternProperties)[0];
         const local = PushLocal(`const local = new RegExp(/${keyPattern}/)`);
-        yield CreateCondition(schema, path, `(Object.keys(${path}).every(key => ${local}.test(key)))`);
-        const expr = [...Visit(valueSchema, 'value')].map((cond) => cond.expr).join(' && ');
-        yield CreateCondition(schema, path, `(Object.values(${path}).every(value => ${expr}))`);
+        yield `(Object.keys(${path}).every(key => ${local}.test(key)))`;
+        const expr = [...Visit(valueSchema, 'value')].map((condition) => condition).join(' && ');
+        yield `(Object.values(${path}).every(value => ${expr}))`;
     }
     function* Ref(schema, path) {
         // reference: referenced schemas can originate from either additional
@@ -187,48 +182,48 @@ var TypeCompiler;
             PushLocal(body);
         }
         const func = CreateFunctionName(schema.$ref);
-        yield CreateCondition(schema, path, `(${func}(${path}).ok)`);
+        yield `(${func}(${path}))`;
     }
     function* Self(schema, path) {
         const func = CreateFunctionName(schema.$ref);
-        yield CreateCondition(schema, path, `(${func}(${path}).ok)`);
+        yield `(${func}(${path}))`;
     }
     function* String(schema, path) {
-        yield CreateCondition(schema, path, `(typeof ${path} === 'string')`);
+        yield `(typeof ${path} === 'string')`;
         if (schema.pattern !== undefined) {
             const local = PushLocal(`const local = new RegExp('${schema.pattern}');`);
-            yield CreateCondition(schema, path, `(${local}.test(${path}))`);
+            yield `(${local}.test(${path}))`;
         }
     }
     function* Tuple(schema, path) {
-        yield CreateCondition(schema, path, `(Array.isArray(${path}))`);
+        yield `(Array.isArray(${path}))`;
         if (schema.items === undefined)
-            return yield CreateCondition(schema, path, `(${path}.length === 0)`);
-        yield CreateCondition(schema, path, `(${path}.length === ${schema.maxItems})`);
+            return yield `(${path}.length === 0)`;
+        yield `(${path}.length === ${schema.maxItems})`;
         for (let i = 0; i < schema.items.length; i++) {
-            const expr = [...Visit(schema.items[i], `${path}[${i}]`)].map((condition) => condition.expr).join(' && ');
-            yield CreateCondition(schema, path, `(${expr})`);
+            const expr = [...Visit(schema.items[i], `${path}[${i}]`)].map((condition) => condition).join(' && ');
+            yield `(${expr})`;
         }
     }
     function* Undefined(schema, path) {
-        yield CreateCondition(schema, path, `${path} === undefined`);
+        yield `${path} === undefined`;
     }
     function* Union(schema, path) {
-        const exprs = schema.anyOf.map((schema) => [...Visit(schema, path)].map((cond) => cond.expr).join(' && '));
-        yield CreateCondition(schema, path, `(${exprs.join(' || ')})`);
+        const exprs = schema.anyOf.map((schema) => [...Visit(schema, path)].map((condition) => condition).join(' && '));
+        yield `(${exprs.join(' || ')})`;
     }
     function* Uint8Array(schema, path) {
-        yield CreateCondition(schema, path, `(${path} instanceof Uint8Array)`);
+        yield `(${path} instanceof Uint8Array)`;
         if (schema.maxByteLength)
-            yield CreateCondition(schema, path, `(${path}.length <= ${schema.maxByteLength})`);
+            yield `(${path}.length <= ${schema.maxByteLength})`;
         if (schema.minByteLength)
-            yield CreateCondition(schema, path, `(${path}.length >= ${schema.minByteLength})`);
+            yield `(${path}.length >= ${schema.minByteLength})`;
     }
     function* Unknown(schema, path) {
-        yield CreateCondition(schema, path, '(true)');
+        yield '(true)';
     }
     function* Void(schema, path) {
-        yield CreateCondition(schema, path, `(${path} === null)`);
+        yield `(${path} === null)`;
     }
     function* Visit(schema, path) {
         // reference: referenced schemas can originate from either additional
@@ -240,7 +235,7 @@ var TypeCompiler;
             const name = CreateFunctionName(schema.$id);
             const body = CreateFunction(name, conditions);
             PushLocal(body);
-            yield CreateCondition(schema, path, `(${name}(${path}).ok)`);
+            yield `(${name}(${path}))`;
             return;
         }
         const anySchema = schema;
@@ -326,11 +321,11 @@ var TypeCompiler;
         return `check_${$id.replace(/-/g, '_')}`;
     }
     function CreateFunction(name, conditions) {
-        const statements = conditions.map((condition, index) => `  if(!${condition.expr}) { return { ok: false } }`);
-        return `function ${name}(value) {\n${statements.join('\n')}\n  return { ok: true }\n}`;
+        const expression = conditions.map((condition) => `    ${condition}`).join(' &&\n');
+        return `function ${name}(value) {\n  return (\n${expression}\n )\n}`;
     }
     // -------------------------------------------------------------------
-    // Compiler
+    // Compile
     // -------------------------------------------------------------------
     function Build(schema, additional = []) {
         ClearLocals();
@@ -339,11 +334,11 @@ var TypeCompiler;
         const locals = GetLocals();
         return `${locals.join('\n')}\nreturn ${CreateFunction('check', conditions)}`;
     }
-    /** Compiles a type into validation function */
+    /** Compiles the given type for runtime type checking. This compiler only accepts known TypeBox types non-inclusive of unsafe types. */
     function Compile(schema, additional = []) {
         const code = Build(schema, additional);
         const func = globalThis.Function(code);
-        return new TypeCheck(schema, func());
+        return new TypeCheck(schema, func(), code);
     }
     TypeCompiler.Compile = Compile;
 })(TypeCompiler = exports.TypeCompiler || (exports.TypeCompiler = {}));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.24.0",
+  "version": "0.24.3",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "json-schema",

package/typebox.d.ts

@@ -84,15 +84,6 @@ export interface TEnum<T extends Record<string, string | number> = Record<string
     static: T[keyof T];
     anyOf: TLiteral<string | number>[];
 }
-export interface TExclude<T extends TUnion, U extends TUnion> extends TUnion {
-    [Kind]: 'Union';
-    static: Exclude<Static<T, this['params']>, Static<U, this['params']>>;
-}
-export interface TExtract<T extends TSchema, U extends TUnion> extends TUnion {
-    [Kind]: 'Union';
-    static: Extract<Static<T, this['params']>, Static<U, this['params']>>;
-}
-export declare type TExtends<T extends TSchema, U extends TSchema, X extends TSchema, Y extends TSchema> = T extends TAny ? (U extends TUnknown ? X : U extends TAny ? X : TUnion<[X, Y]>) : T extends U ? X : Y;
 export declare type TFunctionParameters<T extends readonly TSchema[], P extends unknown[]> = [...{
     [K in keyof T]: T[K] extends TSchema ? Static<T[K], P> : never;
 }];
@@ -275,8 +266,11 @@ export interface TUnknown extends TSchema {
     [Kind]: 'Unknown';
     static: unknown;
 }
+export interface UnsafeOptions extends SchemaOptions {
+    [Kind]?: string;
+}
 export interface TUnsafe<T> extends TSchema {
-    [Kind]: 'Unknown';
+    [Kind]: string;
     static: T;
 }
 export interface TVoid extends TSchema {
@@ -356,7 +350,7 @@ export declare class TypeBuilder {
     /** Creates an unknown type */
     Unknown(options?: SchemaOptions): TUnknown;
     /** Creates a user defined schema that infers as type T  */
-    Unsafe<T>(options?: SchemaOptions): TUnsafe<T>;
+    Unsafe<T>(options?: UnsafeOptions): TUnsafe<T>;
     /** Creates a void type */
     Void(options?: SchemaOptions): TVoid;
     /** Use this function to return TSchema with static and params omitted */

package/typebox.js

@@ -293,7 +293,7 @@ class TypeBuilder {
     }
     /** Creates a user defined schema that infers as type T  */
     Unsafe(options = {}) {
-        return this.Create({ ...options, [exports.Kind]: 'Unknown' });
+        return this.Create({ ...options, [exports.Kind]: options[exports.Kind] || 'Unsafe' });
     }
     /** Creates a void type */
     Void(options = {}) {