@sinclair/typebox 0.32.0-dev-27 → 0.32.0

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

@@ -1,9 +1,6 @@
 import { TypeBoxError } from '../../type/error/index.mjs';
-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/import/value/mutate/mutate.mjs

@@ -5,14 +5,9 @@ import { TypeBoxError } from '../../type/error/index.mjs';
 // ------------------------------------------------------------------
 // Errors
 // ------------------------------------------------------------------
-export class ValueMutateTypeMismatchError extends TypeBoxError {
-    constructor() {
-        super('Cannot assign due type mismatch of assignable values');
-    }
-}
-export class ValueMutateInvalidRootMutationError extends TypeBoxError {
-    constructor() {
-        super('Only object and array types can be mutated at the root level');
+export class ValueMutateError extends TypeBoxError {
+    constructor(message) {
+        super(message);
     }
 }
 function ObjectType(root, path, current, next) {
@@ -90,8 +85,8 @@ function IsMismatchedValue(current, next) {
 /** `[Mutable]` Performs a deep mutable value assignment while retaining internal references */
 export 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);
 }

package/build/require/compiler/compiler.js

@@ -384,6 +384,11 @@ var TypeCompiler;
             return yield `${CreateFunctionName(schema.$ref)}(${value})`;
         yield* Visit(target, references, value);
     }
+    function* FromRegExp(schema, references, value) {
+        const variable = CreateVariable(`${new RegExp(schema.source, schema.flags)};`);
+        yield `(typeof ${value} === 'string')`;
+        yield `${variable}.test(${value})`;
+    }
     function* FromString(schema, references, value) {
         yield `(typeof ${value} === 'string')`;
         if ((0, index_11.IsNumber)(schema.maxLength))
@@ -503,6 +508,8 @@ var TypeCompiler;
                 return yield* FromRecord(schema_, references_, value);
             case 'Ref':
                 return yield* FromRef(schema_, references_, value);
+            case 'RegExp':
+                return yield* FromRegExp(schema_, references_, value);
             case 'String':
                 return yield* FromString(schema_, references_, value);
             case 'Symbol':

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

@@ -49,21 +49,22 @@ export declare enum ValueErrorType {
     ObjectRequiredProperty = 45,
     Object = 46,
     Promise = 47,
-    StringFormatUnknown = 48,
-    StringFormat = 49,
-    StringMaxLength = 50,
-    StringMinLength = 51,
-    StringPattern = 52,
-    String = 53,
-    Symbol = 54,
-    TupleLength = 55,
-    Tuple = 56,
-    Uint8ArrayMaxByteLength = 57,
-    Uint8ArrayMinByteLength = 58,
-    Uint8Array = 59,
-    Undefined = 60,
-    Union = 61,
-    Void = 62
+    RegExp = 48,
+    StringFormatUnknown = 49,
+    StringFormat = 50,
+    StringMaxLength = 51,
+    StringMinLength = 52,
+    StringPattern = 53,
+    String = 54,
+    Symbol = 55,
+    TupleLength = 56,
+    Tuple = 57,
+    Uint8ArrayMaxByteLength = 58,
+    Uint8ArrayMinByteLength = 59,
+    Uint8Array = 60,
+    Undefined = 61,
+    Union = 62,
+    Void = 63
 }
 export interface ValueError {
     type: ValueErrorType;

package/build/require/errors/errors.js

@@ -70,21 +70,22 @@ var ValueErrorType;
     ValueErrorType[ValueErrorType["ObjectRequiredProperty"] = 45] = "ObjectRequiredProperty";
     ValueErrorType[ValueErrorType["Object"] = 46] = "Object";
     ValueErrorType[ValueErrorType["Promise"] = 47] = "Promise";
-    ValueErrorType[ValueErrorType["StringFormatUnknown"] = 48] = "StringFormatUnknown";
-    ValueErrorType[ValueErrorType["StringFormat"] = 49] = "StringFormat";
-    ValueErrorType[ValueErrorType["StringMaxLength"] = 50] = "StringMaxLength";
-    ValueErrorType[ValueErrorType["StringMinLength"] = 51] = "StringMinLength";
-    ValueErrorType[ValueErrorType["StringPattern"] = 52] = "StringPattern";
-    ValueErrorType[ValueErrorType["String"] = 53] = "String";
-    ValueErrorType[ValueErrorType["Symbol"] = 54] = "Symbol";
-    ValueErrorType[ValueErrorType["TupleLength"] = 55] = "TupleLength";
-    ValueErrorType[ValueErrorType["Tuple"] = 56] = "Tuple";
-    ValueErrorType[ValueErrorType["Uint8ArrayMaxByteLength"] = 57] = "Uint8ArrayMaxByteLength";
-    ValueErrorType[ValueErrorType["Uint8ArrayMinByteLength"] = 58] = "Uint8ArrayMinByteLength";
-    ValueErrorType[ValueErrorType["Uint8Array"] = 59] = "Uint8Array";
-    ValueErrorType[ValueErrorType["Undefined"] = 60] = "Undefined";
-    ValueErrorType[ValueErrorType["Union"] = 61] = "Union";
-    ValueErrorType[ValueErrorType["Void"] = 62] = "Void";
+    ValueErrorType[ValueErrorType["RegExp"] = 48] = "RegExp";
+    ValueErrorType[ValueErrorType["StringFormatUnknown"] = 49] = "StringFormatUnknown";
+    ValueErrorType[ValueErrorType["StringFormat"] = 50] = "StringFormat";
+    ValueErrorType[ValueErrorType["StringMaxLength"] = 51] = "StringMaxLength";
+    ValueErrorType[ValueErrorType["StringMinLength"] = 52] = "StringMinLength";
+    ValueErrorType[ValueErrorType["StringPattern"] = 53] = "StringPattern";
+    ValueErrorType[ValueErrorType["String"] = 54] = "String";
+    ValueErrorType[ValueErrorType["Symbol"] = 55] = "Symbol";
+    ValueErrorType[ValueErrorType["TupleLength"] = 56] = "TupleLength";
+    ValueErrorType[ValueErrorType["Tuple"] = 57] = "Tuple";
+    ValueErrorType[ValueErrorType["Uint8ArrayMaxByteLength"] = 58] = "Uint8ArrayMaxByteLength";
+    ValueErrorType[ValueErrorType["Uint8ArrayMinByteLength"] = 59] = "Uint8ArrayMinByteLength";
+    ValueErrorType[ValueErrorType["Uint8Array"] = 60] = "Uint8Array";
+    ValueErrorType[ValueErrorType["Undefined"] = 61] = "Undefined";
+    ValueErrorType[ValueErrorType["Union"] = 62] = "Union";
+    ValueErrorType[ValueErrorType["Void"] = 63] = "Void";
 })(ValueErrorType || (exports.ValueErrorType = ValueErrorType = {}));
 // ------------------------------------------------------------------
 // ValueErrors
@@ -395,6 +396,12 @@ function* FromRecord(schema, references, path, value) {
 function* FromRef(schema, references, path, value) {
     yield* Visit((0, index_5.Deref)(schema, references), references, path, value);
 }
+function* FromRegExp(schema, references, path, value) {
+    const regex = new RegExp(schema.source, schema.flags);
+    if (!regex.test(value)) {
+        return yield Create(ValueErrorType.RegExp, schema, path, value);
+    }
+}
 function* FromString(schema, references, path, value) {
     if (!(0, index_9.IsString)(value))
         return yield Create(ValueErrorType.String, schema, path, value);
@@ -533,6 +540,8 @@ function* Visit(schema, references, path, value) {
             return yield* FromRecord(schema_, references_, path, value);
         case 'Ref':
             return yield* FromRef(schema_, references_, path, value);
+        case 'RegExp':
+            return yield* FromRegExp(schema_, references_, path, value);
         case 'String':
             return yield* FromString(schema_, references_, path, value);
         case 'Symbol':

package/build/require/errors/function.js

@@ -101,6 +101,8 @@ function DefaultErrorFunction(error) {
             return 'Required property';
         case errors_1.ValueErrorType.Promise:
             return 'Expected Promise';
+        case errors_1.ValueErrorType.RegExp:
+            return 'Expected string to match regular expression';
         case errors_1.ValueErrorType.StringFormatUnknown:
             return `Unknown format '${error.schema.format}'`;
         case errors_1.ValueErrorType.StringFormat:

package/build/require/type/clone/value.js

@@ -12,6 +12,9 @@ function DateType(value) {
 function Uint8ArrayType(value) {
     return new Uint8Array(value);
 }
+function RegExpType(value) {
+    return new RegExp(value.source, value.flags);
+}
 function ObjectType(value) {
     const clonedProperties = Object.getOwnPropertyNames(value).reduce((acc, key) => ({ ...acc, [key]: Visit(value[key]) }), {});
     const clonedSymbols = Object.getOwnPropertySymbols(value).reduce((acc, key) => ({ ...acc, [key]: Visit(value[key]) }), {});
@@ -22,8 +25,9 @@ function Visit(value) {
     return (ValueGuard.IsArray(value) ? ArrayType(value) :
         ValueGuard.IsDate(value) ? DateType(value) :
             ValueGuard.IsUint8Array(value) ? Uint8ArrayType(value) :
-                ValueGuard.IsObject(value) ? ObjectType(value) :
-                    value);
+                ValueGuard.IsRegExp(value) ? RegExpType(value) :
+                    ValueGuard.IsObject(value) ? ObjectType(value) :
+                        value);
 }
 /** Clones a value */
 function Clone(value) {