@sinclair/typebox 0.24.1 → 0.24.4

package/compiler/compiler.d.ts

@@ -1,25 +1,20 @@
+import { TypeError } from './errors';
 import * as Types from '../typebox';
 export declare type CheckFunction = (value: unknown) => boolean;
-export declare class TypeCheckAssertError extends Error {
-    readonly schema: Types.TSchema;
-    readonly value: unknown;
-    constructor(schema: Types.TSchema, value: unknown);
-}
 export declare class TypeCheck<T extends Types.TSchema> {
     private readonly schema;
+    private readonly additional;
     private readonly checkFunc;
-    constructor(schema: T, checkFunc: CheckFunction);
-    /** Returns true if the value is valid. */
+    private readonly code;
+    constructor(schema: T, additional: Types.TSchema[], checkFunc: CheckFunction, code: string);
+    /** Returns the generated validation code used to validate this type */
+    Code(): string;
+    /** Returns an iterator for each type error found in this value */
+    Errors(value: unknown): Generator<TypeError>;
+    /** Returns true if the value matches the given type. */
     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

@@ -27,40 +27,35 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TypeCompiler = exports.TypeCheck = exports.TypeCheckAssertError = void 0;
+exports.TypeCompiler = exports.TypeCheck = void 0;
+const errors_1 = require("./errors");
 const Types = require("../typebox");
 // -------------------------------------------------------------------
 // TypeCheck
 // -------------------------------------------------------------------
-class TypeCheckAssertError extends Error {
-    schema;
-    value;
-    constructor(schema, value) {
-        super(`TypeCheckAssertError`);
-        this.schema = Types.Type.Strict(schema);
-        this.value = value;
-    }
-}
-exports.TypeCheckAssertError = TypeCheckAssertError;
 class TypeCheck {
     schema;
+    additional;
     checkFunc;
-    constructor(schema, checkFunc) {
+    code;
+    constructor(schema, additional, checkFunc, code) {
         this.schema = schema;
+        this.additional = additional;
         this.checkFunc = checkFunc;
+        this.code = code;
+    }
+    /** Returns the generated validation code used to validate this type */
+    Code() {
+        return this.code;
+    }
+    /** Returns an iterator for each type error found in this value */
+    Errors(value) {
+        return errors_1.TypeErrors.Errors(this.schema, this.additional, value);
     }
-    /** Returns true if the value is valid. */
+    /** Returns true if the value matches the given type. */
     Check(value) {
         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
-        if (!this.checkFunc(value))
-            throw new TypeCheckAssertError(this.schema, value);
-    }
 }
 exports.TypeCheck = TypeCheck;
 // -------------------------------------------------------------------
@@ -68,74 +63,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
@@ -143,11 +132,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) {
@@ -156,21 +145,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
@@ -185,48 +174,48 @@ var TypeCompiler;
             PushLocal(body);
         }
         const func = CreateFunctionName(schema.$ref);
-        yield CreateCondition(schema, path, `(${func}(${path}))`);
+        yield `(${func}(${path}))`;
     }
     function* Self(schema, path) {
         const func = CreateFunctionName(schema.$ref);
-        yield CreateCondition(schema, path, `(${func}(${path}))`);
+        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
@@ -238,7 +227,7 @@ var TypeCompiler;
             const name = CreateFunctionName(schema.$id);
             const body = CreateFunction(name, conditions);
             PushLocal(body);
-            yield CreateCondition(schema, path, `(${name}(${path}))`);
+            yield `(${name}(${path}))`;
             return;
         }
         const anySchema = schema;
@@ -324,11 +313,11 @@ var TypeCompiler;
         return `check_${$id.replace(/-/g, '_')}`;
     }
     function CreateFunction(name, conditions) {
-        const statements = conditions.map((condition, index) => `  if(!${condition.expr}) { return false }`);
-        return `function ${name}(value) {\n${statements.join('\n')}\n  return 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();
@@ -337,11 +326,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, additional, func(), code);
     }
     TypeCompiler.Compile = Compile;
 })(TypeCompiler = exports.TypeCompiler || (exports.TypeCompiler = {}));

package/compiler/errors.d.ts

@@ -0,0 +1,10 @@
+import * as Types from '../typebox';
+export interface TypeError {
+    schema: Types.TSchema;
+    path: string;
+    value: unknown;
+    message: string;
+}
+export declare namespace TypeErrors {
+    function Errors<T extends Types.TSchema>(schema: T, additional: Types.TSchema[], value: any): Generator<TypeError>;
+}

package/compiler/errors.js

@@ -0,0 +1,311 @@
+"use strict";
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/compiler
+
+The MIT License (MIT)
+
+Copyright (c) 2022 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypeErrors = void 0;
+const Types = require("../typebox");
+var TypeErrors;
+(function (TypeErrors) {
+    function* Any(schema, path, value) { }
+    function* Array(schema, path, value) {
+        if (!globalThis.Array.isArray(value)) {
+            return yield { schema, path, value, message: `Expected array` };
+        }
+        for (let i = 0; i < value.length; i++) {
+            yield* Visit(schema.items, `${path}/${i}`, value[i]);
+        }
+    }
+    function* Boolean(schema, path, value) {
+        if (!(typeof value === 'boolean')) {
+            return yield { schema, path, value, message: `Expected boolean` };
+        }
+    }
+    function* Constructor(schema, path, value) {
+        yield* Visit(schema.yields, path, value);
+    }
+    function* Function(schema, path, value) {
+        if (!(typeof value === 'function')) {
+            return yield { schema, path, value, message: `Expected function` };
+        }
+    }
+    function* Integer(schema, path, value) {
+        if (!(typeof value === 'number')) {
+            return yield { schema, path, value, message: `Expected number` };
+        }
+        if (!globalThis.Number.isInteger(value)) {
+            yield { schema, path, value, message: `Expected integer` };
+        }
+        if (schema.multipleOf && !(value % schema.multipleOf === 0)) {
+            yield { schema, path, value, message: `Expected number to be a multiple of ${schema.multipleOf}` };
+        }
+        if (schema.exclusiveMinimum && !(value > schema.exclusiveMinimum)) {
+            yield { schema, path, value, message: `Expected number to be greater than ${schema.exclusiveMinimum}` };
+        }
+        if (schema.exclusiveMaximum && !(value < schema.exclusiveMaximum)) {
+            yield { schema, path, value, message: `Expected number to be less than ${schema.exclusiveMaximum}` };
+        }
+        if (schema.minimum && !(value >= schema.minimum)) {
+            yield { schema, path, value, message: `Expected number to be greater or equal to ${schema.minimum}` };
+        }
+        if (schema.maximum && !(value <= schema.maximum)) {
+            yield { schema, path, value, message: `Expected number to be less or equal to ${schema.maximum}` };
+        }
+    }
+    function* Literal(schema, path, value) {
+        if (!(value === schema.const)) {
+            const error = typeof schema.const === 'string' ? `'${schema.const}'` : schema.const;
+            return yield { schema, path, value, message: `Expected ${error}` };
+        }
+    }
+    function* Null(schema, path, value) {
+        if (!(value === null)) {
+            return yield { schema, path, value, message: `Expected null` };
+        }
+    }
+    function* Number(schema, path, value) {
+        if (!(typeof value === 'number')) {
+            return yield { schema, path, value, message: `Expected number` };
+        }
+        if (schema.multipleOf && !(value % schema.multipleOf === 0)) {
+            yield { schema, path, value, message: `Expected number to be a multiple of ${schema.multipleOf}` };
+        }
+        if (schema.exclusiveMinimum && !(value > schema.exclusiveMinimum)) {
+            yield { schema, path, value, message: `Expected number to be greater than ${schema.exclusiveMinimum}` };
+        }
+        if (schema.exclusiveMaximum && !(value < schema.exclusiveMaximum)) {
+            yield { schema, path, value, message: `Expected number to be less than ${schema.exclusiveMaximum}` };
+        }
+        if (schema.minimum && !(value >= schema.minimum)) {
+            yield { schema, path, value, message: `Expected number to be greater or equal to ${schema.minimum}` };
+        }
+        if (schema.maximum && !(value <= schema.maximum)) {
+            yield { schema, path, value, message: `Expected number to be less or equal to ${schema.maximum}` };
+        }
+    }
+    function* Object(schema, path, value) {
+        if (!(typeof value === 'object' && value !== null && !globalThis.Array.isArray(value))) {
+            return yield { schema, path, value, message: `Expected object` };
+        }
+        if (schema.minProperties !== undefined && !(globalThis.Object.keys(value).length >= schema.minProperties)) {
+            yield { schema, path, value, message: `Expected object to have at least ${schema.minProperties} properties` };
+        }
+        if (schema.maxProperties !== undefined && !(globalThis.Object.keys(value).length <= schema.maxProperties)) {
+            yield { schema, path, value, message: `Expected object to have less than ${schema.minProperties} properties` };
+        }
+        const propertyKeys = globalThis.Object.keys(schema.properties);
+        if (schema.additionalProperties === false) {
+            // optimization: If the property key length matches the required keys length
+            // then we only need check that the values property key length matches that
+            // 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 && !(globalThis.Object.keys(value).length === propertyKeys.length)) {
+                yield { schema, path, value, message: 'Expected object must not have additional properties' };
+            }
+            else {
+                if (!globalThis.Object.keys(value).every((key) => propertyKeys.includes(key))) {
+                    yield { schema, path, value, message: 'Expected object must not have additional properties' };
+                }
+            }
+        }
+        for (const propertyKey of propertyKeys) {
+            const propertySchema = schema.properties[propertyKey];
+            if (schema.required && schema.required.includes(propertyKey)) {
+                yield* Visit(propertySchema, `${path}/${propertyKey}`, value[propertyKey]);
+            }
+            else {
+                if (value[propertyKey] !== undefined) {
+                    yield* Visit(propertySchema, `${path}/${propertyKey}`, value[propertyKey]);
+                }
+            }
+        }
+    }
+    function* Promise(schema, path, value) {
+        if (!(typeof value === 'object' && typeof value.then === 'function')) {
+            yield { schema, path, value, message: `Expected Promise` };
+        }
+    }
+    function* Record(schema, path, value) {
+        if (!(typeof value === 'object' && value !== null && !globalThis.Array.isArray(value))) {
+            return yield { schema, path, value, message: `Expected object` };
+        }
+        const [keyPattern, valueSchema] = globalThis.Object.entries(schema.patternProperties)[0];
+        const regex = new RegExp(keyPattern);
+        if (!globalThis.Object.keys(value).every((key) => regex.test(key))) {
+            const message = keyPattern === '^(0|[1-9][0-9]*)$' ? 'Expected all object property keys to be numeric' : 'Expected all object property keys to be strings';
+            return yield { schema, path, value, message };
+        }
+        for (const [propKey, propValue] of globalThis.Object.entries(value)) {
+            yield* Visit(valueSchema, `${path}/${propKey}`, propValue);
+        }
+    }
+    function* Ref(schema, path, value) {
+        if (!referenceMap.has(schema.$ref)) {
+            throw Error(`TypeErrors: Cannot locate referenced schema for $id '${schema.$id}'`);
+        }
+        const referencedSchema = referenceMap.get(schema.$ref);
+        yield* Visit(referencedSchema, path, value);
+    }
+    function* Self(schema, path, value) {
+        if (!referenceMap.has(schema.$ref)) {
+            throw Error(`TypeErrors: Cannot locate referenced schema for $id '${schema.$id}'`);
+        }
+        const referencedSchema = referenceMap.get(schema.$ref);
+        yield* Visit(referencedSchema, path, value);
+    }
+    function* String(schema, path, value) {
+        if (!(typeof value === 'string')) {
+            return yield { schema, path, value, message: 'Expected string' };
+        }
+        if (schema.pattern !== undefined) {
+            const regex = new RegExp(schema.pattern);
+            if (!regex.test(value)) {
+                yield { schema, path, value, message: `Expected string to match pattern ${schema.pattern}` };
+            }
+        }
+    }
+    function* Tuple(schema, path, value) {
+        if (!global.Array.isArray(value)) {
+            return yield { schema, path, value, message: 'Expected Array' };
+        }
+        if (schema.items === undefined && !(value.length === 0)) {
+            return yield { schema, path, value, message: 'Expected tuple to have 0 elements' };
+        }
+        if (!(value.length === schema.maxItems)) {
+            yield { schema, path, value, message: `Expected tuple to have ${schema.maxItems} elements` };
+        }
+        if (!schema.items) {
+            return;
+        }
+        for (let i = 0; i < schema.items.length; i++) {
+            yield* Visit(schema.items[i], `${path}/${i}`, value[i]);
+        }
+    }
+    function* Undefined(schema, path, value) {
+        if (!(value === undefined)) {
+            yield { schema, path, value, message: `Expected undefined` };
+        }
+    }
+    function* Union(schema, path, value) {
+        const errors = [];
+        for (const inner of schema.anyOf) {
+            const variantErrors = [...Visit(inner, path, value)];
+            if (variantErrors.length === 0)
+                return;
+            errors.push(...variantErrors);
+        }
+        for (const error of errors) {
+            yield error;
+        }
+        if (errors.length > 0) {
+            yield { schema, path, value, message: 'Expected value of union' };
+        }
+    }
+    function* Uint8Array(schema, path, value) {
+        if (!(value instanceof globalThis.Uint8Array)) {
+            return yield { schema, path, value, message: `Expected Uint8Array` };
+        }
+        if (schema.maxByteLength && !(value.length <= schema.maxByteLength)) {
+            yield { schema, path, value, message: `Expected Uint8Array to have a byte length less or equal to ${schema.maxByteLength}` };
+        }
+        if (schema.minByteLength && !(value.length >= schema.minByteLength)) {
+            yield { schema, path, value, message: `Expected Uint8Array to have a byte length greater or equal to ${schema.maxByteLength}` };
+        }
+    }
+    function* Unknown(schema, path, value) { }
+    function* Void(schema, path, value) {
+        if (!(value === null)) {
+            return yield { schema, path, value, message: `Expected null` };
+        }
+    }
+    function* Visit(schema, path, value) {
+        if (schema.$id !== undefined) {
+            referenceMap.set(schema.$id, schema);
+        }
+        const anySchema = schema;
+        switch (anySchema[Types.Kind]) {
+            case 'Any':
+                return yield* Any(anySchema, path, value);
+            case 'Array':
+                return yield* Array(anySchema, path, value);
+            case 'Boolean':
+                return yield* Boolean(anySchema, path, value);
+            case 'Constructor':
+                return yield* Constructor(anySchema, path, value);
+            case 'Function':
+                return yield* Function(anySchema, path, value);
+            case 'Integer':
+                return yield* Integer(anySchema, path, value);
+            case 'Literal':
+                return yield* Literal(anySchema, path, value);
+            case 'Null':
+                return yield* Null(anySchema, path, value);
+            case 'Number':
+                return yield* Number(anySchema, path, value);
+            case 'Object':
+                return yield* Object(anySchema, path, value);
+            case 'Promise':
+                return yield* Promise(anySchema, path, value);
+            case 'Record':
+                return yield* Record(anySchema, path, value);
+            case 'Ref':
+                return yield* Ref(anySchema, path, value);
+            case 'Self':
+                return yield* Self(anySchema, path, value);
+            case 'String':
+                return yield* String(anySchema, path, value);
+            case 'Tuple':
+                return yield* Tuple(anySchema, path, value);
+            case 'Undefined':
+                return yield* Undefined(anySchema, path, value);
+            case 'Union':
+                return yield* Union(anySchema, path, value);
+            case 'Uint8Array':
+                return yield* Uint8Array(anySchema, path, value);
+            case 'Unknown':
+                return yield* Unknown(anySchema, path, value);
+            case 'Void':
+                return yield* Void(anySchema, path, value);
+            default:
+                throw Error(`Unknown schema kind '${schema[Types.Kind]}'`);
+        }
+    }
+    const referenceMap = new Map();
+    function SetAdditional(additional = []) {
+        referenceMap.clear();
+        for (const schema of additional) {
+            if (!schema.$id)
+                throw Error('TypeErrors: Referenced additional schemas must have an $id');
+            referenceMap.set(schema.$id, schema);
+        }
+    }
+    function* Errors(schema, additional, value) {
+        SetAdditional(additional);
+        yield* Visit(schema, '', value);
+    }
+    TypeErrors.Errors = Errors;
+})(TypeErrors = exports.TypeErrors || (exports.TypeErrors = {}));

package/compiler/index.d.ts

@@ -1 +1,2 @@
 export * from './compiler';
+export * from './errors';

package/compiler/index.js

@@ -38,3 +38,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./compiler"), exports);
+__exportStar(require("./errors"), exports);

package/package.json

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

package/readme.md

@@ -727,7 +727,7 @@ Please refer to the official AJV [documentation](https://ajv.js.org/guide/gettin
 
 ### Compiler
 
-TypeBox provides an optional type compiler that can be used as a runtime type checker in absense of a JSON Schema validator. Please note that this compiler is not fully JSON Schema compliant and only permits compilation of TypeBox types only (where the schema representation is known in advance). The `TypeCompiler` contains a `TypeCompiler.Compile(T)` method that returns a `TypeCheck<T>` object that can be used to test the validity of a value.
+TypeBox include a specialized type compiler that can be used as a runtime type checker in absense of a JSON Schema validator. This compiler is optimized for high throughput validation scenarios and generally performs better than AJV for most structural checks. Please note that this compiler is not fully JSON Schema compliant and is limited to TypeBox types only. The `TypeCompiler` contains a `Compile(T)` function that returns a `TypeCheck<T>` object that can be used to test the validity of a value as well as obtain errors.
 
 ```typescript
 import { TypeCompiler } from '@sinclair/typebox/compiler'
@@ -747,6 +747,37 @@ const OK = C.Check({
   z: 3 
 }) // -> true
 ```
+Errors can be obtained by calling the `Errors(...)` function. This function returns an iterator that may contain zero or more errors for the given value. For performance, you should only call `Errors(V)` if the `Check(V)` function returns false. 
+```typescript
+const C = TypeCompiler.Compile(Type.Object({
+  x: Type.Number(),
+  y: Type.Number(),
+  z: Type.Number()
+}))
+
+const V = { } // invalid
+
+if(!C.Check(V)) {
+  for(const error of C.Errors(V)) {
+    console.log(error)
+  }
+}
+```
+To inspect the generated validation code created by the compiler. You can call the `Code()` function on the `TypeCheck<T>` object.
+
+```typescript
+const C = TypeCompiler.Compile(Type.String())
+
+console.log(C.Code())
+//
+// outputs:
+//
+// return function check(value) {
+//   return (
+//     (typeof value === 'string')
+//  )
+// }
+```
 
 <a name="Contribute"></a>
 

package/typebox.d.ts

@@ -266,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 {
@@ -347,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 = {}) {