@sinclair/typebox 0.24.22 → 0.24.23

package/compiler/compiler.d.ts

@@ -1,4 +1,4 @@
-import { ValueError } from '../value/errors';
+import { ValueError } from '../error/errors';
 import * as Types from '../typebox';
 export declare type CheckFunction = (value: unknown) => boolean;
 export declare class TypeCheck<T extends Types.TSchema> {

package/compiler/compiler.js

@@ -28,7 +28,7 @@ THE SOFTWARE.
 ---------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TypeCompiler = exports.TypeCheck = void 0;
-const errors_1 = require("../value/errors");
+const errors_1 = require("../error/errors");
 const property_1 = require("./property");
 const Types = require("../typebox");
 // -------------------------------------------------------------------

package/compiler/index.d.ts

@@ -1,2 +1,2 @@
-export type { ValueError } from '../value/errors';
+export { ValueError, ValueErrorType } from '../error/errors';
 export * from './compiler';

package/compiler/index.js

@@ -41,4 +41,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValueErrorType = void 0;
+var errors_1 = require("../error/errors");
+Object.defineProperty(exports, "ValueErrorType", { enumerable: true, get: function () { return errors_1.ValueErrorType; } });
 __exportStar(require("./compiler"), exports);

package/error/errors.d.ts

@@ -0,0 +1,52 @@
+import * as Types from '../typebox';
+export declare enum ValueErrorType {
+    Array = 0,
+    ArrayMinItems = 1,
+    ArrayMaxItems = 2,
+    ArrayUniqueItems = 3,
+    Boolean = 4,
+    Function = 5,
+    Integer = 6,
+    IntegerMultipleOf = 7,
+    IntegerExclusiveMinimum = 8,
+    IntegerExclusiveMaximum = 9,
+    IntegerMinimum = 10,
+    IntegerMaximum = 11,
+    Literal = 12,
+    Null = 13,
+    Number = 14,
+    NumberMultipleOf = 15,
+    NumberExclusiveMinimum = 16,
+    NumberExclusiveMaximum = 17,
+    NumberMinumum = 18,
+    NumberMaximum = 19,
+    Object = 20,
+    ObjectMinProperties = 21,
+    ObjectMaxProperties = 22,
+    ObjectAdditionalProperties = 23,
+    Promise = 24,
+    RecordKeyNumeric = 25,
+    RecordKeyString = 26,
+    String = 27,
+    StringMinLength = 28,
+    StringMaxLength = 29,
+    StringPattern = 30,
+    TupleZeroLength = 31,
+    TupleLength = 32,
+    Undefined = 33,
+    Union = 34,
+    Uint8Array = 35,
+    Uint8ArrayMinByteLength = 36,
+    Uint8ArrayMaxByteLength = 37,
+    Void = 38
+}
+export interface ValueError {
+    type: ValueErrorType;
+    schema: Types.TSchema;
+    path: string;
+    value: unknown;
+    message: string;
+}
+export declare namespace ValueErrors {
+    function Errors<T extends Types.TSchema>(schema: T, references: Types.TSchema[], value: any): IterableIterator<ValueError>;
+}

package/{value → error}/errors.js

@@ -27,23 +27,71 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ValueErrors = void 0;
+exports.ValueErrors = exports.ValueErrorType = void 0;
 const Types = require("../typebox");
+// -------------------------------------------------------------------
+// ValueErrorType
+// -------------------------------------------------------------------
+var ValueErrorType;
+(function (ValueErrorType) {
+    ValueErrorType[ValueErrorType["Array"] = 0] = "Array";
+    ValueErrorType[ValueErrorType["ArrayMinItems"] = 1] = "ArrayMinItems";
+    ValueErrorType[ValueErrorType["ArrayMaxItems"] = 2] = "ArrayMaxItems";
+    ValueErrorType[ValueErrorType["ArrayUniqueItems"] = 3] = "ArrayUniqueItems";
+    ValueErrorType[ValueErrorType["Boolean"] = 4] = "Boolean";
+    ValueErrorType[ValueErrorType["Function"] = 5] = "Function";
+    ValueErrorType[ValueErrorType["Integer"] = 6] = "Integer";
+    ValueErrorType[ValueErrorType["IntegerMultipleOf"] = 7] = "IntegerMultipleOf";
+    ValueErrorType[ValueErrorType["IntegerExclusiveMinimum"] = 8] = "IntegerExclusiveMinimum";
+    ValueErrorType[ValueErrorType["IntegerExclusiveMaximum"] = 9] = "IntegerExclusiveMaximum";
+    ValueErrorType[ValueErrorType["IntegerMinimum"] = 10] = "IntegerMinimum";
+    ValueErrorType[ValueErrorType["IntegerMaximum"] = 11] = "IntegerMaximum";
+    ValueErrorType[ValueErrorType["Literal"] = 12] = "Literal";
+    ValueErrorType[ValueErrorType["Null"] = 13] = "Null";
+    ValueErrorType[ValueErrorType["Number"] = 14] = "Number";
+    ValueErrorType[ValueErrorType["NumberMultipleOf"] = 15] = "NumberMultipleOf";
+    ValueErrorType[ValueErrorType["NumberExclusiveMinimum"] = 16] = "NumberExclusiveMinimum";
+    ValueErrorType[ValueErrorType["NumberExclusiveMaximum"] = 17] = "NumberExclusiveMaximum";
+    ValueErrorType[ValueErrorType["NumberMinumum"] = 18] = "NumberMinumum";
+    ValueErrorType[ValueErrorType["NumberMaximum"] = 19] = "NumberMaximum";
+    ValueErrorType[ValueErrorType["Object"] = 20] = "Object";
+    ValueErrorType[ValueErrorType["ObjectMinProperties"] = 21] = "ObjectMinProperties";
+    ValueErrorType[ValueErrorType["ObjectMaxProperties"] = 22] = "ObjectMaxProperties";
+    ValueErrorType[ValueErrorType["ObjectAdditionalProperties"] = 23] = "ObjectAdditionalProperties";
+    ValueErrorType[ValueErrorType["Promise"] = 24] = "Promise";
+    ValueErrorType[ValueErrorType["RecordKeyNumeric"] = 25] = "RecordKeyNumeric";
+    ValueErrorType[ValueErrorType["RecordKeyString"] = 26] = "RecordKeyString";
+    ValueErrorType[ValueErrorType["String"] = 27] = "String";
+    ValueErrorType[ValueErrorType["StringMinLength"] = 28] = "StringMinLength";
+    ValueErrorType[ValueErrorType["StringMaxLength"] = 29] = "StringMaxLength";
+    ValueErrorType[ValueErrorType["StringPattern"] = 30] = "StringPattern";
+    ValueErrorType[ValueErrorType["TupleZeroLength"] = 31] = "TupleZeroLength";
+    ValueErrorType[ValueErrorType["TupleLength"] = 32] = "TupleLength";
+    ValueErrorType[ValueErrorType["Undefined"] = 33] = "Undefined";
+    ValueErrorType[ValueErrorType["Union"] = 34] = "Union";
+    ValueErrorType[ValueErrorType["Uint8Array"] = 35] = "Uint8Array";
+    ValueErrorType[ValueErrorType["Uint8ArrayMinByteLength"] = 36] = "Uint8ArrayMinByteLength";
+    ValueErrorType[ValueErrorType["Uint8ArrayMaxByteLength"] = 37] = "Uint8ArrayMaxByteLength";
+    ValueErrorType[ValueErrorType["Void"] = 38] = "Void";
+})(ValueErrorType = exports.ValueErrorType || (exports.ValueErrorType = {}));
+// -------------------------------------------------------------------
+// ValueErrors
+// -------------------------------------------------------------------
 var ValueErrors;
 (function (ValueErrors) {
     function* Any(schema, references, path, value) { }
     function* Array(schema, references, path, value) {
         if (!globalThis.Array.isArray(value)) {
-            return yield { schema, path, value, message: `Expected array` };
+            return yield { type: ValueErrorType.Array, schema, path, value, message: `Expected array` };
         }
         if (schema.minItems !== undefined && !(value.length >= schema.minItems)) {
-            yield { schema, path, value, message: `Expected array length to be greater or equal to ${schema.minItems}` };
+            yield { type: ValueErrorType.ArrayMinItems, schema, path, value, message: `Expected array length to be greater or equal to ${schema.minItems}` };
         }
         if (schema.maxItems !== undefined && !(value.length <= schema.maxItems)) {
-            yield { schema, path, value, message: `Expected array length to be less or equal to ${schema.maxItems}` };
+            yield { type: ValueErrorType.ArrayMinItems, schema, path, value, message: `Expected array length to be less or equal to ${schema.maxItems}` };
         }
         if (schema.uniqueItems === true && !(new Set(value).size === value.length)) {
-            yield { schema, path, value, message: `Expected array elements to be unique` };
+            yield { type: ValueErrorType.ArrayUniqueItems, schema, path, value, message: `Expected array elements to be unique` };
         }
         for (let i = 0; i < value.length; i++) {
             yield* Visit(schema.items, references, `${path}/${i}`, value[i]);
@@ -51,7 +99,7 @@ var ValueErrors;
     }
     function* Boolean(schema, references, path, value) {
         if (!(typeof value === 'boolean')) {
-            return yield { schema, path, value, message: `Expected boolean` };
+            return yield { type: ValueErrorType.Boolean, schema, path, value, message: `Expected boolean` };
         }
     }
     function* Constructor(schema, references, path, value) {
@@ -59,78 +107,78 @@ var ValueErrors;
     }
     function* Function(schema, references, path, value) {
         if (!(typeof value === 'function')) {
-            return yield { schema, path, value, message: `Expected function` };
+            return yield { type: ValueErrorType.Function, schema, path, value, message: `Expected function` };
         }
     }
     function* Integer(schema, references, path, value) {
         if (!(typeof value === 'number')) {
-            return yield { schema, path, value, message: `Expected number` };
+            return yield { type: ValueErrorType.Number, schema, path, value, message: `Expected number` };
         }
         if (!globalThis.Number.isInteger(value)) {
-            yield { schema, path, value, message: `Expected integer` };
+            yield { type: ValueErrorType.Integer, schema, path, value, message: `Expected integer` };
         }
         if (schema.multipleOf && !(value % schema.multipleOf === 0)) {
-            yield { schema, path, value, message: `Expected integer to be a multiple of ${schema.multipleOf}` };
+            yield { type: ValueErrorType.IntegerMultipleOf, schema, path, value, message: `Expected integer to be a multiple of ${schema.multipleOf}` };
         }
         if (schema.exclusiveMinimum && !(value > schema.exclusiveMinimum)) {
-            yield { schema, path, value, message: `Expected integer to be greater than ${schema.exclusiveMinimum}` };
+            yield { type: ValueErrorType.IntegerExclusiveMinimum, schema, path, value, message: `Expected integer to be greater than ${schema.exclusiveMinimum}` };
         }
         if (schema.exclusiveMaximum && !(value < schema.exclusiveMaximum)) {
-            yield { schema, path, value, message: `Expected integer to be less than ${schema.exclusiveMaximum}` };
+            yield { type: ValueErrorType.IntegerExclusiveMaximum, schema, path, value, message: `Expected integer to be less than ${schema.exclusiveMaximum}` };
         }
         if (schema.minimum && !(value >= schema.minimum)) {
-            yield { schema, path, value, message: `Expected integer to be greater or equal to ${schema.minimum}` };
+            yield { type: ValueErrorType.IntegerMinimum, schema, path, value, message: `Expected integer to be greater or equal to ${schema.minimum}` };
         }
         if (schema.maximum && !(value <= schema.maximum)) {
-            yield { schema, path, value, message: `Expected integer to be less or equal to ${schema.maximum}` };
+            yield { type: ValueErrorType.IntegerMaximum, schema, path, value, message: `Expected integer to be less or equal to ${schema.maximum}` };
         }
     }
     function* Literal(schema, references, path, value) {
         if (!(value === schema.const)) {
             const error = typeof schema.const === 'string' ? `'${schema.const}'` : schema.const;
-            return yield { schema, path, value, message: `Expected ${error}` };
+            return yield { type: ValueErrorType.Literal, schema, path, value, message: `Expected ${error}` };
         }
     }
     function* Null(schema, references, path, value) {
         if (!(value === null)) {
-            return yield { schema, path, value, message: `Expected null` };
+            return yield { type: ValueErrorType.Null, schema, path, value, message: `Expected null` };
         }
     }
     function* Number(schema, references, path, value) {
         if (!(typeof value === 'number')) {
-            return yield { schema, path, value, message: `Expected number` };
+            return yield { type: ValueErrorType.Number, 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}` };
+            yield { type: ValueErrorType.NumberMultipleOf, 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}` };
+            yield { type: ValueErrorType.NumberExclusiveMinimum, 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}` };
+            yield { type: ValueErrorType.NumberExclusiveMaximum, 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}` };
+            yield { type: ValueErrorType.NumberMaximum, 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}` };
+            yield { type: ValueErrorType.NumberMinumum, schema, path, value, message: `Expected number to be less or equal to ${schema.maximum}` };
         }
     }
     function* Object(schema, references, path, value) {
         if (!(typeof value === 'object' && value !== null && !globalThis.Array.isArray(value))) {
-            return yield { schema, path, value, message: `Expected object` };
+            return yield { type: ValueErrorType.Object, 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` };
+            yield { type: ValueErrorType.ObjectMinProperties, 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` };
+            yield { type: ValueErrorType.ObjectMaxProperties, schema, path, value, message: `Expected object to have less than ${schema.minProperties} properties` };
         }
         const propertyKeys = globalThis.Object.keys(schema.properties);
         if (schema.additionalProperties === false) {
             for (const propKey of globalThis.Object.keys(value)) {
                 if (!propertyKeys.includes(propKey)) {
-                    yield { schema, path: `${path}/${propKey}`, value: value[propKey], message: 'Unexpected property' };
+                    yield { type: ValueErrorType.ObjectAdditionalProperties, schema, path: `${path}/${propKey}`, value: value[propKey], message: 'Unexpected property' };
                 }
             }
         }
@@ -148,18 +196,20 @@ var ValueErrors;
     }
     function* Promise(schema, references, path, value) {
         if (!(typeof value === 'object' && typeof value.then === 'function')) {
-            yield { schema, path, value, message: `Expected Promise` };
+            yield { type: ValueErrorType.Promise, schema, path, value, message: `Expected Promise` };
         }
     }
     function* Record(schema, references, path, value) {
         if (!(typeof value === 'object' && value !== null && !globalThis.Array.isArray(value))) {
-            return yield { schema, path, value, message: `Expected object` };
+            return yield { type: ValueErrorType.Object, 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 };
+            const numeric = keyPattern === '^(0|[1-9][0-9]*)$';
+            const type = numeric ? ValueErrorType.RecordKeyNumeric : ValueErrorType.RecordKeyString;
+            const message = numeric ? 'Expected all object property keys to be numeric' : 'Expected all object property keys to be strings';
+            return yield { type, schema, path, value, message };
         }
         for (const [propKey, propValue] of globalThis.Object.entries(value)) {
             yield* Visit(valueSchema, references, `${path}/${propKey}`, propValue);
@@ -179,30 +229,30 @@ var ValueErrors;
     }
     function* String(schema, references, path, value) {
         if (!(typeof value === 'string')) {
-            return yield { schema, path, value, message: 'Expected string' };
+            return yield { type: ValueErrorType.String, schema, path, value, message: 'Expected string' };
         }
         if (schema.minLength !== undefined && !(value.length >= schema.minLength)) {
-            yield { schema, path, value, message: `Expected string length greater or equal to ${schema.minLength}` };
+            yield { type: ValueErrorType.StringMinLength, schema, path, value, message: `Expected string length greater or equal to ${schema.minLength}` };
         }
         if (schema.maxLength !== undefined && !(value.length <= schema.maxLength)) {
-            yield { schema, path, value, message: `Expected string length less or equal to ${schema.maxLength}` };
+            yield { type: ValueErrorType.StringMaxLength, schema, path, value, message: `Expected string length less or equal to ${schema.maxLength}` };
         }
         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}` };
+                yield { type: ValueErrorType.StringPattern, schema, path, value, message: `Expected string to match pattern ${schema.pattern}` };
             }
         }
     }
     function* Tuple(schema, references, path, value) {
         if (!globalThis.Array.isArray(value)) {
-            return yield { schema, path, value, message: 'Expected Array' };
+            return yield { type: ValueErrorType.Array, 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' };
+            return yield { type: ValueErrorType.TupleZeroLength, 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` };
+            yield { type: ValueErrorType.TupleLength, schema, path, value, message: `Expected tuple to have ${schema.maxItems} elements` };
         }
         if (!schema.items) {
             return;
@@ -213,7 +263,7 @@ var ValueErrors;
     }
     function* Undefined(schema, references, path, value) {
         if (!(value === undefined)) {
-            yield { schema, path, value, message: `Expected undefined` };
+            yield { type: ValueErrorType.Undefined, schema, path, value, message: `Expected undefined` };
         }
     }
     function* Union(schema, references, path, value) {
@@ -228,24 +278,24 @@ var ValueErrors;
             yield error;
         }
         if (errors.length > 0) {
-            yield { schema, path, value, message: 'Expected value of union' };
+            yield { type: ValueErrorType.Union, schema, path, value, message: 'Expected value of union' };
         }
     }
     function* Uint8Array(schema, references, path, value) {
         if (!(value instanceof globalThis.Uint8Array)) {
-            return yield { schema, path, value, message: `Expected Uint8Array` };
+            return yield { type: ValueErrorType.Uint8Array, 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}` };
+            yield { type: ValueErrorType.Uint8ArrayMaxByteLength, 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}` };
+            yield { type: ValueErrorType.Uint8ArrayMinByteLength, schema, path, value, message: `Expected Uint8Array to have a byte length greater or equal to ${schema.maxByteLength}` };
         }
     }
     function* Unknown(schema, references, path, value) { }
     function* Void(schema, references, path, value) {
         if (!(value === null)) {
-            return yield { schema, path, value, message: `Expected null` };
+            return yield { type: ValueErrorType.Void, schema, path, value, message: `Expected null` };
         }
     }
     function* Visit(schema, references, path, value) {

package/package.json

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

package/readme.md

@@ -47,30 +47,30 @@ type T = Static<typeof T>   // type T = string
 
 TypeBox is a type builder library that creates in-memory JSON Schema objects that can be statically inferred as TypeScript types. The schemas produced by this library are designed to match the static type checking rules of the TypeScript compiler. TypeBox enables one to create unified types that can be statically checked by TypeScript and runtime asserted using standard JSON Schema validation.
 
-TypeBox can be used as a simple tool to build up complex schemas or integrated into RPC or REST services to help validate data received over the wire. It offers a type system aligned to the capabilities of TypeScript and can be used equally well in JavaScript environments.
+TypeBox can be used as a simple tool to build up complex schemas or integrated into RPC or REST services to help validate JSON data received over the wire.
 
 License MIT
 
 ## Contents
-- [Install](#Install)
-- [Overview](#Overview)
-- [Usage](#Usage)
-- [Types](#Types)
-- [Modifiers](#Modifiers)
-- [Options](#Options)
-- [Extended Types](#Extended-Types)
-- [Reference Types](#Reference-Types)
-- [Recursive Types](#Recursive-Types)
-- [Generic Types](#Generic-Types)
-- [Unsafe Types](#Unsafe-Types)
-- [Conditional Types](#Conditional-Types)
-- [Values](#Values)
-- [Guards](#Guards)
-- [Strict](#Strict)
-- [Validation](#Validation)
-- [Compiler](#Compiler)
-- [Benchmark](#Benchmark)
-- [Contribute](#Contribute)
+- [Install](#install)
+- [Overview](#overview)
+- [Usage](#usage)
+- [Types](#types)
+- [Modifiers](#modifiers)
+- [Options](#options)
+- [Extended Types](#extended-types)
+- [Reference Types](#reference-types)
+- [Recursive Types](#recursive-types)
+- [Generic Types](#generic-types)
+- [Unsafe Types](#unsafe-types)
+- [Conditional Types](#conditional-types)
+- [Values](#values)
+- [Guards](#guards)
+- [Strict](#strict)
+- [Validation](#validation)
+- [Compiler](#compiler)
+- [Benchmark](#benchmark)
+- [Contribute](#contribute)
 
 <a name="Example"></a>
 
@@ -147,8 +147,6 @@ function receive(value: T) {                         // ... as a Type
 }
 ```
 
-<a name="Types"></a>
-
 ## Types
 
 The following table outlines the TypeBox mappings between TypeScript and JSON schema.
@@ -342,7 +340,6 @@ The following table outlines the TypeBox mappings between TypeScript and JSON sc
 │                                │                             │                                │
 └────────────────────────────────┴─────────────────────────────┴────────────────────────────────┘
 ```
-<a name="Modifiers"></a>
 
 ## Modifiers
 
@@ -386,8 +383,6 @@ TypeBox provides modifiers that can be applied to an objects properties. This al
 └────────────────────────────────┴─────────────────────────────┴────────────────────────────────┘
 ```
 
-<a name="Options"></a>
-
 ## Options
 
 You can pass additional JSON schema options on the last argument of any given type. The following are some examples.
@@ -403,8 +398,6 @@ const T = Type.Number({ multipleOf: 2 })
 const T = Type.Array(Type.Integer(), { minItems: 5 })
 ```
 
-<a name="Extended-Types"></a>
-
 ## Extended Types
 
 In addition to JSON schema types, TypeBox provides several extended types that allow for `function` and `constructor` types to be composed. These additional types are not valid JSON Schema and will not validate using typical JSON Schema validation. However, these types can be used to frame JSON schema and describe callable interfaces that may receive JSON validated data. These types are as follows.
@@ -467,8 +460,6 @@ In addition to JSON schema types, TypeBox provides several extended types that a
 └────────────────────────────────┴─────────────────────────────┴────────────────────────────────┘
 ```
 
-<a name="Reference-Types"></a>
-
 ## Reference Types
 
 Use `Type.Ref(...)` to create referenced types. The target type must specify an `$id`.
@@ -484,8 +475,6 @@ const R = Type.Ref(T)                                // const R = {
                                                      // }
 ```
 
-<a name="Recursive-Types"></a>
-
 ## Recursive Types
 
 Use `Type.Recursive(...)` to create recursive types.
@@ -524,8 +513,6 @@ function test(node: Node) {
 }
 ```
 
-<a name="Generic-Types"></a>
-
 ## Generic Types
 
 Use functions to create generic types. The following creates a generic `Nullable<T>` type. 
@@ -556,8 +543,6 @@ const U = Nullable(Type.Number())                    // const U = {
 type U = Static<typeof U>                            // type U = number | null
 ```
 
-<a name="Unsafe-Types"></a>
-
 ## Unsafe Types
 
 Use `Type.Unsafe(...)` to create custom schemas with user defined inference rules.
@@ -609,8 +594,6 @@ const T = StringEnum(['A', 'B', 'C'])                // const T = {
 type T = Static<typeof T>                            // type T = 'A' | 'B' | 'C'
 ```
 
-<a name="Conditional-Types"></a>
-
 ## Conditional Types
 
 Use `Conditional.Extends(...)` to create conditional mapped types.
@@ -660,8 +643,6 @@ The following table shows the TypeBox mappings between TypeScript and JSON schem
 └────────────────────────────────┴─────────────────────────────┴────────────────────────────────┘
 ```
 
-<a name="Values"></a>
-
 ## Values
 
 Use `Value.Create(...)` to generate values from types.
@@ -697,8 +678,6 @@ const B = Value.Cast(T, { x: 1 })                      // const B = { x: 1, y: 0
 const C = Value.Cast(T, { x: 1, y: 2, z: 3 })          // const C = { x: 1, y: 2 }
 ```
 
-<a name="Guards"></a>
-
 ## Guards
 
 Use a `TypeGuard` to test if a value meets a TypeBox type specification. Guards can be helpful when reflecting types.
@@ -716,8 +695,6 @@ if(TypeGuard.TString(T)) {
 
 ```
 
-<a name="Strict"></a>
-
 ## Strict
 
 TypeBox schemas contain the `Kind` and `Modifier` symbol properties. These properties are provided to enable runtime type reflection on schemas, as well as helping TypeBox internally compose types. These properties are not strictly valid JSON schema; so in some cases it may be desirable to omit them. TypeBox provides a `Type.Strict()` function that will omit these properties if necessary.
@@ -745,8 +722,6 @@ const U = Type.Strict(T)                             // const U = {
                                                      // }
 ```
 
-<a name="Validation"></a>
-
 ## Validation
 
 TypeBox schemas target JSON Schema draft 6 so any validator capable of draft 6 should be fine. A good library to use for validation in JavaScript environments is [Ajv](https://www.npmjs.com/package/ajv). The following example shows setting up Ajv to work with TypeBox.
@@ -812,8 +787,6 @@ const R = ajv.validate(T, { x: 1, y: 2, z: 3 })      // const R = true
 
 Please refer to the official Ajv [documentation](https://ajv.js.org/guide/getting-started.html) for additional information on using Ajv.
 
-<a name="Compiler"></a>
-
 ## Compiler
 
 TypeBox provides an optional high performance runtime type checker that can be used in applications that require extremely fast validation. This type checker is optimized for TypeBox types only whose schematics are known in advance. If defining custom schemas with `Type.Unsafe<T>` please consider Ajv.
@@ -845,16 +818,19 @@ const C = TypeCompiler.Compile(Type.Object({         // const C: TypeCheck<TObje
 const value = { }
 
 const errors = [...C.Errors(value)]                  // const errors = [{
+                                                     //   type: ValueErrorType.Number,
                                                      //   schema: { type: 'number' },
                                                      //   path: '/x',
                                                      //   value: undefined,
                                                      //   message: 'Expected number'
                                                      // }, {
+                                                     //   type: ValueErrorType.Number,
                                                      //   schema: { type: 'number' },
                                                      //   path: '/y',
                                                      //   value: undefined,
                                                      //   message: 'Expected number'
                                                      // }, {
+                                                     //   type: ValueErrorType.Number,
                                                      //   schema: { type: 'number' },
                                                      //   path: '/z',
                                                      //   value: undefined,
@@ -874,9 +850,13 @@ console.log(C.Code())                                // return function check(va
                                                      // }
 ```
 
+
+
 ## Benchmark
 
-This project maintains benchmarks that measure Ajv and TypeCompiler validate and compile performance. These benchmarks can be run locally by cloning this repository and running `npm run benchmark`. Results show against Ajv version 8.11.0.
+This project maintains a set of benchmarks that measure Ajv and TypeCompiler compilation and validation performance. These benchmarks can be run locally by cloning this repository and running `npm run benchmark`. The results below show for Ajv version 8.11.0. 
+
+For additional comparative benchmarks, please refer to [typescript-runtime-type-benchmarks](https://moltar.github.io/typescript-runtime-type-benchmarks/).
 
 ### Validate
 
@@ -948,8 +928,6 @@ This benchmark measures compilation performance for varying types. You can revie
 └──────────────────┴────────────┴──────────────┴──────────────┴──────────────┘
 ```
 
-<a name="Contribute"></a>
-
 ## Contribute
 
 TypeBox is open to community contribution. Please ensure you submit an open issue before submitting your pull request. The TypeBox project preferences open community discussion prior to accepting new features.

package/value/index.d.ts

@@ -1,2 +1,2 @@
-export type { ValueError } from './errors';
+export { ValueError, ValueErrorType } from '../error/errors';
 export * from './value';

package/value/index.js

@@ -41,4 +41,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValueErrorType = void 0;
+var errors_1 = require("../error/errors");
+Object.defineProperty(exports, "ValueErrorType", { enumerable: true, get: function () { return errors_1.ValueErrorType; } });
 __exportStar(require("./value"), exports);

package/value/value.d.ts

@@ -1,5 +1,5 @@
 import * as Types from '../typebox';
-import { ValueError } from './errors';
+import { ValueError } from '../error/errors';
 /** Creates Values from TypeBox Types */
 export declare namespace Value {
     /** Creates a value from the given type */

package/value/value.js

@@ -28,7 +28,7 @@ THE SOFTWARE.
 ---------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Value = void 0;
-const errors_1 = require("./errors");
+const errors_1 = require("../error/errors");
 const cast_1 = require("./cast");
 const create_1 = require("./create");
 const check_1 = require("./check");

package/value/errors.d.ts

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