@sinclair/typebox 0.32.0-dev-27 → 0.32.0

package/build/require/value/create/create.js

@@ -1,7 +1,7 @@
 "use strict";
 
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Create = exports.ValueCreateRecursiveInstantiationError = exports.ValueCreateTempateLiteralTypeError = exports.ValueCreateIntersectTypeError = exports.ValueCreateNotTypeError = exports.ValueCreateNeverTypeError = exports.ValueCreateUnknownTypeError = void 0;
+exports.Create = exports.ValueCreateError = void 0;
 const index_1 = require("../guard/index");
 const index_2 = require("../check/index");
 const index_3 = require("../deref/index");
@@ -13,49 +13,13 @@ const index_8 = require("../../type/error/index");
 // ------------------------------------------------------------------
 // Errors
 // ------------------------------------------------------------------
-class ValueCreateUnknownTypeError extends index_8.TypeBoxError {
-    constructor(schema) {
-        super('Unknown type');
+class ValueCreateError extends index_8.TypeBoxError {
+    constructor(schema, message) {
+        super(message);
         this.schema = schema;
     }
 }
-exports.ValueCreateUnknownTypeError = ValueCreateUnknownTypeError;
-class ValueCreateNeverTypeError extends index_8.TypeBoxError {
-    constructor(schema) {
-        super('Never types cannot be created');
-        this.schema = schema;
-    }
-}
-exports.ValueCreateNeverTypeError = ValueCreateNeverTypeError;
-class ValueCreateNotTypeError extends index_8.TypeBoxError {
-    constructor(schema) {
-        super('Not types must have a default value');
-        this.schema = schema;
-    }
-}
-exports.ValueCreateNotTypeError = ValueCreateNotTypeError;
-class ValueCreateIntersectTypeError extends index_8.TypeBoxError {
-    constructor(schema) {
-        super('Intersect produced invalid value. Consider using a default value.');
-        this.schema = schema;
-    }
-}
-exports.ValueCreateIntersectTypeError = ValueCreateIntersectTypeError;
-class ValueCreateTempateLiteralTypeError extends index_8.TypeBoxError {
-    constructor(schema) {
-        super('Can only create template literal values from patterns that produce finite sequences. Consider using a default value.');
-        this.schema = schema;
-    }
-}
-exports.ValueCreateTempateLiteralTypeError = ValueCreateTempateLiteralTypeError;
-class ValueCreateRecursiveInstantiationError extends index_8.TypeBoxError {
-    constructor(schema, recursiveMaxDepth) {
-        super('Value cannot be created as recursive type may produce value of infinite size. Consider using a default.');
-        this.schema = schema;
-        this.recursiveMaxDepth = recursiveMaxDepth;
-    }
-}
-exports.ValueCreateRecursiveInstantiationError = ValueCreateRecursiveInstantiationError;
+exports.ValueCreateError = ValueCreateError;
 // ------------------------------------------------------------------
 // Create
 // ------------------------------------------------------------------
@@ -69,10 +33,10 @@ function FromAny(schema, references) {
 }
 function FromArray(schema, references) {
     if (schema.uniqueItems === true && !(0, index_1.HasPropertyKey)(schema, 'default')) {
-        throw new Error('ValueCreate.Array: Array with the uniqueItems constraint requires a default value');
+        throw new ValueCreateError(schema, 'Array with the uniqueItems constraint requires a default value');
     }
     else if ('contains' in schema && !(0, index_1.HasPropertyKey)(schema, 'default')) {
-        throw new Error('ValueCreate.Array: Array with the contains constraint requires a default value');
+        throw new ValueCreateError(schema, 'Array with the contains constraint requires a default value');
     }
     else if ('default' in schema) {
         return schema.default;
@@ -179,7 +143,7 @@ function FromIntersect(schema, references) {
             return typeof next === 'object' ? { ...acc, ...next } : next;
         }, {});
         if (!(0, index_2.Check)(schema, references, value))
-            throw new ValueCreateIntersectTypeError(schema);
+            throw new ValueCreateError(schema, 'Intersect produced invalid value. Consider using a default value.');
         return value;
     }
 }
@@ -200,14 +164,19 @@ function FromLiteral(schema, references) {
     }
 }
 function FromNever(schema, references) {
-    throw new ValueCreateNeverTypeError(schema);
+    if ((0, index_1.HasPropertyKey)(schema, 'default')) {
+        return schema.default;
+    }
+    else {
+        throw new ValueCreateError(schema, 'Never types cannot be created. Consider using a default value.');
+    }
 }
 function FromNot(schema, references) {
     if ((0, index_1.HasPropertyKey)(schema, 'default')) {
         return schema.default;
     }
     else {
-        throw new ValueCreateNotTypeError(schema);
+        throw new ValueCreateError(schema, 'Not types must have a default value');
     }
 }
 function FromNull(schema, references) {
@@ -272,10 +241,18 @@ function FromRef(schema, references) {
         return Visit((0, index_3.Deref)(schema, references), references);
     }
 }
+function FromRegExp(schema, references) {
+    if ((0, index_1.HasPropertyKey)(schema, 'default')) {
+        return schema.default;
+    }
+    else {
+        throw new ValueCreateError(schema, 'RegExp types cannot be created. Consider using a default value.');
+    }
+}
 function FromString(schema, references) {
     if (schema.pattern !== undefined) {
         if (!(0, index_1.HasPropertyKey)(schema, 'default')) {
-            throw new Error('ValueCreate.String: String types with patterns must specify a default value');
+            throw new ValueCreateError(schema, 'String types with patterns must specify a default value');
         }
         else {
             return schema.default;
@@ -283,7 +260,7 @@ function FromString(schema, references) {
     }
     else if (schema.format !== undefined) {
         if (!(0, index_1.HasPropertyKey)(schema, 'default')) {
-            throw new Error('ValueCreate.String: String types with formats must specify a default value');
+            throw new ValueCreateError(schema, 'String types with formats must specify a default value');
         }
         else {
             return schema.default;
@@ -294,9 +271,8 @@ function FromString(schema, references) {
             return schema.default;
         }
         else if (schema.minLength !== undefined) {
-            return Array.from({ length: schema.minLength })
-                .map(() => '.')
-                .join('');
+            // prettier-ignore
+            return Array.from({ length: schema.minLength }).map(() => ' ').join('');
         }
         else {
             return '';
@@ -319,13 +295,13 @@ function FromTemplateLiteral(schema, references) {
         return schema.default;
     }
     if (!(0, index_4.IsTemplateLiteralFinite)(schema))
-        throw new ValueCreateTempateLiteralTypeError(schema);
+        throw new ValueCreateError(schema, 'Can only create template literals that produce a finite variants. Consider using a default value.');
     const generated = (0, index_4.TemplateLiteralGenerate)(schema);
     return generated[0];
 }
 function FromThis(schema, references) {
     if (recursiveDepth++ > recursiveMaxDepth)
-        throw new ValueCreateRecursiveInstantiationError(schema, recursiveMaxDepth);
+        throw new ValueCreateError(schema, 'Cannot create recursive type as it appears possibly infinite. Consider using a default.');
     if ((0, index_1.HasPropertyKey)(schema, 'default')) {
         return schema.default;
     }
@@ -442,6 +418,8 @@ function Visit(schema, references) {
             return FromRecord(schema_, references_);
         case 'Ref':
             return FromRef(schema_, references_);
+        case 'RegExp':
+            return FromRegExp(schema_, references_);
         case 'String':
             return FromString(schema_, references_);
         case 'Symbol':
@@ -464,7 +442,7 @@ function Visit(schema, references) {
             return FromVoid(schema_, references_);
         default:
             if (!index_6.TypeRegistry.Has(schema_[index_7.Kind]))
-                throw new ValueCreateUnknownTypeError(schema_);
+                throw new ValueCreateError(schema_, 'Unknown type');
             return FromKind(schema_, references_);
     }
 }

package/build/require/value/default/default.js

@@ -8,12 +8,10 @@ const index_3 = require("../../type/symbols/index");
 // ------------------------------------------------------------------
 // ValueGuard
 // ------------------------------------------------------------------
-// prettier-ignore
 const index_4 = require("../guard/index");
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-// prettier-ignore
 const type_1 = require("../../type/guard/type");
 // ------------------------------------------------------------------
 // ValueOrDefault

package/build/require/value/delta/delta.d.ts

@@ -30,11 +30,11 @@ export declare const Edit: import("../../type/union/union-type").TUnion<[import(
     type: import("../../type/literal/literal").TLiteral<"delete">;
     path: import("../../type/string/string").TString;
 }>]>;
-export declare class ValueDeltaObjectWithSymbolKeyError extends TypeBoxError {
-    readonly key: unknown;
-    constructor(key: unknown);
+export declare class ValueDeltaError extends TypeBoxError {
+    readonly value: unknown;
+    constructor(value: unknown, message: string);
 }
-export declare class ValueDeltaUnableToDiffUnknownValue extends TypeBoxError {
+export declare class ValueDeltaSymbolError extends ValueDeltaError {
     readonly value: unknown;
     constructor(value: unknown);
 }

package/build/require/value/delta/delta.js

@@ -1,7 +1,7 @@
 "use strict";
 
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Patch = exports.Diff = exports.ValueDeltaUnableToDiffUnknownValue = exports.ValueDeltaObjectWithSymbolKeyError = exports.Edit = exports.Delete = exports.Update = exports.Insert = void 0;
+exports.Patch = exports.Diff = exports.ValueDeltaSymbolError = exports.ValueDeltaError = exports.Edit = exports.Delete = exports.Update = exports.Insert = void 0;
 const index_1 = require("../guard/index");
 const index_2 = require("../pointer/index");
 const index_3 = require("../clone/index");
@@ -29,20 +29,20 @@ exports.Edit = (0, index_9.Union)([exports.Insert, exports.Update, exports.Delet
 // ------------------------------------------------------------------
 // Errors
 // ------------------------------------------------------------------
-class ValueDeltaObjectWithSymbolKeyError extends index_4.TypeBoxError {
-    constructor(key) {
-        super('Cannot diff objects with symbol keys');
-        this.key = key;
+class ValueDeltaError extends index_4.TypeBoxError {
+    constructor(value, message) {
+        super(message);
+        this.value = value;
     }
 }
-exports.ValueDeltaObjectWithSymbolKeyError = ValueDeltaObjectWithSymbolKeyError;
-class ValueDeltaUnableToDiffUnknownValue extends index_4.TypeBoxError {
+exports.ValueDeltaError = ValueDeltaError;
+class ValueDeltaSymbolError extends ValueDeltaError {
     constructor(value) {
-        super('Unable to create diff edits for unknown value');
+        super(value, 'Cannot diff objects with symbol keys');
         this.value = value;
     }
 }
-exports.ValueDeltaUnableToDiffUnknownValue = ValueDeltaUnableToDiffUnknownValue;
+exports.ValueDeltaSymbolError = ValueDeltaSymbolError;
 // ------------------------------------------------------------------
 // Command Factory
 // ------------------------------------------------------------------
@@ -65,7 +65,7 @@ function* ObjectType(path, current, next) {
     const nextKeys = [...globalThis.Object.keys(next), ...globalThis.Object.getOwnPropertySymbols(next)];
     for (const key of currentKeys) {
         if ((0, index_1.IsSymbol)(key))
-            throw new ValueDeltaObjectWithSymbolKeyError(key);
+            throw new ValueDeltaSymbolError(key);
         if ((0, index_1.IsUndefined)(next[key]) && nextKeys.includes(key))
             yield CreateUpdate(`${path}/${globalThis.String(key)}`, undefined);
     }
@@ -73,18 +73,18 @@ function* ObjectType(path, current, next) {
         if ((0, index_1.IsUndefined)(current[key]) || (0, index_1.IsUndefined)(next[key]))
             continue;
         if ((0, index_1.IsSymbol)(key))
-            throw new ValueDeltaObjectWithSymbolKeyError(key);
+            throw new ValueDeltaSymbolError(key);
         yield* Visit(`${path}/${globalThis.String(key)}`, current[key], next[key]);
     }
     for (const key of nextKeys) {
         if ((0, index_1.IsSymbol)(key))
-            throw new ValueDeltaObjectWithSymbolKeyError(key);
+            throw new ValueDeltaSymbolError(key);
         if ((0, index_1.IsUndefined)(current[key]))
             yield CreateInsert(`${path}/${globalThis.String(key)}`, next[key]);
     }
     for (const key of currentKeys.reverse()) {
         if ((0, index_1.IsSymbol)(key))
-            throw new ValueDeltaObjectWithSymbolKeyError(key);
+            throw new ValueDeltaSymbolError(key);
         if ((0, index_1.IsUndefined)(next[key]) && !nextKeys.includes(key))
             yield CreateDelete(`${path}/${globalThis.String(key)}`);
     }
@@ -127,7 +127,7 @@ function* Visit(path, current, next) {
         return yield* TypedArrayType(path, current, next);
     if ((0, index_1.IsValueType)(current))
         return yield* ValueType(path, current, next);
-    throw new ValueDeltaUnableToDiffUnknownValue(current);
+    throw new ValueDeltaError(current, 'Unable to create diff edits for unknown value');
 }
 // ------------------------------------------------------------------
 // Diff

package/build/require/value/index.d.ts

@@ -1,16 +1,16 @@
 export { ValueError, ValueErrorType, ValueErrorIterator } from '../errors/index';
-export { Cast, ValueCastArrayUniqueItemsTypeError, ValueCastNeverTypeError, ValueCastRecursiveTypeError, ValueCastUnknownTypeError } from './cast/index';
+export { Cast, ValueCastError } from './cast/index';
 export { Check } from './check/index';
 export { Clean } from './clean/index';
 export { Clone } from './clone/index';
-export { Convert, ValueConvertUnknownTypeError } from './convert/index';
-export { Create, ValueCreateIntersectTypeError, ValueCreateNeverTypeError, ValueCreateNotTypeError, ValueCreateRecursiveInstantiationError, ValueCreateTempateLiteralTypeError, ValueCreateUnknownTypeError } from './create/index';
+export { Convert } from './convert/index';
+export { Create, ValueCreateError } from './create/index';
 export { Default } from './default/index';
-export { Diff, Patch, Edit, Delete, Insert, Update, ValueDeltaObjectWithSymbolKeyError, ValueDeltaUnableToDiffUnknownValue } from './delta/index';
+export { Diff, Patch, Edit, Delete, Insert, Update, ValueDeltaError } from './delta/index';
 export { Equal } from './equal/index';
 export { Hash, ValueHashError } from './hash/index';
-export { Mutate, type Mutable, ValueMutateInvalidRootMutationError, ValueMutateTypeMismatchError } from './mutate/index';
+export { Mutate, ValueMutateError, type Mutable } from './mutate/index';
 export { ValuePointer } from './pointer/index';
-export { TransformDecode as DecodeTransform, TransformEncode as EncodeTransform, HasTransform, TransformDecodeCheckError, TransformDecodeError, TransformEncodeCheckError, TransformEncodeError } from './transform/index';
-export { ArrayType, HasPropertyKey, IsArray, IsAsyncIterator, IsBigInt, IsBoolean, IsDate, IsFunction, IsInteger, IsIterator, IsNull, IsNumber, IsObject, IsPlainObject, IsPromise, IsString, IsSymbol, IsTypedArray, IsUint8Array, IsUndefined, IsValueType, ObjectType, TypedArrayType, ValueType, } from './guard/index';
+export { TransformDecode, TransformEncode, HasTransform, TransformDecodeCheckError, TransformDecodeError, TransformEncodeCheckError, TransformEncodeError } from './transform/index';
+export { ArrayType, HasPropertyKey, IsArray, IsAsyncIterator, IsBigInt, IsBoolean, IsDate, IsFunction, IsInteger, IsIterator, IsNull, IsNumber, IsObject, IsPlainObject, IsPromise, IsString, IsSymbol, IsTypedArray, IsUint8Array, IsUndefined, IsValueType, type ObjectType, type TypedArrayType, type ValueType, } from './guard/index';
 export { Value } from './value/index';

package/build/require/value/index.js

@@ -1,8 +1,8 @@
 "use strict";
 
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.IsInteger = exports.IsFunction = exports.IsDate = exports.IsBoolean = exports.IsBigInt = exports.IsAsyncIterator = exports.IsArray = exports.HasPropertyKey = exports.TransformEncodeError = exports.TransformEncodeCheckError = exports.TransformDecodeError = exports.TransformDecodeCheckError = exports.HasTransform = exports.EncodeTransform = exports.DecodeTransform = exports.ValuePointer = exports.ValueMutateTypeMismatchError = exports.ValueMutateInvalidRootMutationError = exports.Mutate = exports.ValueHashError = exports.Hash = exports.Equal = exports.ValueDeltaUnableToDiffUnknownValue = exports.ValueDeltaObjectWithSymbolKeyError = exports.Update = exports.Insert = exports.Delete = exports.Edit = exports.Patch = exports.Diff = exports.Default = exports.ValueCreateUnknownTypeError = exports.ValueCreateTempateLiteralTypeError = exports.ValueCreateRecursiveInstantiationError = exports.ValueCreateNotTypeError = exports.ValueCreateNeverTypeError = exports.ValueCreateIntersectTypeError = exports.Create = exports.ValueConvertUnknownTypeError = exports.Convert = exports.Clone = exports.Clean = exports.Check = exports.ValueCastUnknownTypeError = exports.ValueCastRecursiveTypeError = exports.ValueCastNeverTypeError = exports.ValueCastArrayUniqueItemsTypeError = exports.Cast = exports.ValueErrorIterator = exports.ValueErrorType = void 0;
-exports.Value = exports.IsValueType = exports.IsUndefined = exports.IsUint8Array = exports.IsTypedArray = exports.IsSymbol = exports.IsString = exports.IsPromise = exports.IsPlainObject = exports.IsObject = exports.IsNumber = exports.IsNull = exports.IsIterator = void 0;
+exports.IsUndefined = exports.IsUint8Array = exports.IsTypedArray = exports.IsSymbol = exports.IsString = exports.IsPromise = exports.IsPlainObject = exports.IsObject = exports.IsNumber = exports.IsNull = exports.IsIterator = exports.IsInteger = exports.IsFunction = exports.IsDate = exports.IsBoolean = exports.IsBigInt = exports.IsAsyncIterator = exports.IsArray = exports.HasPropertyKey = exports.TransformEncodeError = exports.TransformEncodeCheckError = exports.TransformDecodeError = exports.TransformDecodeCheckError = exports.HasTransform = exports.TransformEncode = exports.TransformDecode = exports.ValuePointer = exports.ValueMutateError = exports.Mutate = exports.ValueHashError = exports.Hash = exports.Equal = exports.ValueDeltaError = exports.Update = exports.Insert = exports.Delete = exports.Edit = exports.Patch = exports.Diff = exports.Default = exports.ValueCreateError = exports.Create = exports.Convert = exports.Clone = exports.Clean = exports.Check = exports.ValueCastError = exports.Cast = exports.ValueErrorIterator = exports.ValueErrorType = void 0;
+exports.Value = exports.IsValueType = void 0;
 // ------------------------------------------------------------------
 // Value Errors (re-export)
 // ------------------------------------------------------------------
@@ -14,10 +14,7 @@ Object.defineProperty(exports, "ValueErrorIterator", { enumerable: true, get: fu
 // ------------------------------------------------------------------
 var index_2 = require("./cast/index");
 Object.defineProperty(exports, "Cast", { enumerable: true, get: function () { return index_2.Cast; } });
-Object.defineProperty(exports, "ValueCastArrayUniqueItemsTypeError", { enumerable: true, get: function () { return index_2.ValueCastArrayUniqueItemsTypeError; } });
-Object.defineProperty(exports, "ValueCastNeverTypeError", { enumerable: true, get: function () { return index_2.ValueCastNeverTypeError; } });
-Object.defineProperty(exports, "ValueCastRecursiveTypeError", { enumerable: true, get: function () { return index_2.ValueCastRecursiveTypeError; } });
-Object.defineProperty(exports, "ValueCastUnknownTypeError", { enumerable: true, get: function () { return index_2.ValueCastUnknownTypeError; } });
+Object.defineProperty(exports, "ValueCastError", { enumerable: true, get: function () { return index_2.ValueCastError; } });
 var index_3 = require("./check/index");
 Object.defineProperty(exports, "Check", { enumerable: true, get: function () { return index_3.Check; } });
 var index_4 = require("./clean/index");
@@ -26,15 +23,9 @@ var index_5 = require("./clone/index");
 Object.defineProperty(exports, "Clone", { enumerable: true, get: function () { return index_5.Clone; } });
 var index_6 = require("./convert/index");
 Object.defineProperty(exports, "Convert", { enumerable: true, get: function () { return index_6.Convert; } });
-Object.defineProperty(exports, "ValueConvertUnknownTypeError", { enumerable: true, get: function () { return index_6.ValueConvertUnknownTypeError; } });
 var index_7 = require("./create/index");
 Object.defineProperty(exports, "Create", { enumerable: true, get: function () { return index_7.Create; } });
-Object.defineProperty(exports, "ValueCreateIntersectTypeError", { enumerable: true, get: function () { return index_7.ValueCreateIntersectTypeError; } });
-Object.defineProperty(exports, "ValueCreateNeverTypeError", { enumerable: true, get: function () { return index_7.ValueCreateNeverTypeError; } });
-Object.defineProperty(exports, "ValueCreateNotTypeError", { enumerable: true, get: function () { return index_7.ValueCreateNotTypeError; } });
-Object.defineProperty(exports, "ValueCreateRecursiveInstantiationError", { enumerable: true, get: function () { return index_7.ValueCreateRecursiveInstantiationError; } });
-Object.defineProperty(exports, "ValueCreateTempateLiteralTypeError", { enumerable: true, get: function () { return index_7.ValueCreateTempateLiteralTypeError; } });
-Object.defineProperty(exports, "ValueCreateUnknownTypeError", { enumerable: true, get: function () { return index_7.ValueCreateUnknownTypeError; } });
+Object.defineProperty(exports, "ValueCreateError", { enumerable: true, get: function () { return index_7.ValueCreateError; } });
 var index_8 = require("./default/index");
 Object.defineProperty(exports, "Default", { enumerable: true, get: function () { return index_8.Default; } });
 var index_9 = require("./delta/index");
@@ -44,8 +35,7 @@ Object.defineProperty(exports, "Edit", { enumerable: true, get: function () { re
 Object.defineProperty(exports, "Delete", { enumerable: true, get: function () { return index_9.Delete; } });
 Object.defineProperty(exports, "Insert", { enumerable: true, get: function () { return index_9.Insert; } });
 Object.defineProperty(exports, "Update", { enumerable: true, get: function () { return index_9.Update; } });
-Object.defineProperty(exports, "ValueDeltaObjectWithSymbolKeyError", { enumerable: true, get: function () { return index_9.ValueDeltaObjectWithSymbolKeyError; } });
-Object.defineProperty(exports, "ValueDeltaUnableToDiffUnknownValue", { enumerable: true, get: function () { return index_9.ValueDeltaUnableToDiffUnknownValue; } });
+Object.defineProperty(exports, "ValueDeltaError", { enumerable: true, get: function () { return index_9.ValueDeltaError; } });
 var index_10 = require("./equal/index");
 Object.defineProperty(exports, "Equal", { enumerable: true, get: function () { return index_10.Equal; } });
 var index_11 = require("./hash/index");
@@ -53,13 +43,12 @@ Object.defineProperty(exports, "Hash", { enumerable: true, get: function () { re
 Object.defineProperty(exports, "ValueHashError", { enumerable: true, get: function () { return index_11.ValueHashError; } });
 var index_12 = require("./mutate/index");
 Object.defineProperty(exports, "Mutate", { enumerable: true, get: function () { return index_12.Mutate; } });
-Object.defineProperty(exports, "ValueMutateInvalidRootMutationError", { enumerable: true, get: function () { return index_12.ValueMutateInvalidRootMutationError; } });
-Object.defineProperty(exports, "ValueMutateTypeMismatchError", { enumerable: true, get: function () { return index_12.ValueMutateTypeMismatchError; } });
+Object.defineProperty(exports, "ValueMutateError", { enumerable: true, get: function () { return index_12.ValueMutateError; } });
 var index_13 = require("./pointer/index");
 Object.defineProperty(exports, "ValuePointer", { enumerable: true, get: function () { return index_13.ValuePointer; } });
 var index_14 = require("./transform/index");
-Object.defineProperty(exports, "DecodeTransform", { enumerable: true, get: function () { return index_14.TransformDecode; } });
-Object.defineProperty(exports, "EncodeTransform", { enumerable: true, get: function () { return index_14.TransformEncode; } });
+Object.defineProperty(exports, "TransformDecode", { enumerable: true, get: function () { return index_14.TransformDecode; } });
+Object.defineProperty(exports, "TransformEncode", { enumerable: true, get: function () { return index_14.TransformEncode; } });
 Object.defineProperty(exports, "HasTransform", { enumerable: true, get: function () { return index_14.HasTransform; } });
 Object.defineProperty(exports, "TransformDecodeCheckError", { enumerable: true, get: function () { return index_14.TransformDecodeCheckError; } });
 Object.defineProperty(exports, "TransformDecodeError", { enumerable: true, get: function () { return index_14.TransformDecodeError; } });

package/build/require/value/mutate/mutate.d.ts

@@ -1,9 +1,6 @@
 import { TypeBoxError } from '../../type/error/index';
-export declare class ValueMutateTypeMismatchError extends TypeBoxError {
-    constructor();
-}
-export declare class ValueMutateInvalidRootMutationError extends TypeBoxError {
-    constructor();
+export declare class ValueMutateError extends TypeBoxError {
+    constructor(message: string);
 }
 export type Mutable = {
     [key: string]: unknown;

package/build/require/value/mutate/mutate.js

@@ -1,7 +1,7 @@
 "use strict";
 
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Mutate = exports.ValueMutateInvalidRootMutationError = exports.ValueMutateTypeMismatchError = void 0;
+exports.Mutate = exports.ValueMutateError = void 0;
 const index_1 = require("../guard/index");
 const index_2 = require("../pointer/index");
 const index_3 = require("../clone/index");
@@ -9,18 +9,12 @@ const index_4 = require("../../type/error/index");
 // ------------------------------------------------------------------
 // Errors
 // ------------------------------------------------------------------
-class ValueMutateTypeMismatchError extends index_4.TypeBoxError {
-    constructor() {
-        super('Cannot assign due type mismatch of assignable values');
+class ValueMutateError extends index_4.TypeBoxError {
+    constructor(message) {
+        super(message);
     }
 }
-exports.ValueMutateTypeMismatchError = ValueMutateTypeMismatchError;
-class ValueMutateInvalidRootMutationError extends index_4.TypeBoxError {
-    constructor() {
-        super('Only object and array types can be mutated at the root level');
-    }
-}
-exports.ValueMutateInvalidRootMutationError = ValueMutateInvalidRootMutationError;
+exports.ValueMutateError = ValueMutateError;
 function ObjectType(root, path, current, next) {
     if (!(0, index_1.IsPlainObject)(current)) {
         index_2.ValuePointer.Set(root, path, (0, index_3.Clone)(next));
@@ -96,9 +90,9 @@ function IsMismatchedValue(current, next) {
 /** `[Mutable]` Performs a deep mutable value assignment while retaining internal references */
 function Mutate(current, next) {
     if (IsNonMutableValue(current) || IsNonMutableValue(next))
-        throw new ValueMutateInvalidRootMutationError();
+        throw new ValueMutateError('Only object and array types can be mutated at the root level');
     if (IsMismatchedValue(current, next))
-        throw new ValueMutateTypeMismatchError();
+        throw new ValueMutateError('Cannot assign due type mismatch of assignable values');
     Visit(current, '', current, next);
 }
 exports.Mutate = Mutate;

package/package.json

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

package/readme.md

@@ -605,9 +605,10 @@ TypeBox provides an extended type set that can be used to create schematics for
 │                                │                             │ }                              │
 │                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
-│ const T = Type.RegExp(/abc/)   │ type T = string             │ const T = {                    │
-│                                │                             │   type: 'string'               │
-│                                │                             │   pattern: 'abc'               │
+│ const T = Type.RegExp(/abc/i)  │ type T = string             │ const T = {                    │
+│                                │                             │   type: 'RegExp'               │
+│                                │                             │   source: 'abc'                │
+│                                │                             │   flags: 'i'                   │
 │                                │                             │ }                              │
 │                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
@@ -647,12 +648,14 @@ TypeBox provides an extended type set that can be used to create schematics for
 
 ### Import
 
-You can import Type to bring in the full type system. This is recommended for most users.
+Import the Type namespace to bring in TypeBox's full type system. This is recommended for most users.
 
 ```typescript
 import { Type, type Static } from '@sinclair/typebox'
 ```
-You can also import types individually. This approach enables modern bundlers to tree shake unused types.
+
+You can also selectively import types. This enables modern bundlers to tree shake for unused types.
+
 ```typescript
 import { Object, Number, String, Boolean, type Static } from '@sinclair/typebox'
 ```
@@ -905,11 +908,11 @@ const R = Type.Record(K, Type.String())              // const R: TObject<{
 TypeBox supports indexed access types with Index. This type enables uniform access to interior property and element types without having to extract them from the underlying schema representation. This type is supported for Object, Array, Tuple, Union and Intersect types.
 
 ```typescript
-const T = Type.Object({                              // const T: TObject<{
-  x: Type.Number(),                                  //   x: TNumber,
-  y: Type.String(),                                  //   y: TString,
-  z: Type.Boolean()                                  //   z: TBoolean
-})                                                   // }>
+const T = Type.Object({                              // type T = {
+  x: Type.Number(),                                  //   x: number,
+  y: Type.String(),                                  //   y: string,
+  z: Type.Boolean()                                  //   z: boolean
+})                                                   // }
 
 const A = Type.Index(T, ['x'])                       // type A = T['x']
                                                      //
@@ -944,17 +947,17 @@ const C = Type.Index(T, Type.KeyOf(T))               // type C = T[keyof T]
 TypeBox supports mapped object types with Mapped. This type accepts two arguments, the first is a union type typically derived from KeyOf, the second is a mapping function that receives a mapping key `K` that can be used to index properties of a type. The following implements Partial using mapped types.
 
 ```typescript
-const T = Type.Object({                              // const T: TObject<{
-  x: Type.Number(),                                  //   x: TNumber,
-  y: Type.String(),                                  //   y: TString,
-  z: Type.Boolean()                                  //   z: TBoolean
-})                                                   // }>
+const T = Type.Object({                              // type T = {
+  x: Type.Number(),                                  //   x: number,
+  y: Type.String(),                                  //   y: string,
+  z: Type.Boolean()                                  //   z: boolean
+})                                                   // }
 
-const P = Type.Mapped(Type.KeyOf(T), K => {          // type P = { [K in keyof T]?: T[K] }
+const M = Type.Mapped(Type.KeyOf(T), K => {          // type M = { [K in keyof T]?: T[K] }
   return Type.Optional(Type.Index(T, K))             //
 })                                                   // ... evaluated as
                                                      // 
-                                                     // const P: TObject<{
+                                                     // const M: TObject<{
                                                      //   x: TOptional<TNumber>,
                                                      //   y: TOptional<TString>,
                                                      //   z: TOptional<TBoolean>
@@ -969,29 +972,29 @@ TypeBox supports runtime conditional types with Extends. This type performs a st
 
 ```typescript
 // Extends
-const T = Type.Extends(                              // type T = string extends number ? true : false
+const A = Type.Extends(                              // type A = string extends number ? 1 : 2
   Type.String(),                                     //   
   Type.Number(),                                     // ... evaluated as
-  Type.Literal(true),                                //
-  Type.Literal(false)                                // const T: TLiteral<false>
+  Type.Literal(1),                                   //
+  Type.Literal(2)                                    // const A: TLiteral<2>
 )
 
 // Extract
-const T = Type.Extract(                              // type T = Extract<1 | 2 | 3, 1>
+const B = Type.Extract(                              // type B = Extract<1 | 2 | 3, 1>
   Type.Union([                                       //
     Type.Literal(1),                                 // ... evaluated as
     Type.Literal(2),                                 //
-    Type.Literal(3)                                  // const T: TLiteral<1>
+    Type.Literal(3)                                  // const B: TLiteral<1>
   ]), 
   Type.Literal(1)
 )
 
 // Exclude
-const T = Type.Exclude(                              // type T = Exclude<1 | 2 | 3, 1>
+const C = Type.Exclude(                              // type C = Exclude<1 | 2 | 3, 1>
   Type.Union([                                       // 
     Type.Literal(1),                                 // ... evaluated as
     Type.Literal(2),                                 //
-    Type.Literal(3)                                  // const T: TUnion<[
+    Type.Literal(3)                                  // const C: TUnion<[
   ]),                                                //   TLiteral<2>,
   Type.Literal(1)                                    //   TLiteral<3>,
 )                                                    // ]>
@@ -1039,11 +1042,11 @@ TypeBox supports value decoding and encoding with Transform types. These types w
 import { Value } from '@sinclair/typebox/value'
 
 const T = Type.Transform(Type.Number())
-  .Decode(value => new Date(value))                  // required: number to Date
-  .Encode(value => value.getTime())                  // required: Date to number
+  .Decode(value => new Date(value))                  // decode: number to Date
+  .Encode(value => value.getTime())                  // encode: Date to number
 
-const decoded = Value.Decode(T, 0)                   // const decoded = Date(1970-01-01T00:00:00.000Z)
-const encoded = Value.Encode(T, decoded)             // const encoded = 0
+const D = Value.Decode(T, 0)                         // const D = Date(1970-01-01T00:00:00.000Z)
+const E = Value.Encode(T, D)                         // const E = 0
 ```
 Use the StaticEncode or StaticDecode types to infer a Transform type.
 ```typescript
@@ -1418,15 +1421,18 @@ The TypeBox type system can be extended with additional types and formats using
 
 ### TypeRegistry
 
-Use the TypeRegistry to register a new type. The Kind must match the registered type name.
+Use the TypeRegistry to register a type. The Kind must match the registered type name.
 
 ```typescript
-import { TypeRegistry, Symbols } from '@sinclair/typebox'
+import { TSchema, Kind, TypeRegistry } from '@sinclair/typebox'
 
 TypeRegistry.Set('Foo', (schema, value) => value === 'foo')
 
-const A = Value.Check({ [Kind]: 'Foo' }, 'foo')      // const A = true
-const B = Value.Check({ [Kind]: 'Foo' }, 'bar')      // const B = false
+const Foo = { [Kind]: 'Foo' } as TSchema 
+
+const A = Value.Check(Foo, 'foo')                    // const A = true
+
+const B = Value.Check(Foo, 'bar')                    // const B = false
 ```
 
 <a name='typeregistry-format'></a>
@@ -1443,6 +1449,7 @@ FormatRegistry.Set('foo', (value) => value === 'foo')
 const T = Type.String({ format: 'foo' })
 
 const A = Value.Check(T, 'foo')                      // const A = true
+
 const B = Value.Check(T, 'bar')                      // const B = false
 ```
 
@@ -1795,11 +1802,11 @@ The following table lists esbuild compiled and minified sizes for each TypeBox m
 ┌──────────────────────┬────────────┬────────────┬─────────────┐
 │       (index)        │  Compiled  │  Minified  │ Compression │
 ├──────────────────────┼────────────┼────────────┼─────────────┤
-│ typebox/compiler     │ '119.2 kb' │ ' 52.3 kb' │  '2.28 x'   │
-│ typebox/errors       │ ' 55.0 kb' │ ' 25.2 kb' │  '2.19 x'   │
+│ typebox/compiler     │ '120.6 kb' │ ' 52.9 kb' │  '2.28 x'   │
+│ typebox/errors       │ ' 55.7 kb' │ ' 25.5 kb' │  '2.19 x'   │
 │ typebox/system       │ '  4.7 kb' │ '  2.0 kb' │  '2.33 x'   │
-│ typebox/value        │ '146.1 kb' │ ' 61.8 kb' │  '2.37 x'   │
-│ typebox              │ ' 90.1 kb' │ ' 37.3 kb' │  '2.41 x'   │
+│ typebox/value        │ '146.2 kb' │ ' 62.0 kb' │  '2.36 x'   │
+│ typebox              │ ' 91.4 kb' │ ' 37.8 kb' │  '2.42 x'   │
 └──────────────────────┴────────────┴────────────┴─────────────┘
 ```