@sinclair/typebox 0.32.15 → 0.32.16

package/build/import/system/system.d.mts

@@ -8,7 +8,7 @@ export declare class TypeSystemDuplicateFormat extends TypeBoxError {
 /** Creates user defined types and formats and provides overrides for value checking behaviours */
 export declare namespace TypeSystem {
     /** Creates a new type */
-    function Type<Type, Options = Record<PropertyKey, unknown>>(kind: string, check: (options: Options, value: unknown) => boolean): (options?: Partial<Options>) => import("../type/unsafe/unsafe.mjs").TUnsafe<Type>;
+    function Type<Type, Options = Record<PropertyKey, unknown>>(kind: string, check: (options: Options, value: unknown) => boolean): (options?: Partial<Options>) => import("src/type/unsafe/unsafe.mjs").TUnsafe<Type>;
     /** Creates a new string format */
     function Format<F extends string>(format: F, check: (value: string) => boolean): F;
 }

package/build/import/type/indexed/indexed.d.mts

@@ -16,7 +16,7 @@ import { type TIndexFromMappedResult } from './indexed-from-mapped-result.mjs';
 type TFromRest<T extends TSchema[], K extends PropertyKey, Acc extends TSchema[] = []> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? TFromRest<R, K, [...Acc, Assert<TIndexFromPropertyKey<L, K>, TSchema>]> : Acc);
 type TFromIntersectRest<T extends TSchema[], Acc extends TSchema[] = []> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? L extends TNever ? TFromIntersectRest<R, [...Acc]> : TFromIntersectRest<R, [...Acc, L]> : Acc);
 type TFromIntersect<T extends TSchema[], K extends PropertyKey> = (TIntersectEvaluated<TFromIntersectRest<TFromRest<T, K>>>);
-type TFromUnionRest<T extends TSchema[]> = T;
+type TFromUnionRest<T extends TSchema[], Acc extends TSchema[] = []> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? L extends TNever ? [] : TFromUnionRest<R, [L, ...Acc]> : Acc;
 type TFromUnion<T extends TSchema[], K extends PropertyKey> = (TUnionEvaluated<TFromUnionRest<TFromRest<T, K>>>);
 type TFromTuple<T extends TSchema[], K extends PropertyKey> = (K extends keyof T ? T[K] : K extends '[number]' ? TUnionEvaluated<T> : TNever);
 type TFromArray<T extends TSchema, K extends PropertyKey> = (K extends '[number]' ? T : TNever);

package/build/import/type/indexed/indexed.mjs

@@ -23,7 +23,9 @@ function FromIntersect(T, K) {
 }
 // prettier-ignore
 function FromUnionRest(T) {
-    return T; // review this
+    return (T.some(L => IsNever(L))
+        ? []
+        : T);
 }
 // prettier-ignore
 function FromUnion(T, K) {

package/build/import/type/template-literal/parse.mjs

@@ -4,23 +4,42 @@ import { TypeBoxError } from '../error/index.mjs';
 // ------------------------------------------------------------------
 export class TemplateLiteralParserError extends TypeBoxError {
 }
+// -------------------------------------------------------------------
+// Unescape
+//
+// Unescape for these control characters specifically. Note that this
+// function is only called on non union group content, and where we
+// still want to allow the user to embed control characters in that
+// content. For review.
+// -------------------------------------------------------------------
 // prettier-ignore
+function Unescape(pattern) {
+    return pattern
+        .replace(/\\\$/g, '$')
+        .replace(/\\\*/g, '*')
+        .replace(/\\\^/g, '^')
+        .replace(/\\\|/g, '|')
+        .replace(/\\\(/g, '(')
+        .replace(/\\\)/g, ')');
+}
+// -------------------------------------------------------------------
+// Control Characters
+// -------------------------------------------------------------------
 function IsNonEscaped(pattern, index, char) {
     return pattern[index] === char && pattern.charCodeAt(index - 1) !== 92;
 }
-// prettier-ignore
 function IsOpenParen(pattern, index) {
     return IsNonEscaped(pattern, index, '(');
 }
-// prettier-ignore
 function IsCloseParen(pattern, index) {
     return IsNonEscaped(pattern, index, ')');
 }
-// prettier-ignore
 function IsSeparator(pattern, index) {
     return IsNonEscaped(pattern, index, '|');
 }
-// prettier-ignore
+// -------------------------------------------------------------------
+// Control Groups
+// -------------------------------------------------------------------
 function IsGroup(pattern) {
     if (!(IsOpenParen(pattern, 0) && IsCloseParen(pattern, pattern.length - 1)))
         return false;
@@ -137,7 +156,7 @@ export function TemplateLiteralParse(pattern) {
     return (IsGroup(pattern) ? TemplateLiteralParse(InGroup(pattern)) :
         IsPrecedenceOr(pattern) ? Or(pattern) :
             IsPrecedenceAnd(pattern) ? And(pattern) :
-                { type: 'const', const: pattern });
+                { type: 'const', const: Unescape(pattern) });
 }
 // ------------------------------------------------------------------
 // TemplateLiteralParseExact

package/build/import/type/template-literal/syntax.d.mts

@@ -12,7 +12,7 @@ type FromUnionLiteral<T extends string> = T extends `${infer L}|${infer R}` ? [T
 ];
 type FromUnion<T extends string> = TUnionEvaluated<FromUnionLiteral<T>>;
 type FromTerminal<T extends string> = T extends 'boolean' ? TBoolean : T extends 'bigint' ? TBigInt : T extends 'number' ? TNumber : T extends 'string' ? TString : FromUnion<T>;
-type FromString<T extends string> = T extends `{${infer L}}${infer R}` ? [FromTerminal<L>, ...FromString<R>] : T extends `${infer L}$${infer R}` ? [TLiteral<L>, ...FromString<R>] : T extends `${infer L}` ? [TLiteral<L>] : [
+type FromString<T extends string> = T extends `{${infer L}}${infer R}` ? [FromTerminal<L>, ...FromString<R>] : T extends `${infer L}$\{${infer R1}\}${infer R2}` ? [TLiteral<L>, ...FromString<`{${R1}}`>, ...FromString<R2>] : T extends `${infer L}$\{${infer R1}\}` ? [TLiteral<L>, ...FromString<`{${R1}}`>] : T extends `${infer L}` ? [TLiteral<L>] : [
 ];
 export type TTemplateLiteralSyntax<T extends string> = (TTemplateLiteral<Assert<FromString<T>, TTemplateLiteralKind[]>>);
 /** Parses TemplateLiteralSyntax and returns a tuple of TemplateLiteralKinds */

package/build/import/value/convert/convert.mjs

@@ -1,9 +1,6 @@
 import { Clone } from '../clone/index.mjs';
-import { Check } from '../check/index.mjs';
 import { Deref } from '../deref/index.mjs';
-import { IsObject as IsObjectType } from '../../type/guard/type.mjs';
 import { Kind } from '../../type/symbols/index.mjs';
-import { Composite } from '../../type/composite/index.mjs';
 // ------------------------------------------------------------------
 // ValueGuard
 // ------------------------------------------------------------------
@@ -129,12 +126,8 @@ function FromDate(schema, references, value) {
 function FromInteger(schema, references, value) {
     return TryConvertInteger(value);
 }
-// prettier-ignore
 function FromIntersect(schema, references, value) {
-    const allObjects = schema.allOf.every(schema => IsObjectType(schema));
-    if (allObjects)
-        return Visit(Composite(schema.allOf), references, value);
-    return Visit(schema.allOf[0], references, value); // todo: fix this
+    return schema.allOf.reduce((value, schema) => Visit(schema, references, value), value);
 }
 function FromLiteral(schema, references, value) {
     return TryConvertLiteral(schema, value);
@@ -192,13 +185,7 @@ function FromUndefined(schema, references, value) {
     return TryConvertUndefined(value);
 }
 function FromUnion(schema, references, value) {
-    for (const subschema of schema.anyOf) {
-        const converted = Visit(subschema, references, value);
-        if (Check(subschema, references, converted)) {
-            return converted;
-        }
-    }
-    return value;
+    return schema.anyOf.reduce((value, schema) => Visit(schema, references, value), value);
 }
 function Visit(schema, references, value) {
     const references_ = IsString(schema.$id) ? [...references, schema] : references;

package/build/import/value/delta/delta.d.mts

@@ -1,34 +1,34 @@
 import type { Static } from '../../type/static/index.mjs';
 import { TypeBoxError } from '../../type/error/index.mjs';
 export type Insert = Static<typeof Insert>;
-export declare const Insert: import("../../type/object/object.mjs").TObject<{
-    type: import("../../type/literal/literal.mjs").TLiteral<"insert">;
-    path: import("../../type/string/string.mjs").TString;
-    value: import("../../type/unknown/unknown.mjs").TUnknown;
+export declare const Insert: import("src/type/object/object.mjs").TObject<{
+    type: import("src/type/literal/literal.mjs").TLiteral<"insert">;
+    path: import("src/type/string/string.mjs").TString;
+    value: import("src/type/unknown/unknown.mjs").TUnknown;
 }>;
 export type Update = Static<typeof Update>;
-export declare const Update: import("../../type/object/object.mjs").TObject<{
-    type: import("../../type/literal/literal.mjs").TLiteral<"update">;
-    path: import("../../type/string/string.mjs").TString;
-    value: import("../../type/unknown/unknown.mjs").TUnknown;
+export declare const Update: import("src/type/object/object.mjs").TObject<{
+    type: import("src/type/literal/literal.mjs").TLiteral<"update">;
+    path: import("src/type/string/string.mjs").TString;
+    value: import("src/type/unknown/unknown.mjs").TUnknown;
 }>;
 export type Delete = Static<typeof Delete>;
-export declare const Delete: import("../../type/object/object.mjs").TObject<{
-    type: import("../../type/literal/literal.mjs").TLiteral<"delete">;
-    path: import("../../type/string/string.mjs").TString;
+export declare const Delete: import("src/type/object/object.mjs").TObject<{
+    type: import("src/type/literal/literal.mjs").TLiteral<"delete">;
+    path: import("src/type/string/string.mjs").TString;
 }>;
 export type Edit = Static<typeof Edit>;
-export declare const Edit: import("../../type/union/union-type.mjs").TUnion<[import("../../type/object/object.mjs").TObject<{
-    type: import("../../type/literal/literal.mjs").TLiteral<"insert">;
-    path: import("../../type/string/string.mjs").TString;
-    value: import("../../type/unknown/unknown.mjs").TUnknown;
-}>, import("../../type/object/object.mjs").TObject<{
-    type: import("../../type/literal/literal.mjs").TLiteral<"update">;
-    path: import("../../type/string/string.mjs").TString;
-    value: import("../../type/unknown/unknown.mjs").TUnknown;
-}>, import("../../type/object/object.mjs").TObject<{
-    type: import("../../type/literal/literal.mjs").TLiteral<"delete">;
-    path: import("../../type/string/string.mjs").TString;
+export declare const Edit: import("src/type/union/union-type.mjs").TUnion<[import("src/type/object/object.mjs").TObject<{
+    type: import("src/type/literal/literal.mjs").TLiteral<"insert">;
+    path: import("src/type/string/string.mjs").TString;
+    value: import("src/type/unknown/unknown.mjs").TUnknown;
+}>, import("src/type/object/object.mjs").TObject<{
+    type: import("src/type/literal/literal.mjs").TLiteral<"update">;
+    path: import("src/type/string/string.mjs").TString;
+    value: import("src/type/unknown/unknown.mjs").TUnknown;
+}>, import("src/type/object/object.mjs").TObject<{
+    type: import("src/type/literal/literal.mjs").TLiteral<"delete">;
+    path: import("src/type/string/string.mjs").TString;
 }>]>;
 export declare class ValueDeltaError extends TypeBoxError {
     readonly value: unknown;

package/build/import/value/transform/decode.d.mts

@@ -9,8 +9,10 @@ export declare class TransformDecodeCheckError extends TypeBoxError {
 }
 export declare class TransformDecodeError extends TypeBoxError {
     readonly schema: TSchema;
+    readonly path: string;
     readonly value: unknown;
-    constructor(schema: TSchema, value: unknown, error: any);
+    readonly error: Error;
+    constructor(schema: TSchema, path: string, value: unknown, error: Error);
 }
 /**
  * `[Internal]` Decodes the value and returns the result. This function requires that

package/build/import/value/transform/decode.mjs

@@ -16,168 +16,174 @@ import { IsTransform, IsSchema } from '../../type/guard/type.mjs';
 // Errors
 // ------------------------------------------------------------------
 // thrown externally
+// prettier-ignore
 export class TransformDecodeCheckError extends TypeBoxError {
     schema;
     value;
     error;
     constructor(schema, value, error) {
-        super(`Unable to decode due to invalid value`);
+        super(`Unable to decode value as it does not match the expected schema`);
         this.schema = schema;
         this.value = value;
         this.error = error;
     }
 }
+// prettier-ignore
 export class TransformDecodeError extends TypeBoxError {
     schema;
+    path;
     value;
-    constructor(schema, value, error) {
-        super(`${error instanceof Error ? error.message : 'Unknown error'}`);
+    error;
+    constructor(schema, path, value, error) {
+        super(error instanceof Error ? error.message : 'Unknown error');
         this.schema = schema;
+        this.path = path;
         this.value = value;
+        this.error = error;
     }
 }
 // ------------------------------------------------------------------
 // Decode
 // ------------------------------------------------------------------
 // prettier-ignore
-function Default(schema, value) {
+function Default(schema, path, value) {
     try {
         return IsTransform(schema) ? schema[TransformKind].Decode(value) : value;
     }
     catch (error) {
-        throw new TransformDecodeError(schema, value, error);
+        throw new TransformDecodeError(schema, path, value, error);
     }
 }
 // prettier-ignore
-function FromArray(schema, references, value) {
+function FromArray(schema, references, path, value) {
     return (IsArray(value))
-        ? Default(schema, value.map((value) => Visit(schema.items, references, value)))
-        : Default(schema, value);
+        ? Default(schema, path, value.map((value, index) => Visit(schema.items, references, `${path}/${index}`, value)))
+        : Default(schema, path, value);
 }
 // prettier-ignore
-function FromIntersect(schema, references, value) {
+function FromIntersect(schema, references, path, value) {
     if (!IsStandardObject(value) || IsValueType(value))
-        return Default(schema, value);
+        return Default(schema, path, value);
     const knownKeys = KeyOfPropertyKeys(schema);
     const knownProperties = knownKeys.reduce((value, key) => {
         return (key in value)
-            ? { ...value, [key]: Visit(Index(schema, [key]), references, value[key]) }
+            ? { ...value, [key]: Visit(Index(schema, [key]), references, `${path}/${key}`, value[key]) }
             : value;
     }, value);
     if (!IsTransform(schema.unevaluatedProperties)) {
-        return Default(schema, knownProperties);
+        return Default(schema, path, knownProperties);
     }
     const unknownKeys = Object.getOwnPropertyNames(knownProperties);
     const unevaluatedProperties = schema.unevaluatedProperties;
     const unknownProperties = unknownKeys.reduce((value, key) => {
         return !knownKeys.includes(key)
-            ? { ...value, [key]: Default(unevaluatedProperties, value[key]) }
+            ? { ...value, [key]: Default(unevaluatedProperties, `${path}/${key}`, value[key]) }
             : value;
     }, knownProperties);
-    return Default(schema, unknownProperties);
+    return Default(schema, path, unknownProperties);
 }
-function FromNot(schema, references, value) {
-    return Default(schema, Visit(schema.not, references, value));
+function FromNot(schema, references, path, value) {
+    return Default(schema, path, Visit(schema.not, references, path, value));
 }
 // prettier-ignore
-function FromObject(schema, references, value) {
+function FromObject(schema, references, path, value) {
     if (!IsStandardObject(value))
-        return Default(schema, value);
+        return Default(schema, path, value);
     const knownKeys = KeyOfPropertyKeys(schema);
     const knownProperties = knownKeys.reduce((value, key) => {
         return (key in value)
-            ? { ...value, [key]: Visit(schema.properties[key], references, value[key]) }
+            ? { ...value, [key]: Visit(schema.properties[key], references, `${path}/${key}`, value[key]) }
             : value;
     }, value);
     if (!IsSchema(schema.additionalProperties)) {
-        return Default(schema, knownProperties);
+        return Default(schema, path, knownProperties);
     }
     const unknownKeys = Object.getOwnPropertyNames(knownProperties);
     const additionalProperties = schema.additionalProperties;
     const unknownProperties = unknownKeys.reduce((value, key) => {
         return !knownKeys.includes(key)
-            ? { ...value, [key]: Default(additionalProperties, value[key]) }
+            ? { ...value, [key]: Default(additionalProperties, `${path}/${key}`, value[key]) }
             : value;
     }, knownProperties);
-    return Default(schema, unknownProperties);
+    return Default(schema, path, unknownProperties);
 }
 // prettier-ignore
-function FromRecord(schema, references, value) {
+function FromRecord(schema, references, path, value) {
     if (!IsStandardObject(value))
-        return Default(schema, value);
+        return Default(schema, path, value);
     const pattern = Object.getOwnPropertyNames(schema.patternProperties)[0];
     const knownKeys = new RegExp(pattern);
     const knownProperties = Object.getOwnPropertyNames(value).reduce((value, key) => {
         return knownKeys.test(key)
-            ? { ...value, [key]: Visit(schema.patternProperties[pattern], references, value[key]) }
+            ? { ...value, [key]: Visit(schema.patternProperties[pattern], references, `${path}/${key}`, value[key]) }
             : value;
     }, value);
     if (!IsSchema(schema.additionalProperties)) {
-        return Default(schema, knownProperties);
+        return Default(schema, path, knownProperties);
     }
     const unknownKeys = Object.getOwnPropertyNames(knownProperties);
     const additionalProperties = schema.additionalProperties;
     const unknownProperties = unknownKeys.reduce((value, key) => {
         return !knownKeys.test(key)
-            ? { ...value, [key]: Default(additionalProperties, value[key]) }
+            ? { ...value, [key]: Default(additionalProperties, `${path}/${key}`, value[key]) }
             : value;
     }, knownProperties);
-    return Default(schema, unknownProperties);
+    return Default(schema, path, unknownProperties);
 }
 // prettier-ignore
-function FromRef(schema, references, value) {
+function FromRef(schema, references, path, value) {
     const target = Deref(schema, references);
-    return Default(schema, Visit(target, references, value));
+    return Default(schema, path, Visit(target, references, path, value));
 }
 // prettier-ignore
-function FromThis(schema, references, value) {
+function FromThis(schema, references, path, value) {
     const target = Deref(schema, references);
-    return Default(schema, Visit(target, references, value));
+    return Default(schema, path, Visit(target, references, path, value));
 }
 // prettier-ignore
-function FromTuple(schema, references, value) {
+function FromTuple(schema, references, path, value) {
     return (IsArray(value) && IsArray(schema.items))
-        ? Default(schema, schema.items.map((schema, index) => Visit(schema, references, value[index])))
-        : Default(schema, value);
+        ? Default(schema, path, schema.items.map((schema, index) => Visit(schema, references, `${path}/${index}`, value[index])))
+        : Default(schema, path, value);
 }
 // prettier-ignore
-function FromUnion(schema, references, value) {
+function FromUnion(schema, references, path, value) {
     for (const subschema of schema.anyOf) {
         if (!Check(subschema, references, value))
             continue;
         // note: ensure interior is decoded first
-        const decoded = Visit(subschema, references, value);
-        return Default(schema, decoded);
+        const decoded = Visit(subschema, references, path, value);
+        return Default(schema, path, decoded);
     }
-    return Default(schema, value);
+    return Default(schema, path, value);
 }
 // prettier-ignore
-function Visit(schema, references, value) {
+function Visit(schema, references, path, value) {
     const references_ = typeof schema.$id === 'string' ? [...references, schema] : references;
     const schema_ = schema;
     switch (schema[Kind]) {
         case 'Array':
-            return FromArray(schema_, references_, value);
+            return FromArray(schema_, references_, path, value);
         case 'Intersect':
-            return FromIntersect(schema_, references_, value);
+            return FromIntersect(schema_, references_, path, value);
         case 'Not':
-            return FromNot(schema_, references_, value);
+            return FromNot(schema_, references_, path, value);
         case 'Object':
-            return FromObject(schema_, references_, value);
+            return FromObject(schema_, references_, path, value);
         case 'Record':
-            return FromRecord(schema_, references_, value);
+            return FromRecord(schema_, references_, path, value);
         case 'Ref':
-            return FromRef(schema_, references_, value);
+            return FromRef(schema_, references_, path, value);
         case 'Symbol':
-            return Default(schema_, value);
+            return Default(schema_, path, value);
         case 'This':
-            return FromThis(schema_, references_, value);
+            return FromThis(schema_, references_, path, value);
         case 'Tuple':
-            return FromTuple(schema_, references_, value);
+            return FromTuple(schema_, references_, path, value);
         case 'Union':
-            return FromUnion(schema_, references_, value);
+            return FromUnion(schema_, references_, path, value);
         default:
-            return Default(schema_, value);
+            return Default(schema_, path, value);
     }
 }
 /**
@@ -186,5 +192,5 @@ function Visit(schema, references, value) {
  * undefined behavior. Refer to the `Value.Decode()` for implementation details.
  */
 export function TransformDecode(schema, references, value) {
-    return Visit(schema, references, value);
+    return Visit(schema, references, '', value);
 }

package/build/import/value/transform/encode.d.mts

@@ -9,8 +9,10 @@ export declare class TransformEncodeCheckError extends TypeBoxError {
 }
 export declare class TransformEncodeError extends TypeBoxError {
     readonly schema: TSchema;
+    readonly path: string;
     readonly value: unknown;
-    constructor(schema: TSchema, value: unknown, error: any);
+    readonly error: Error;
+    constructor(schema: TSchema, path: string, value: unknown, error: Error);
 }
 /**
  * `[Internal]` Encodes the value and returns the result. This function expects the