@sinclair/typebox 0.33.14 → 0.33.16

package/build/cjs/errors/errors.d.ts

@@ -72,6 +72,7 @@ export interface ValueError {
     path: string;
     value: unknown;
     message: string;
+    errors: ValueErrorIterator[];
 }
 export declare class ValueErrorsUnknownTypeError extends TypeBoxError {
     readonly schema: TSchema;

package/build/cjs/errors/errors.js

@@ -11,13 +11,14 @@ const function_1 = require("./function");
 const index_4 = require("../type/error/index");
 const index_5 = require("../value/deref/index");
 const index_6 = require("../value/hash/index");
-const index_7 = require("../type/symbols/index");
-const index_8 = require("../type/never/index");
+const index_7 = require("../value/check/index");
+const index_8 = require("../type/symbols/index");
+const index_9 = require("../type/never/index");
 // ------------------------------------------------------------------
 // ValueGuard
 // ------------------------------------------------------------------
 // prettier-ignore
-const index_9 = require("../value/guard/index");
+const index_10 = require("../value/guard/index");
 // ------------------------------------------------------------------
 // ValueErrorType
 // ------------------------------------------------------------------
@@ -130,15 +131,22 @@ exports.ValueErrorIterator = ValueErrorIterator;
 // --------------------------------------------------------------------------
 // Create
 // --------------------------------------------------------------------------
-function Create(errorType, schema, path, value) {
-    return { type: errorType, schema, path, value, message: (0, function_1.GetErrorFunction)()({ errorType, path, schema, value }) };
+function Create(errorType, schema, path, value, errors = []) {
+    return {
+        type: errorType,
+        schema,
+        path,
+        value,
+        message: (0, function_1.GetErrorFunction)()({ errorType, path, schema, value, errors }),
+        errors,
+    };
 }
 // --------------------------------------------------------------------------
 // Types
 // --------------------------------------------------------------------------
 function* FromAny(schema, references, path, value) { }
 function* FromArray(schema, references, path, value) {
-    if (!(0, index_9.IsArray)(value)) {
+    if (!(0, index_10.IsArray)(value)) {
         return yield Create(ValueErrorType.Array, schema, path, value);
     }
     if (IsDefined(schema.minItems) && !(value.length >= schema.minItems)) {
@@ -166,24 +174,24 @@ function* FromArray(schema, references, path, value) {
     if (!(IsDefined(schema.contains) || IsDefined(schema.minContains) || IsDefined(schema.maxContains))) {
         return;
     }
-    const containsSchema = IsDefined(schema.contains) ? schema.contains : (0, index_8.Never)();
+    const containsSchema = IsDefined(schema.contains) ? schema.contains : (0, index_9.Never)();
     const containsCount = value.reduce((acc, value, index) => (Visit(containsSchema, references, `${path}${index}`, value).next().done === true ? acc + 1 : acc), 0);
     if (containsCount === 0) {
         yield Create(ValueErrorType.ArrayContains, schema, path, value);
     }
-    if ((0, index_9.IsNumber)(schema.minContains) && containsCount < schema.minContains) {
+    if ((0, index_10.IsNumber)(schema.minContains) && containsCount < schema.minContains) {
         yield Create(ValueErrorType.ArrayMinContains, schema, path, value);
     }
-    if ((0, index_9.IsNumber)(schema.maxContains) && containsCount > schema.maxContains) {
+    if ((0, index_10.IsNumber)(schema.maxContains) && containsCount > schema.maxContains) {
         yield Create(ValueErrorType.ArrayMaxContains, schema, path, value);
     }
 }
 function* FromAsyncIterator(schema, references, path, value) {
-    if (!(0, index_9.IsAsyncIterator)(value))
+    if (!(0, index_10.IsAsyncIterator)(value))
         yield Create(ValueErrorType.AsyncIterator, schema, path, value);
 }
 function* FromBigInt(schema, references, path, value) {
-    if (!(0, index_9.IsBigInt)(value))
+    if (!(0, index_10.IsBigInt)(value))
         return yield Create(ValueErrorType.BigInt, schema, path, value);
     if (IsDefined(schema.exclusiveMaximum) && !(value < schema.exclusiveMaximum)) {
         yield Create(ValueErrorType.BigIntExclusiveMaximum, schema, path, value);
@@ -202,14 +210,14 @@ function* FromBigInt(schema, references, path, value) {
     }
 }
 function* FromBoolean(schema, references, path, value) {
-    if (!(0, index_9.IsBoolean)(value))
+    if (!(0, index_10.IsBoolean)(value))
         yield Create(ValueErrorType.Boolean, schema, path, value);
 }
 function* FromConstructor(schema, references, path, value) {
     yield* Visit(schema.returns, references, path, value.prototype);
 }
 function* FromDate(schema, references, path, value) {
-    if (!(0, index_9.IsDate)(value))
+    if (!(0, index_10.IsDate)(value))
         return yield Create(ValueErrorType.Date, schema, path, value);
     if (IsDefined(schema.exclusiveMaximumTimestamp) && !(value.getTime() < schema.exclusiveMaximumTimestamp)) {
         yield Create(ValueErrorType.DateExclusiveMaximumTimestamp, schema, path, value);
@@ -228,11 +236,11 @@ function* FromDate(schema, references, path, value) {
     }
 }
 function* FromFunction(schema, references, path, value) {
-    if (!(0, index_9.IsFunction)(value))
+    if (!(0, index_10.IsFunction)(value))
         yield Create(ValueErrorType.Function, schema, path, value);
 }
 function* FromInteger(schema, references, path, value) {
-    if (!(0, index_9.IsInteger)(value))
+    if (!(0, index_10.IsInteger)(value))
         return yield Create(ValueErrorType.Integer, schema, path, value);
     if (IsDefined(schema.exclusiveMaximum) && !(value < schema.exclusiveMaximum)) {
         yield Create(ValueErrorType.IntegerExclusiveMaximum, schema, path, value);
@@ -281,7 +289,7 @@ function* FromIntersect(schema, references, path, value) {
     }
 }
 function* FromIterator(schema, references, path, value) {
-    if (!(0, index_9.IsIterator)(value))
+    if (!(0, index_10.IsIterator)(value))
         yield Create(ValueErrorType.Iterator, schema, path, value);
 }
 function* FromLiteral(schema, references, path, value) {
@@ -296,7 +304,7 @@ function* FromNot(schema, references, path, value) {
         yield Create(ValueErrorType.Not, schema, path, value);
 }
 function* FromNull(schema, references, path, value) {
-    if (!(0, index_9.IsNull)(value))
+    if (!(0, index_10.IsNull)(value))
         yield Create(ValueErrorType.Null, schema, path, value);
 }
 function* FromNumber(schema, references, path, value) {
@@ -365,7 +373,7 @@ function* FromObject(schema, references, path, value) {
     }
 }
 function* FromPromise(schema, references, path, value) {
-    if (!(0, index_9.IsPromise)(value))
+    if (!(0, index_10.IsPromise)(value))
         yield Create(ValueErrorType.Promise, schema, path, value);
 }
 function* FromRecord(schema, references, path, value) {
@@ -401,7 +409,7 @@ function* FromRef(schema, references, path, value) {
     yield* Visit((0, index_5.Deref)(schema, references), references, path, value);
 }
 function* FromRegExp(schema, references, path, value) {
-    if (!(0, index_9.IsString)(value))
+    if (!(0, index_10.IsString)(value))
         return yield Create(ValueErrorType.String, schema, path, value);
     if (IsDefined(schema.minLength) && !(value.length >= schema.minLength)) {
         yield Create(ValueErrorType.StringMinLength, schema, path, value);
@@ -415,7 +423,7 @@ function* FromRegExp(schema, references, path, value) {
     }
 }
 function* FromString(schema, references, path, value) {
-    if (!(0, index_9.IsString)(value))
+    if (!(0, index_10.IsString)(value))
         return yield Create(ValueErrorType.String, schema, path, value);
     if (IsDefined(schema.minLength) && !(value.length >= schema.minLength)) {
         yield Create(ValueErrorType.StringMinLength, schema, path, value);
@@ -423,13 +431,13 @@ function* FromString(schema, references, path, value) {
     if (IsDefined(schema.maxLength) && !(value.length <= schema.maxLength)) {
         yield Create(ValueErrorType.StringMaxLength, schema, path, value);
     }
-    if ((0, index_9.IsString)(schema.pattern)) {
+    if ((0, index_10.IsString)(schema.pattern)) {
         const regex = new RegExp(schema.pattern);
         if (!regex.test(value)) {
             yield Create(ValueErrorType.StringPattern, schema, path, value);
         }
     }
-    if ((0, index_9.IsString)(schema.format)) {
+    if ((0, index_10.IsString)(schema.format)) {
         if (!index_3.FormatRegistry.Has(schema.format)) {
             yield Create(ValueErrorType.StringFormatUnknown, schema, path, value);
         }
@@ -442,11 +450,11 @@ function* FromString(schema, references, path, value) {
     }
 }
 function* FromSymbol(schema, references, path, value) {
-    if (!(0, index_9.IsSymbol)(value))
+    if (!(0, index_10.IsSymbol)(value))
         yield Create(ValueErrorType.Symbol, schema, path, value);
 }
 function* FromTemplateLiteral(schema, references, path, value) {
-    if (!(0, index_9.IsString)(value))
+    if (!(0, index_10.IsString)(value))
         return yield Create(ValueErrorType.String, schema, path, value);
     const regex = new RegExp(schema.pattern);
     if (!regex.test(value)) {
@@ -457,7 +465,7 @@ function* FromThis(schema, references, path, value) {
     yield* Visit((0, index_5.Deref)(schema, references), references, path, value);
 }
 function* FromTuple(schema, references, path, value) {
-    if (!(0, index_9.IsArray)(value))
+    if (!(0, index_10.IsArray)(value))
         return yield Create(ValueErrorType.Tuple, schema, path, value);
     if (schema.items === undefined && !(value.length === 0)) {
         return yield Create(ValueErrorType.TupleLength, schema, path, value);
@@ -473,23 +481,17 @@ function* FromTuple(schema, references, path, value) {
     }
 }
 function* FromUndefined(schema, references, path, value) {
-    if (!(0, index_9.IsUndefined)(value))
+    if (!(0, index_10.IsUndefined)(value))
         yield Create(ValueErrorType.Undefined, schema, path, value);
 }
 function* FromUnion(schema, references, path, value) {
-    let count = 0;
-    for (const subschema of schema.anyOf) {
-        const errors = [...Visit(subschema, references, path, value)];
-        if (errors.length === 0)
-            return; // matched
-        count += errors.length;
-    }
-    if (count > 0) {
-        yield Create(ValueErrorType.Union, schema, path, value);
-    }
+    if ((0, index_7.Check)(schema, references, value))
+        return;
+    const errors = schema.anyOf.map((variant) => new ValueErrorIterator(Visit(variant, references, path, value)));
+    yield Create(ValueErrorType.Union, schema, path, value, errors);
 }
 function* FromUint8Array(schema, references, path, value) {
-    if (!(0, index_9.IsUint8Array)(value))
+    if (!(0, index_10.IsUint8Array)(value))
         return yield Create(ValueErrorType.Uint8Array, schema, path, value);
     if (IsDefined(schema.maxByteLength) && !(value.length <= schema.maxByteLength)) {
         yield Create(ValueErrorType.Uint8ArrayMaxByteLength, schema, path, value);
@@ -504,14 +506,14 @@ function* FromVoid(schema, references, path, value) {
         yield Create(ValueErrorType.Void, schema, path, value);
 }
 function* FromKind(schema, references, path, value) {
-    const check = index_3.TypeRegistry.Get(schema[index_7.Kind]);
+    const check = index_3.TypeRegistry.Get(schema[index_8.Kind]);
     if (!check(schema, value))
         yield Create(ValueErrorType.Kind, schema, path, value);
 }
 function* Visit(schema, references, path, value) {
     const references_ = IsDefined(schema.$id) ? [...references, schema] : references;
     const schema_ = schema;
-    switch (schema_[index_7.Kind]) {
+    switch (schema_[index_8.Kind]) {
         case 'Any':
             return yield* FromAny(schema_, references_, path, value);
         case 'Array':
@@ -575,7 +577,7 @@ function* Visit(schema, references, path, value) {
         case 'Void':
             return yield* FromVoid(schema_, references_, path, value);
         default:
-            if (!index_3.TypeRegistry.Has(schema_[index_7.Kind]))
+            if (!index_3.TypeRegistry.Has(schema_[index_8.Kind]))
                 throw new ValueErrorsUnknownTypeError(schema);
             return yield* FromKind(schema_, references_, path, value);
     }

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

@@ -1,5 +1,5 @@
 import { TSchema } from '../type/schema/index';
-import { ValueErrorType } from './errors';
+import { ValueErrorIterator, ValueErrorType } from './errors';
 /** Creates an error message using en-US as the default locale */
 export declare function DefaultErrorFunction(error: ErrorFunctionParameter): string;
 export type ErrorFunctionParameter = {
@@ -11,6 +11,8 @@ export type ErrorFunctionParameter = {
     schema: TSchema;
     /** The value associated with the error */
     value: unknown;
+    /** Interior errors for this error */
+    errors: ValueErrorIterator[];
 };
 export type ErrorFunction = (parameter: ErrorFunctionParameter) => string;
 /** Sets the error function used to generate error messages. */

package/build/cjs/type/guard/value.d.ts

@@ -1,3 +1,7 @@
+/** Returns true if this value has this property key */
+export declare function HasPropertyKey<K extends PropertyKey>(value: Record<any, unknown>, key: K): value is Record<PropertyKey, unknown> & {
+    [_ in K]: unknown;
+};
 /** Returns true if this value is an async iterator */
 export declare function IsAsyncIterator(value: unknown): value is AsyncIterableIterator<unknown>;
 /** Returns true if this value is an array */

package/build/cjs/type/guard/value.js

@@ -1,6 +1,7 @@
 "use strict";
 
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.HasPropertyKey = HasPropertyKey;
 exports.IsAsyncIterator = IsAsyncIterator;
 exports.IsArray = IsArray;
 exports.IsBigInt = IsBigInt;
@@ -17,6 +18,13 @@ exports.IsSymbol = IsSymbol;
 exports.IsUint8Array = IsUint8Array;
 exports.IsUndefined = IsUndefined;
 // --------------------------------------------------------------------------
+// PropertyKey
+// --------------------------------------------------------------------------
+/** Returns true if this value has this property key */
+function HasPropertyKey(value, key) {
+    return key in value;
+}
+// --------------------------------------------------------------------------
 // Object Instances
 // --------------------------------------------------------------------------
 /** Returns true if this value is an async iterator */

package/build/cjs/value/default/default.js

@@ -40,6 +40,10 @@ function FromArray(schema, references, value) {
     }
     return defaulted;
 }
+function FromDate(schema, references, value) {
+    // special case intercept for dates
+    return (0, index_5.IsDate)(value) ? value : ValueOrDefault(schema, value);
+}
 function FromIntersect(schema, references, value) {
     const defaulted = ValueOrDefault(schema, value);
     return schema.allOf.reduce((acc, schema) => {
@@ -131,6 +135,8 @@ function Visit(schema, references, value) {
     switch (schema_[index_4.Kind]) {
         case 'Array':
             return FromArray(schema_, references_, value);
+        case 'Date':
+            return FromDate(schema_, references_, value);
         case 'Intersect':
             return FromIntersect(schema_, references_, value);
         case 'Object':

package/build/cjs/value/guard/guard.d.ts

@@ -45,7 +45,9 @@ export declare function IsBigInt64Array(value: unknown): value is BigInt64Array;
 /** Returns true if the value is a BigUint64Array */
 export declare function IsBigUint64Array(value: unknown): value is BigUint64Array;
 /** Returns true if this value has this property key */
-export declare function HasPropertyKey<K extends PropertyKey>(value: Record<any, unknown>, key: K): value is ObjectType & Record<K, unknown>;
+export declare function HasPropertyKey<K extends PropertyKey>(value: Record<any, unknown>, key: K): value is Record<PropertyKey, unknown> & {
+    [_ in K]: unknown;
+};
 /** Returns true of this value is an object type */
 export declare function IsObject(value: unknown): value is ObjectType;
 /** Returns true if this value is an array, but not a typed array */

package/build/cjs/value/guard/guard.js

@@ -129,12 +129,15 @@ function IsBigUint64Array(value) {
     return value instanceof globalThis.BigUint64Array;
 }
 // --------------------------------------------------------------------------
-// Standard
+// PropertyKey
 // --------------------------------------------------------------------------
 /** Returns true if this value has this property key */
 function HasPropertyKey(value, key) {
     return key in value;
 }
+// --------------------------------------------------------------------------
+// Standard
+// --------------------------------------------------------------------------
 /** Returns true of this value is an object type */
 function IsObject(value) {
     return value !== null && typeof value === 'object';

package/build/esm/errors/errors.d.mts

@@ -72,6 +72,7 @@ export interface ValueError {
     path: string;
     value: unknown;
     message: string;
+    errors: ValueErrorIterator[];
 }
 export declare class ValueErrorsUnknownTypeError extends TypeBoxError {
     readonly schema: TSchema;

package/build/esm/errors/errors.mjs

@@ -6,6 +6,7 @@ import { GetErrorFunction } from './function.mjs';
 import { TypeBoxError } from '../type/error/index.mjs';
 import { Deref } from '../value/deref/index.mjs';
 import { Hash } from '../value/hash/index.mjs';
+import { Check } from '../value/check/index.mjs';
 import { Kind } from '../type/symbols/index.mjs';
 import { Never } from '../type/never/index.mjs';
 // ------------------------------------------------------------------
@@ -123,8 +124,15 @@ export class ValueErrorIterator {
 // --------------------------------------------------------------------------
 // Create
 // --------------------------------------------------------------------------
-function Create(errorType, schema, path, value) {
-    return { type: errorType, schema, path, value, message: GetErrorFunction()({ errorType, path, schema, value }) };
+function Create(errorType, schema, path, value, errors = []) {
+    return {
+        type: errorType,
+        schema,
+        path,
+        value,
+        message: GetErrorFunction()({ errorType, path, schema, value, errors }),
+        errors,
+    };
 }
 // --------------------------------------------------------------------------
 // Types
@@ -470,16 +478,10 @@ function* FromUndefined(schema, references, path, value) {
         yield Create(ValueErrorType.Undefined, schema, path, value);
 }
 function* FromUnion(schema, references, path, value) {
-    let count = 0;
-    for (const subschema of schema.anyOf) {
-        const errors = [...Visit(subschema, references, path, value)];
-        if (errors.length === 0)
-            return; // matched
-        count += errors.length;
-    }
-    if (count > 0) {
-        yield Create(ValueErrorType.Union, schema, path, value);
-    }
+    if (Check(schema, references, value))
+        return;
+    const errors = schema.anyOf.map((variant) => new ValueErrorIterator(Visit(variant, references, path, value)));
+    yield Create(ValueErrorType.Union, schema, path, value, errors);
 }
 function* FromUint8Array(schema, references, path, value) {
     if (!IsUint8Array(value))

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

@@ -1,5 +1,5 @@
 import { TSchema } from '../type/schema/index.mjs';
-import { ValueErrorType } from './errors.mjs';
+import { ValueErrorIterator, ValueErrorType } from './errors.mjs';
 /** Creates an error message using en-US as the default locale */
 export declare function DefaultErrorFunction(error: ErrorFunctionParameter): string;
 export type ErrorFunctionParameter = {
@@ -11,6 +11,8 @@ export type ErrorFunctionParameter = {
     schema: TSchema;
     /** The value associated with the error */
     value: unknown;
+    /** Interior errors for this error */
+    errors: ValueErrorIterator[];
 };
 export type ErrorFunction = (parameter: ErrorFunctionParameter) => string;
 /** Sets the error function used to generate error messages. */

package/build/esm/type/guard/value.d.mts

@@ -1,3 +1,7 @@
+/** Returns true if this value has this property key */
+export declare function HasPropertyKey<K extends PropertyKey>(value: Record<any, unknown>, key: K): value is Record<PropertyKey, unknown> & {
+    [_ in K]: unknown;
+};
 /** Returns true if this value is an async iterator */
 export declare function IsAsyncIterator(value: unknown): value is AsyncIterableIterator<unknown>;
 /** Returns true if this value is an array */

package/build/esm/type/guard/value.mjs

@@ -1,4 +1,11 @@
 // --------------------------------------------------------------------------
+// PropertyKey
+// --------------------------------------------------------------------------
+/** Returns true if this value has this property key */
+export function HasPropertyKey(value, key) {
+    return key in value;
+}
+// --------------------------------------------------------------------------
 // Object Instances
 // --------------------------------------------------------------------------
 /** Returns true if this value is an async iterator */

package/build/esm/value/default/default.mjs

@@ -5,7 +5,7 @@ import { Kind } from '../../type/symbols/index.mjs';
 // ------------------------------------------------------------------
 // ValueGuard
 // ------------------------------------------------------------------
-import { IsFunction, IsObject, IsArray, IsUndefined, HasPropertyKey } from '../guard/index.mjs';
+import { IsArray, IsDate, IsFunction, IsObject, IsUndefined, HasPropertyKey } from '../guard/index.mjs';
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
@@ -36,6 +36,10 @@ function FromArray(schema, references, value) {
     }
     return defaulted;
 }
+function FromDate(schema, references, value) {
+    // special case intercept for dates
+    return IsDate(value) ? value : ValueOrDefault(schema, value);
+}
 function FromIntersect(schema, references, value) {
     const defaulted = ValueOrDefault(schema, value);
     return schema.allOf.reduce((acc, schema) => {
@@ -127,6 +131,8 @@ function Visit(schema, references, value) {
     switch (schema_[Kind]) {
         case 'Array':
             return FromArray(schema_, references_, value);
+        case 'Date':
+            return FromDate(schema_, references_, value);
         case 'Intersect':
             return FromIntersect(schema_, references_, value);
         case 'Object':

package/build/esm/value/guard/guard.d.mts

@@ -45,7 +45,9 @@ export declare function IsBigInt64Array(value: unknown): value is BigInt64Array;
 /** Returns true if the value is a BigUint64Array */
 export declare function IsBigUint64Array(value: unknown): value is BigUint64Array;
 /** Returns true if this value has this property key */
-export declare function HasPropertyKey<K extends PropertyKey>(value: Record<any, unknown>, key: K): value is ObjectType & Record<K, unknown>;
+export declare function HasPropertyKey<K extends PropertyKey>(value: Record<any, unknown>, key: K): value is Record<PropertyKey, unknown> & {
+    [_ in K]: unknown;
+};
 /** Returns true of this value is an object type */
 export declare function IsObject(value: unknown): value is ObjectType;
 /** Returns true if this value is an array, but not a typed array */

package/build/esm/value/guard/guard.mjs

@@ -92,12 +92,15 @@ export function IsBigUint64Array(value) {
     return value instanceof globalThis.BigUint64Array;
 }
 // --------------------------------------------------------------------------
-// Standard
+// PropertyKey
 // --------------------------------------------------------------------------
 /** Returns true if this value has this property key */
 export function HasPropertyKey(value, key) {
     return key in value;
 }
+// --------------------------------------------------------------------------
+// Standard
+// --------------------------------------------------------------------------
 /** Returns true of this value is an object type */
 export function IsObject(value) {
     return value !== null && typeof value === 'object';

package/package.json

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