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

package/build/import/compiler/compiler.mjs

@@ -384,6 +384,11 @@ export 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 (IsNumber(schema.maxLength))
@@ -503,6 +508,8 @@ export 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/import/errors/errors.d.mts

@@ -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/import/errors/errors.mjs

@@ -66,21 +66,22 @@ export 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 || (ValueErrorType = {}));
 // ------------------------------------------------------------------
 // ValueErrors
@@ -391,6 +392,12 @@ function* FromRecord(schema, references, path, value) {
 function* FromRef(schema, references, path, value) {
     yield* Visit(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 (!IsString(value))
         return yield Create(ValueErrorType.String, schema, path, value);
@@ -529,6 +536,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/import/errors/function.mjs

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

package/build/import/index.d.mts

@@ -36,11 +36,11 @@ export { Not, type TNot } from './type/not/index.mjs';
 export { Null, type TNull } from './type/null/index.mjs';
 export { Number, type TNumber, type NumberOptions } from './type/number/index.mjs';
 export { Object, type TObject, type TProperties, type ObjectOptions } from './type/object/index.mjs';
-export { Omit, type TOmit, type TOmitFromMappedKey } from './type/omit/index.mjs';
+export { Omit, type TOmit, type TOmitFromMappedKey, type TOmitFromMappedResult } from './type/omit/index.mjs';
 export { Optional, OptionalFromMappedResult, type TOptional, type TOptionalWithFlag, type TOptionalFromMappedResult } from './type/optional/index.mjs';
 export { Parameters, type TParameters } from './type/parameters/index.mjs';
 export { Partial, PartialFromMappedResult, type TPartial, type TPartialFromMappedResult } from './type/partial/index.mjs';
-export { Pick, type TPick, type TPickFromMappedKey } from './type/pick/index.mjs';
+export { Pick, type TPick, type TPickFromMappedKey, type TPickFromMappedResult } from './type/pick/index.mjs';
 export { Promise, type TPromise } from './type/promise/index.mjs';
 export { Readonly, ReadonlyFromMappedResult, type TReadonly, type TReadonlyWithFlag, type TReadonlyFromMappedResult } from './type/readonly/index.mjs';
 export { ReadonlyOptional, type TReadonlyOptional } from './type/readonly-optional/index.mjs';

package/build/import/type/awaited/awaited.mjs

@@ -4,14 +4,10 @@ import { CloneType } from '../clone/type.mjs';
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-// prettier-ignore
 import { IsIntersect, IsUnion, IsPromise } from '../guard/type.mjs';
 // prettier-ignore
-function FromRest(T, Acc = []) {
-    const [L, ...R] = T;
-    return (T.length > 0
-        ? FromRest(R, [...Acc, FromSchema(L)])
-        : Acc);
+function FromRest(T) {
+    return T.map(L => FromSchema(L));
 }
 // prettier-ignore
 function FromIntersect(T) {

package/build/import/type/clone/value.mjs

@@ -8,6 +8,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]) }), {});
@@ -18,8 +21,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 */
 export function Clone(value) {

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

@@ -7,8 +7,7 @@ type TCompositeIndex<T extends TIntersect<TObject[]>, K extends string[], Acc ex
     [_ in L]: TIndex<T, [L]>;
 }> : Acc;
 type TCompositeReduce<T extends TObject[]> = UnionToTuple<TCompositeKeys<T>> extends infer K ? Evaluate<TCompositeIndex<TIntersect<T>, Assert<K, string[]>>> : {};
-export type TCompositeResolve<T extends TObject[]> = TIntersect<T> extends TIntersect ? TObject<TCompositeReduce<T>> : TObject<{}>;
-export declare function CompositeResolve<T extends TObject[]>(T: [...T]): TCompositeResolve<T>;
+type TCompositeResolve<T extends TObject[]> = TIntersect<T> extends TIntersect ? TObject<TCompositeReduce<T>> : TObject<{}>;
 export type TComposite<T extends TObject[]> = TCompositeResolve<T>;
 /** `[Json]` Creates a Composite object type */
 export declare function Composite<T extends TObject[]>(T: [...T], options?: ObjectOptions): TComposite<T>;

package/build/import/type/composite/composite.mjs

@@ -1,9 +1,9 @@
 import { Object } from '../object/index.mjs';
 import { Intersect } from '../intersect/index.mjs';
-import { KeyOfPropertyKeys } from '../keyof/index.mjs';
 import { Index } from '../indexed/index.mjs';
+import { KeyOfPropertyKeys } from '../keyof/index.mjs';
 import { CloneType } from '../clone/type.mjs';
-export function CompositeResolve(T) {
+function CompositeResolve(T) {
     const intersect = Intersect(T, {});
     const keys = KeyOfPropertyKeys(intersect);
     const properties = keys.reduce((acc, key) => ({ ...acc, [key]: Index(intersect, [key]) }), {});

package/build/import/type/const/const.mjs

@@ -1,4 +1,3 @@
-import { IsArray, IsNumber, IsBigInt, IsUint8Array, IsDate, IsIterator, IsObject, IsAsyncIterator, IsFunction, IsUndefined, IsNull, IsSymbol, IsBoolean, IsString } from '../guard/value.mjs';
 import { Any } from '../any/index.mjs';
 import { BigInt } from '../bigint/index.mjs';
 import { Date } from '../date/index.mjs';
@@ -13,12 +12,13 @@ import { Undefined } from '../undefined/index.mjs';
 import { Uint8Array } from '../uint8array/index.mjs';
 import { Unknown } from '../unknown/index.mjs';
 import { TypeClone } from '../clone/index.mjs';
+// ------------------------------------------------------------------
+// ValueGuard
+// ------------------------------------------------------------------
+import { IsArray, IsNumber, IsBigInt, IsUint8Array, IsDate, IsIterator, IsObject, IsAsyncIterator, IsFunction, IsUndefined, IsNull, IsSymbol, IsBoolean, IsString } from '../guard/value.mjs';
 // prettier-ignore
 function FromArray(T) {
-    const [L, ...R] = T;
-    return (T.length > 0
-        ? [FromValue(L, false), ...FromArray(R)]
-        : []);
+    return T.map(L => FromValue(L, false));
 }
 // prettier-ignore
 function FromProperties(value) {
@@ -33,7 +33,7 @@ function ConditionalReadonly(T, root) {
 function FromValue(value, root) {
     return (IsAsyncIterator(value) ? ConditionalReadonly(Any(), root) :
         IsIterator(value) ? ConditionalReadonly(Any(), root) :
-            IsArray(value) ? Readonly(Tuple(FromArray(value))) : // Always Readonly
+            IsArray(value) ? Readonly(Tuple(FromArray(value))) :
                 IsUint8Array(value) ? Uint8Array() :
                     IsDate(value) ? Date() :
                         IsObject(value) ? ConditionalReadonly(Object(FromProperties(value)), root) :

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

@@ -4,7 +4,7 @@ import type { Ensure } from '../helpers/index.mjs';
 import { Kind } from '../symbols/index.mjs';
 type ConstructorStaticReturnType<T extends TSchema, P extends unknown[]> = Static<T, P>;
 type ConstructorStaticParameters<T extends TSchema[], P extends unknown[], Acc extends unknown[] = []> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? ConstructorStaticParameters<R, P, [...Acc, Static<L, P>]> : Acc;
-export type ConstructorStatic<T extends TSchema[], U extends TSchema, P extends unknown[]> = (Ensure<new (...param: ConstructorStaticParameters<T, P>) => ConstructorStaticReturnType<U, P>>);
+type ConstructorStatic<T extends TSchema[], U extends TSchema, P extends unknown[]> = (Ensure<new (...param: ConstructorStaticParameters<T, P>) => ConstructorStaticReturnType<U, P>>);
 export interface TConstructor<T extends TSchema[] = TSchema[], U extends TSchema = TSchema> extends TSchema {
     [Kind]: 'Constructor';
     static: ConstructorStatic<T, U, this['params']>;

package/build/import/type/constructor/constructor.mjs

@@ -1,5 +1,5 @@
-import { Kind } from '../symbols/index.mjs';
 import { CloneType, CloneRest } from '../clone/type.mjs';
+import { Kind } from '../symbols/index.mjs';
 /** `[JavaScript]` Creates a Constructor type */
 export function Constructor(parameters, returns, options) {
     return {

package/build/import/type/deref/deref.mjs

@@ -4,8 +4,7 @@ import { IsUndefined } from '../guard/value.mjs';
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-// prettier-ignore
-import { IsConstructor, IsFunction, IsIntersect, IsUnion, IsTuple, IsArray, IsObject, IsPromise, IsAsyncIterator, IsIterator, IsRef, } from '../guard/type.mjs';
+import { IsConstructor, IsFunction, IsIntersect, IsUnion, IsTuple, IsArray, IsObject, IsPromise, IsAsyncIterator, IsIterator, IsRef } from '../guard/type.mjs';
 function FromRest(schema, references) {
     return schema.map((schema) => Deref(schema, references));
 }

package/build/import/type/discard/discard.mjs

@@ -1,7 +1,7 @@
-function Key(value, key) {
+function DiscardKey(value, key) {
     const { [key]: _, ...rest } = value;
     return rest;
 }
 export function Discard(value, keys) {
-    return keys.reduce((acc, key) => Key(acc, key), value);
+    return keys.reduce((acc, key) => DiscardKey(acc, key), value);
 }

package/build/import/type/enum/enum.mjs

@@ -1,6 +1,9 @@
 import { Literal } from '../literal/index.mjs';
 import { Kind, Hint } from '../symbols/index.mjs';
 import { Union } from '../union/index.mjs';
+// ------------------------------------------------------------------
+// ValueGuard
+// ------------------------------------------------------------------
 import { IsUndefined } from '../guard/value.mjs';
 /** `[Json]` Creates a Enum type */
 export function Enum(item, options = {}) {

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

@@ -2,10 +2,10 @@ import type { TSchema, SchemaOptions } from '../schema/index.mjs';
 import type { TProperties } from '../object/index.mjs';
 import { type TMappedResult } from '../mapped/index.mjs';
 import { type TExclude } from './exclude.mjs';
-type TFromProperties<K extends TProperties, U extends TSchema> = ({
-    [K2 in keyof K]: TExclude<K[K2], U>;
+type TFromProperties<K extends TProperties, T extends TSchema> = ({
+    [K2 in keyof K]: TExclude<K[K2], T>;
 });
-type TFromMappedResult<K extends TMappedResult, U extends TSchema> = (TFromProperties<K['properties'], U>);
-export type TExcludeFromMappedResult<T extends TMappedResult, U extends TSchema, P extends TProperties = TFromMappedResult<T, U>> = (TMappedResult<P>);
-export declare function ExcludeFromMappedResult<T extends TMappedResult, U extends TSchema, P extends TProperties = TFromMappedResult<T, U>>(T: T, U: U, options: SchemaOptions): TMappedResult<P>;
+type TFromMappedResult<R extends TMappedResult, T extends TSchema> = (TFromProperties<R['properties'], T>);
+export type TExcludeFromMappedResult<R extends TMappedResult, T extends TSchema, P extends TProperties = TFromMappedResult<R, T>> = (TMappedResult<P>);
+export declare function ExcludeFromMappedResult<R extends TMappedResult, T extends TSchema, P extends TProperties = TFromMappedResult<R, T>>(R: R, T: T, options: SchemaOptions): TMappedResult<P>;
 export {};

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

@@ -1,17 +1,17 @@
 import { MappedResult } from '../mapped/index.mjs';
 import { Exclude } from './exclude.mjs';
 // prettier-ignore
-function FromProperties(K, U, options) {
-    return globalThis.Object.getOwnPropertyNames(K).reduce((Acc, K2) => {
-        return { ...Acc, [K2]: Exclude(K[K2], U, options) };
+function FromProperties(P, U, options) {
+    return globalThis.Object.getOwnPropertyNames(P).reduce((Acc, K2) => {
+        return { ...Acc, [K2]: Exclude(P[K2], U, options) };
     }, {});
 }
 // prettier-ignore
-function FromMappedResult(K, U, options) {
-    return FromProperties(K.properties, U, options);
+function FromMappedResult(R, T, options) {
+    return FromProperties(R.properties, T, options);
 }
 // prettier-ignore
-export function ExcludeFromMappedResult(T, U, options) {
-    const P = FromMappedResult(T, U, options);
+export function ExcludeFromMappedResult(R, T, options) {
+    const P = FromMappedResult(R, T, options);
     return MappedResult(P);
 }

package/build/import/type/exclude/exclude.mjs

@@ -7,7 +7,6 @@ import { ExcludeFromMappedResult } from './exclude-from-mapped-result.mjs';
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-// prettier-ignore
 import { IsMappedResult, IsTemplateLiteral, IsUnion } from '../guard/type.mjs';
 // prettier-ignore
 function ExcludeResolve(L, R) {