@sinclair/typebox 0.32.0-dev-25 → 0.32.0-dev-26

package/build/import/errors/errors.mjs

@@ -124,8 +124,8 @@ export class ValueErrorIterator {
 // --------------------------------------------------------------------------
 // Create
 // --------------------------------------------------------------------------
-function Create(type, schema, path, value) {
-    return { type, schema, path, value, message: GetErrorFunction()(schema, type) };
+function Create(errorType, schema, path, value) {
+    return { type: errorType, schema, path, value, message: GetErrorFunction()({ errorType, path, schema, value }) };
 }
 // --------------------------------------------------------------------------
 // Types

package/build/import/errors/function.d.mts

@@ -1,9 +1,19 @@
 import { TSchema } from '../type/schema/index.mjs';
 import { ValueErrorType } from './errors.mjs';
 /** Creates an error message using en-US as the default locale */
-export declare function DefaultErrorFunction(schema: TSchema, errorType: ValueErrorType): string;
-export type ErrorFunction = (schema: TSchema, type: ValueErrorType) => string;
-/** Sets the error function used to generate error messages */
+export declare function DefaultErrorFunction(error: ErrorFunctionParameter): string;
+export type ErrorFunctionParameter = {
+    /** The type of validation error */
+    errorType: ValueErrorType;
+    /** The path of the error */
+    path: string;
+    /** The schema associated with the error */
+    schema: TSchema;
+    /** The value associated with the error */
+    value: unknown;
+};
+export type ErrorFunction = (parameter: ErrorFunctionParameter) => string;
+/** Sets the error function used to generate error messages. */
 export declare function SetErrorFunction(callback: ErrorFunction): void;
 /** Gets the error function used to generate error messages */
 export declare function GetErrorFunction(): ErrorFunction;

package/build/import/errors/function.mjs

@@ -1,18 +1,18 @@
 import { Kind } from '../type/symbols/index.mjs';
 import { ValueErrorType } from './errors.mjs';
 /** Creates an error message using en-US as the default locale */
-export function DefaultErrorFunction(schema, errorType) {
-    switch (errorType) {
+export function DefaultErrorFunction(error) {
+    switch (error.errorType) {
         case ValueErrorType.ArrayContains:
             return 'Expected array to contain at least one matching value';
         case ValueErrorType.ArrayMaxContains:
-            return `Expected array to contain no more than ${schema.maxContains} matching values`;
+            return `Expected array to contain no more than ${error.schema.maxContains} matching values`;
         case ValueErrorType.ArrayMinContains:
-            return `Expected array to contain at least ${schema.minContains} matching values`;
+            return `Expected array to contain at least ${error.schema.minContains} matching values`;
         case ValueErrorType.ArrayMaxItems:
-            return `Expected array length to be less or equal to ${schema.maxItems}`;
+            return `Expected array length to be less or equal to ${error.schema.maxItems}`;
         case ValueErrorType.ArrayMinItems:
-            return `Expected array length to be greater or equal to ${schema.minItems}`;
+            return `Expected array length to be greater or equal to ${error.schema.minItems}`;
         case ValueErrorType.ArrayUniqueItems:
             return 'Expected array elements to be unique';
         case ValueErrorType.Array:
@@ -20,43 +20,43 @@ export function DefaultErrorFunction(schema, errorType) {
         case ValueErrorType.AsyncIterator:
             return 'Expected AsyncIterator';
         case ValueErrorType.BigIntExclusiveMaximum:
-            return `Expected bigint to be less than ${schema.exclusiveMaximum}`;
+            return `Expected bigint to be less than ${error.schema.exclusiveMaximum}`;
         case ValueErrorType.BigIntExclusiveMinimum:
-            return `Expected bigint to be greater than ${schema.exclusiveMinimum}`;
+            return `Expected bigint to be greater than ${error.schema.exclusiveMinimum}`;
         case ValueErrorType.BigIntMaximum:
-            return `Expected bigint to be less or equal to ${schema.maximum}`;
+            return `Expected bigint to be less or equal to ${error.schema.maximum}`;
         case ValueErrorType.BigIntMinimum:
-            return `Expected bigint to be greater or equal to ${schema.minimum}`;
+            return `Expected bigint to be greater or equal to ${error.schema.minimum}`;
         case ValueErrorType.BigIntMultipleOf:
-            return `Expected bigint to be a multiple of ${schema.multipleOf}`;
+            return `Expected bigint to be a multiple of ${error.schema.multipleOf}`;
         case ValueErrorType.BigInt:
             return 'Expected bigint';
         case ValueErrorType.Boolean:
             return 'Expected boolean';
         case ValueErrorType.DateExclusiveMinimumTimestamp:
-            return `Expected Date timestamp to be greater than ${schema.exclusiveMinimumTimestamp}`;
+            return `Expected Date timestamp to be greater than ${error.schema.exclusiveMinimumTimestamp}`;
         case ValueErrorType.DateExclusiveMaximumTimestamp:
-            return `Expected Date timestamp to be less than ${schema.exclusiveMaximumTimestamp}`;
+            return `Expected Date timestamp to be less than ${error.schema.exclusiveMaximumTimestamp}`;
         case ValueErrorType.DateMinimumTimestamp:
-            return `Expected Date timestamp to be greater or equal to ${schema.minimumTimestamp}`;
+            return `Expected Date timestamp to be greater or equal to ${error.schema.minimumTimestamp}`;
         case ValueErrorType.DateMaximumTimestamp:
-            return `Expected Date timestamp to be less or equal to ${schema.maximumTimestamp}`;
+            return `Expected Date timestamp to be less or equal to ${error.schema.maximumTimestamp}`;
         case ValueErrorType.DateMultipleOfTimestamp:
-            return `Expected Date timestamp to be a multiple of ${schema.multipleOfTimestamp}`;
+            return `Expected Date timestamp to be a multiple of ${error.schema.multipleOfTimestamp}`;
         case ValueErrorType.Date:
             return 'Expected Date';
         case ValueErrorType.Function:
             return 'Expected function';
         case ValueErrorType.IntegerExclusiveMaximum:
-            return `Expected integer to be less than ${schema.exclusiveMaximum}`;
+            return `Expected integer to be less than ${error.schema.exclusiveMaximum}`;
         case ValueErrorType.IntegerExclusiveMinimum:
-            return `Expected integer to be greater than ${schema.exclusiveMinimum}`;
+            return `Expected integer to be greater than ${error.schema.exclusiveMinimum}`;
         case ValueErrorType.IntegerMaximum:
-            return `Expected integer to be less or equal to ${schema.maximum}`;
+            return `Expected integer to be less or equal to ${error.schema.maximum}`;
         case ValueErrorType.IntegerMinimum:
-            return `Expected integer to be greater or equal to ${schema.minimum}`;
+            return `Expected integer to be greater or equal to ${error.schema.minimum}`;
         case ValueErrorType.IntegerMultipleOf:
-            return `Expected integer to be a multiple of ${schema.multipleOf}`;
+            return `Expected integer to be a multiple of ${error.schema.multipleOf}`;
         case ValueErrorType.Integer:
             return 'Expected integer';
         case ValueErrorType.IntersectUnevaluatedProperties:
@@ -66,7 +66,7 @@ export function DefaultErrorFunction(schema, errorType) {
         case ValueErrorType.Iterator:
             return 'Expected Iterator';
         case ValueErrorType.Literal:
-            return `Expected ${typeof schema.const === 'string' ? `'${schema.const}'` : schema.const}`;
+            return `Expected ${typeof error.schema.const === 'string' ? `'${error.schema.const}'` : error.schema.const}`;
         case ValueErrorType.Never:
             return 'Never';
         case ValueErrorType.Not:
@@ -74,15 +74,15 @@ export function DefaultErrorFunction(schema, errorType) {
         case ValueErrorType.Null:
             return 'Expected null';
         case ValueErrorType.NumberExclusiveMaximum:
-            return `Expected number to be less than ${schema.exclusiveMaximum}`;
+            return `Expected number to be less than ${error.schema.exclusiveMaximum}`;
         case ValueErrorType.NumberExclusiveMinimum:
-            return `Expected number to be greater than ${schema.exclusiveMinimum}`;
+            return `Expected number to be greater than ${error.schema.exclusiveMinimum}`;
         case ValueErrorType.NumberMaximum:
-            return `Expected number to be less or equal to ${schema.maximum}`;
+            return `Expected number to be less or equal to ${error.schema.maximum}`;
         case ValueErrorType.NumberMinimum:
-            return `Expected number to be greater or equal to ${schema.minimum}`;
+            return `Expected number to be greater or equal to ${error.schema.minimum}`;
         case ValueErrorType.NumberMultipleOf:
-            return `Expected number to be a multiple of ${schema.multipleOf}`;
+            return `Expected number to be a multiple of ${error.schema.multipleOf}`;
         case ValueErrorType.Number:
             return 'Expected number';
         case ValueErrorType.Object:
@@ -90,35 +90,35 @@ export function DefaultErrorFunction(schema, errorType) {
         case ValueErrorType.ObjectAdditionalProperties:
             return 'Unexpected property';
         case ValueErrorType.ObjectMaxProperties:
-            return `Expected object to have no more than ${schema.maxProperties} properties`;
+            return `Expected object to have no more than ${error.schema.maxProperties} properties`;
         case ValueErrorType.ObjectMinProperties:
-            return `Expected object to have at least ${schema.minProperties} properties`;
+            return `Expected object to have at least ${error.schema.minProperties} properties`;
         case ValueErrorType.ObjectRequiredProperty:
             return 'Required property';
         case ValueErrorType.Promise:
             return 'Expected Promise';
         case ValueErrorType.StringFormatUnknown:
-            return `Unknown format '${schema.format}'`;
+            return `Unknown format '${error.schema.format}'`;
         case ValueErrorType.StringFormat:
-            return `Expected string to match '${schema.format}' format`;
+            return `Expected string to match '${error.schema.format}' format`;
         case ValueErrorType.StringMaxLength:
-            return `Expected string length less or equal to ${schema.maxLength}`;
+            return `Expected string length less or equal to ${error.schema.maxLength}`;
         case ValueErrorType.StringMinLength:
-            return `Expected string length greater or equal to ${schema.minLength}`;
+            return `Expected string length greater or equal to ${error.schema.minLength}`;
         case ValueErrorType.StringPattern:
-            return `Expected string to match '${schema.pattern}'`;
+            return `Expected string to match '${error.schema.pattern}'`;
         case ValueErrorType.String:
             return 'Expected string';
         case ValueErrorType.Symbol:
             return 'Expected symbol';
         case ValueErrorType.TupleLength:
-            return `Expected tuple to have ${schema.maxItems || 0} elements`;
+            return `Expected tuple to have ${error.schema.maxItems || 0} elements`;
         case ValueErrorType.Tuple:
             return 'Expected tuple';
         case ValueErrorType.Uint8ArrayMaxByteLength:
-            return `Expected byte length less or equal to ${schema.maxByteLength}`;
+            return `Expected byte length less or equal to ${error.schema.maxByteLength}`;
         case ValueErrorType.Uint8ArrayMinByteLength:
-            return `Expected byte length greater or equal to ${schema.minByteLength}`;
+            return `Expected byte length greater or equal to ${error.schema.minByteLength}`;
         case ValueErrorType.Uint8Array:
             return 'Expected Uint8Array';
         case ValueErrorType.Undefined:
@@ -128,14 +128,14 @@ export function DefaultErrorFunction(schema, errorType) {
         case ValueErrorType.Void:
             return 'Expected void';
         case ValueErrorType.Kind:
-            return `Expected kind '${schema[Kind]}'`;
+            return `Expected kind '${error.schema[Kind]}'`;
         default:
             return 'Unknown error type';
     }
 }
 /** Manages error message providers */
 let errorFunction = DefaultErrorFunction;
-/** Sets the error function used to generate error messages */
+/** Sets the error function used to generate error messages. */
 export function SetErrorFunction(callback) {
     errorFunction = callback;
 }

package/build/import/type/indexed/indexed-from-mapped-result.d.mts

@@ -1,8 +1,8 @@
 import type { TSchema, SchemaOptions } from '../schema/index.mjs';
 import type { TProperties } from '../object/index.mjs';
 import { type TMappedResult } from '../mapped/index.mjs';
+import { type TIndexPropertyKeys } from './indexed-property-keys.mjs';
 import { type TIndex } from './index.mjs';
-import { TIndexPropertyKeys } from './indexed-property-keys.mjs';
 type TFromProperties<T extends TSchema, P extends TProperties> = ({
     [K2 in keyof P]: TIndex<T, TIndexPropertyKeys<P[K2]>>;
 });

package/build/import/type/indexed/indexed-from-mapped-result.mjs

@@ -1,6 +1,6 @@
 import { MappedResult } from '../mapped/index.mjs';
-import { Index } from './index.mjs';
 import { IndexPropertyKeys } from './indexed-property-keys.mjs';
+import { Index } from './index.mjs';
 // prettier-ignore
 function FromProperties(T, P, options) {
     return globalThis.Object.getOwnPropertyNames(P).reduce((Acc, K2) => {

package/build/require/errors/errors.js

@@ -128,8 +128,8 @@ exports.ValueErrorIterator = ValueErrorIterator;
 // --------------------------------------------------------------------------
 // Create
 // --------------------------------------------------------------------------
-function Create(type, schema, path, value) {
-    return { type, schema, path, value, message: (0, function_1.GetErrorFunction)()(schema, type) };
+function Create(errorType, schema, path, value) {
+    return { type: errorType, schema, path, value, message: (0, function_1.GetErrorFunction)()({ errorType, path, schema, value }) };
 }
 // --------------------------------------------------------------------------
 // Types

package/build/require/errors/function.d.ts

@@ -1,9 +1,19 @@
 import { TSchema } from '../type/schema/index';
 import { ValueErrorType } from './errors';
 /** Creates an error message using en-US as the default locale */
-export declare function DefaultErrorFunction(schema: TSchema, errorType: ValueErrorType): string;
-export type ErrorFunction = (schema: TSchema, type: ValueErrorType) => string;
-/** Sets the error function used to generate error messages */
+export declare function DefaultErrorFunction(error: ErrorFunctionParameter): string;
+export type ErrorFunctionParameter = {
+    /** The type of validation error */
+    errorType: ValueErrorType;
+    /** The path of the error */
+    path: string;
+    /** The schema associated with the error */
+    schema: TSchema;
+    /** The value associated with the error */
+    value: unknown;
+};
+export type ErrorFunction = (parameter: ErrorFunctionParameter) => string;
+/** Sets the error function used to generate error messages. */
 export declare function SetErrorFunction(callback: ErrorFunction): void;
 /** Gets the error function used to generate error messages */
 export declare function GetErrorFunction(): ErrorFunction;

package/build/require/errors/function.js

@@ -5,18 +5,18 @@ exports.GetErrorFunction = exports.SetErrorFunction = exports.DefaultErrorFuncti
 const index_1 = require("../type/symbols/index");
 const errors_1 = require("./errors");
 /** Creates an error message using en-US as the default locale */
-function DefaultErrorFunction(schema, errorType) {
-    switch (errorType) {
+function DefaultErrorFunction(error) {
+    switch (error.errorType) {
         case errors_1.ValueErrorType.ArrayContains:
             return 'Expected array to contain at least one matching value';
         case errors_1.ValueErrorType.ArrayMaxContains:
-            return `Expected array to contain no more than ${schema.maxContains} matching values`;
+            return `Expected array to contain no more than ${error.schema.maxContains} matching values`;
         case errors_1.ValueErrorType.ArrayMinContains:
-            return `Expected array to contain at least ${schema.minContains} matching values`;
+            return `Expected array to contain at least ${error.schema.minContains} matching values`;
         case errors_1.ValueErrorType.ArrayMaxItems:
-            return `Expected array length to be less or equal to ${schema.maxItems}`;
+            return `Expected array length to be less or equal to ${error.schema.maxItems}`;
         case errors_1.ValueErrorType.ArrayMinItems:
-            return `Expected array length to be greater or equal to ${schema.minItems}`;
+            return `Expected array length to be greater or equal to ${error.schema.minItems}`;
         case errors_1.ValueErrorType.ArrayUniqueItems:
             return 'Expected array elements to be unique';
         case errors_1.ValueErrorType.Array:
@@ -24,43 +24,43 @@ function DefaultErrorFunction(schema, errorType) {
         case errors_1.ValueErrorType.AsyncIterator:
             return 'Expected AsyncIterator';
         case errors_1.ValueErrorType.BigIntExclusiveMaximum:
-            return `Expected bigint to be less than ${schema.exclusiveMaximum}`;
+            return `Expected bigint to be less than ${error.schema.exclusiveMaximum}`;
         case errors_1.ValueErrorType.BigIntExclusiveMinimum:
-            return `Expected bigint to be greater than ${schema.exclusiveMinimum}`;
+            return `Expected bigint to be greater than ${error.schema.exclusiveMinimum}`;
         case errors_1.ValueErrorType.BigIntMaximum:
-            return `Expected bigint to be less or equal to ${schema.maximum}`;
+            return `Expected bigint to be less or equal to ${error.schema.maximum}`;
         case errors_1.ValueErrorType.BigIntMinimum:
-            return `Expected bigint to be greater or equal to ${schema.minimum}`;
+            return `Expected bigint to be greater or equal to ${error.schema.minimum}`;
         case errors_1.ValueErrorType.BigIntMultipleOf:
-            return `Expected bigint to be a multiple of ${schema.multipleOf}`;
+            return `Expected bigint to be a multiple of ${error.schema.multipleOf}`;
         case errors_1.ValueErrorType.BigInt:
             return 'Expected bigint';
         case errors_1.ValueErrorType.Boolean:
             return 'Expected boolean';
         case errors_1.ValueErrorType.DateExclusiveMinimumTimestamp:
-            return `Expected Date timestamp to be greater than ${schema.exclusiveMinimumTimestamp}`;
+            return `Expected Date timestamp to be greater than ${error.schema.exclusiveMinimumTimestamp}`;
         case errors_1.ValueErrorType.DateExclusiveMaximumTimestamp:
-            return `Expected Date timestamp to be less than ${schema.exclusiveMaximumTimestamp}`;
+            return `Expected Date timestamp to be less than ${error.schema.exclusiveMaximumTimestamp}`;
         case errors_1.ValueErrorType.DateMinimumTimestamp:
-            return `Expected Date timestamp to be greater or equal to ${schema.minimumTimestamp}`;
+            return `Expected Date timestamp to be greater or equal to ${error.schema.minimumTimestamp}`;
         case errors_1.ValueErrorType.DateMaximumTimestamp:
-            return `Expected Date timestamp to be less or equal to ${schema.maximumTimestamp}`;
+            return `Expected Date timestamp to be less or equal to ${error.schema.maximumTimestamp}`;
         case errors_1.ValueErrorType.DateMultipleOfTimestamp:
-            return `Expected Date timestamp to be a multiple of ${schema.multipleOfTimestamp}`;
+            return `Expected Date timestamp to be a multiple of ${error.schema.multipleOfTimestamp}`;
         case errors_1.ValueErrorType.Date:
             return 'Expected Date';
         case errors_1.ValueErrorType.Function:
             return 'Expected function';
         case errors_1.ValueErrorType.IntegerExclusiveMaximum:
-            return `Expected integer to be less than ${schema.exclusiveMaximum}`;
+            return `Expected integer to be less than ${error.schema.exclusiveMaximum}`;
         case errors_1.ValueErrorType.IntegerExclusiveMinimum:
-            return `Expected integer to be greater than ${schema.exclusiveMinimum}`;
+            return `Expected integer to be greater than ${error.schema.exclusiveMinimum}`;
         case errors_1.ValueErrorType.IntegerMaximum:
-            return `Expected integer to be less or equal to ${schema.maximum}`;
+            return `Expected integer to be less or equal to ${error.schema.maximum}`;
         case errors_1.ValueErrorType.IntegerMinimum:
-            return `Expected integer to be greater or equal to ${schema.minimum}`;
+            return `Expected integer to be greater or equal to ${error.schema.minimum}`;
         case errors_1.ValueErrorType.IntegerMultipleOf:
-            return `Expected integer to be a multiple of ${schema.multipleOf}`;
+            return `Expected integer to be a multiple of ${error.schema.multipleOf}`;
         case errors_1.ValueErrorType.Integer:
             return 'Expected integer';
         case errors_1.ValueErrorType.IntersectUnevaluatedProperties:
@@ -70,7 +70,7 @@ function DefaultErrorFunction(schema, errorType) {
         case errors_1.ValueErrorType.Iterator:
             return 'Expected Iterator';
         case errors_1.ValueErrorType.Literal:
-            return `Expected ${typeof schema.const === 'string' ? `'${schema.const}'` : schema.const}`;
+            return `Expected ${typeof error.schema.const === 'string' ? `'${error.schema.const}'` : error.schema.const}`;
         case errors_1.ValueErrorType.Never:
             return 'Never';
         case errors_1.ValueErrorType.Not:
@@ -78,15 +78,15 @@ function DefaultErrorFunction(schema, errorType) {
         case errors_1.ValueErrorType.Null:
             return 'Expected null';
         case errors_1.ValueErrorType.NumberExclusiveMaximum:
-            return `Expected number to be less than ${schema.exclusiveMaximum}`;
+            return `Expected number to be less than ${error.schema.exclusiveMaximum}`;
         case errors_1.ValueErrorType.NumberExclusiveMinimum:
-            return `Expected number to be greater than ${schema.exclusiveMinimum}`;
+            return `Expected number to be greater than ${error.schema.exclusiveMinimum}`;
         case errors_1.ValueErrorType.NumberMaximum:
-            return `Expected number to be less or equal to ${schema.maximum}`;
+            return `Expected number to be less or equal to ${error.schema.maximum}`;
         case errors_1.ValueErrorType.NumberMinimum:
-            return `Expected number to be greater or equal to ${schema.minimum}`;
+            return `Expected number to be greater or equal to ${error.schema.minimum}`;
         case errors_1.ValueErrorType.NumberMultipleOf:
-            return `Expected number to be a multiple of ${schema.multipleOf}`;
+            return `Expected number to be a multiple of ${error.schema.multipleOf}`;
         case errors_1.ValueErrorType.Number:
             return 'Expected number';
         case errors_1.ValueErrorType.Object:
@@ -94,35 +94,35 @@ function DefaultErrorFunction(schema, errorType) {
         case errors_1.ValueErrorType.ObjectAdditionalProperties:
             return 'Unexpected property';
         case errors_1.ValueErrorType.ObjectMaxProperties:
-            return `Expected object to have no more than ${schema.maxProperties} properties`;
+            return `Expected object to have no more than ${error.schema.maxProperties} properties`;
         case errors_1.ValueErrorType.ObjectMinProperties:
-            return `Expected object to have at least ${schema.minProperties} properties`;
+            return `Expected object to have at least ${error.schema.minProperties} properties`;
         case errors_1.ValueErrorType.ObjectRequiredProperty:
             return 'Required property';
         case errors_1.ValueErrorType.Promise:
             return 'Expected Promise';
         case errors_1.ValueErrorType.StringFormatUnknown:
-            return `Unknown format '${schema.format}'`;
+            return `Unknown format '${error.schema.format}'`;
         case errors_1.ValueErrorType.StringFormat:
-            return `Expected string to match '${schema.format}' format`;
+            return `Expected string to match '${error.schema.format}' format`;
         case errors_1.ValueErrorType.StringMaxLength:
-            return `Expected string length less or equal to ${schema.maxLength}`;
+            return `Expected string length less or equal to ${error.schema.maxLength}`;
         case errors_1.ValueErrorType.StringMinLength:
-            return `Expected string length greater or equal to ${schema.minLength}`;
+            return `Expected string length greater or equal to ${error.schema.minLength}`;
         case errors_1.ValueErrorType.StringPattern:
-            return `Expected string to match '${schema.pattern}'`;
+            return `Expected string to match '${error.schema.pattern}'`;
         case errors_1.ValueErrorType.String:
             return 'Expected string';
         case errors_1.ValueErrorType.Symbol:
             return 'Expected symbol';
         case errors_1.ValueErrorType.TupleLength:
-            return `Expected tuple to have ${schema.maxItems || 0} elements`;
+            return `Expected tuple to have ${error.schema.maxItems || 0} elements`;
         case errors_1.ValueErrorType.Tuple:
             return 'Expected tuple';
         case errors_1.ValueErrorType.Uint8ArrayMaxByteLength:
-            return `Expected byte length less or equal to ${schema.maxByteLength}`;
+            return `Expected byte length less or equal to ${error.schema.maxByteLength}`;
         case errors_1.ValueErrorType.Uint8ArrayMinByteLength:
-            return `Expected byte length greater or equal to ${schema.minByteLength}`;
+            return `Expected byte length greater or equal to ${error.schema.minByteLength}`;
         case errors_1.ValueErrorType.Uint8Array:
             return 'Expected Uint8Array';
         case errors_1.ValueErrorType.Undefined:
@@ -132,7 +132,7 @@ function DefaultErrorFunction(schema, errorType) {
         case errors_1.ValueErrorType.Void:
             return 'Expected void';
         case errors_1.ValueErrorType.Kind:
-            return `Expected kind '${schema[index_1.Kind]}'`;
+            return `Expected kind '${error.schema[index_1.Kind]}'`;
         default:
             return 'Unknown error type';
     }
@@ -140,7 +140,7 @@ function DefaultErrorFunction(schema, errorType) {
 exports.DefaultErrorFunction = DefaultErrorFunction;
 /** Manages error message providers */
 let errorFunction = DefaultErrorFunction;
-/** Sets the error function used to generate error messages */
+/** Sets the error function used to generate error messages. */
 function SetErrorFunction(callback) {
     errorFunction = callback;
 }

package/build/require/type/indexed/indexed-from-mapped-result.d.ts

@@ -1,8 +1,8 @@
 import type { TSchema, SchemaOptions } from '../schema/index';
 import type { TProperties } from '../object/index';
 import { type TMappedResult } from '../mapped/index';
+import { type TIndexPropertyKeys } from './indexed-property-keys';
 import { type TIndex } from './index';
-import { TIndexPropertyKeys } from './indexed-property-keys';
 type TFromProperties<T extends TSchema, P extends TProperties> = ({
     [K2 in keyof P]: TIndex<T, TIndexPropertyKeys<P[K2]>>;
 });

package/build/require/type/indexed/indexed-from-mapped-result.js

@@ -3,8 +3,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.IndexFromMappedResult = void 0;
 const index_1 = require("../mapped/index");
-const index_2 = require("./index");
 const indexed_property_keys_1 = require("./indexed-property-keys");
+const index_2 = require("./index");
 // prettier-ignore
 function FromProperties(T, P, options) {
     return globalThis.Object.getOwnPropertyNames(P).reduce((Acc, K2) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.32.0-dev-25",
+  "version": "0.32.0-dev-26",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",

package/readme.md

@@ -1619,12 +1619,12 @@ The following example shows an inline error function that intercepts errors for
 ```typescript
 import { SetErrorFunction, DefaultErrorFunction, ValueErrorType } from '@sinclair/typebox/errors'
 
-SetErrorFunction((schema, errorType) => { // i18n override
-  switch(errorType) {
+SetErrorFunction((error) => { // i18n override
+  switch(error.errorType) {
     /* en-US */ case ValueErrorType.String: return 'Expected string'
     /* fr-FR */ case ValueErrorType.Number: return 'Nombre attendu'  
     /* ko-KR */ case ValueErrorType.Boolean: return '예상 부울'      
-    /* en-US */ default: return DefaultErrorFunction(schema, errorType)          
+    /* en-US */ default: return DefaultErrorFunction(error)          
   }
 })
 const T = Type.Object({                              // const T: TObject<{
@@ -1795,10 +1795,10 @@ The following table lists esbuild compiled and minified sizes for each TypeBox m
 ┌──────────────────────┬────────────┬────────────┬─────────────┐
 │       (index)        │  Compiled  │  Minified  │ Compression │
 ├──────────────────────┼────────────┼────────────┼─────────────┤
-│ typebox/compiler     │ '120.5 kb' │ ' 52.7 kb' │  '2.29 x'   │
-│ typebox/errors       │ ' 55.5 kb' │ ' 25.2 kb' │  '2.20 x'   │
+│ typebox/compiler     │ '120.7 kb' │ ' 53.0 kb' │  '2.28 x'   │
+│ typebox/errors       │ ' 55.8 kb' │ ' 25.5 kb' │  '2.19 x'   │
 │ typebox/system       │ '  4.7 kb' │ '  2.0 kb' │  '2.33 x'   │
-│ typebox/value        │ '147.4 kb' │ ' 62.2 kb' │  '2.37 x'   │
+│ typebox/value        │ '147.6 kb' │ ' 62.5 kb' │  '2.36 x'   │
 │ typebox              │ ' 91.3 kb' │ ' 38.0 kb' │  '2.40 x'   │
 └──────────────────────┴────────────┴────────────┴─────────────┘
 ```