@sinclair/typebox 0.34.16 → 0.34.17

package/build/cjs/type/record/record.js

@@ -2,16 +2,21 @@
 
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Record = Record;
+exports.RecordPattern = RecordPattern;
+exports.RecordKey = RecordKey;
+exports.RecordValue = RecordValue;
 const type_1 = require("../create/type");
 const index_1 = require("../symbols/index");
 const index_2 = require("../computed/index");
 const index_3 = require("../never/index");
-const index_4 = require("../object/index");
-const index_5 = require("../ref/index");
-const index_6 = require("../union/index");
-const index_7 = require("../template-literal/index");
-const index_8 = require("../patterns/index");
-const index_9 = require("../indexed/index");
+const index_4 = require("../number/index");
+const index_5 = require("../object/index");
+const index_6 = require("../ref/index");
+const index_7 = require("../string/index");
+const index_8 = require("../union/index");
+const index_9 = require("../template-literal/index");
+const index_10 = require("../patterns/index");
+const index_11 = require("../indexed/index");
 // ------------------------------------------------------------------
 // ValueGuard
 // ------------------------------------------------------------------
@@ -35,17 +40,17 @@ function RecordCreateFromKeys(K, T, options) {
     const result = {};
     for (const K2 of K)
         result[K2] = T;
-    return (0, index_4.Object)(result, { ...options, [index_1.Hint]: 'Record' });
+    return (0, index_5.Object)(result, { ...options, [index_1.Hint]: 'Record' });
 }
 // prettier-ignore
 function FromTemplateLiteralKey(K, T, options) {
-    return ((0, index_7.IsTemplateLiteralFinite)(K)
-        ? RecordCreateFromKeys((0, index_9.IndexPropertyKeys)(K), T, options)
+    return ((0, index_9.IsTemplateLiteralFinite)(K)
+        ? RecordCreateFromKeys((0, index_11.IndexPropertyKeys)(K), T, options)
         : RecordCreateFromPattern(K.pattern, T, options));
 }
 // prettier-ignore
 function FromUnionKey(key, type, options) {
-    return RecordCreateFromKeys((0, index_9.IndexPropertyKeys)((0, index_6.Union)(key)), type, options);
+    return RecordCreateFromKeys((0, index_11.IndexPropertyKeys)((0, index_8.Union)(key)), type, options);
 }
 // prettier-ignore
 function FromLiteralKey(key, type, options) {
@@ -57,24 +62,28 @@ function FromRegExpKey(key, type, options) {
 }
 // prettier-ignore
 function FromStringKey(key, type, options) {
-    const pattern = (0, value_1.IsUndefined)(key.pattern) ? index_8.PatternStringExact : key.pattern;
+    const pattern = (0, value_1.IsUndefined)(key.pattern) ? index_10.PatternStringExact : key.pattern;
     return RecordCreateFromPattern(pattern, type, options);
 }
 // prettier-ignore
 function FromAnyKey(_, type, options) {
-    return RecordCreateFromPattern(index_8.PatternStringExact, type, options);
+    return RecordCreateFromPattern(index_10.PatternStringExact, type, options);
 }
 // prettier-ignore
 function FromNeverKey(_key, type, options) {
-    return RecordCreateFromPattern(index_8.PatternNeverExact, type, options);
+    return RecordCreateFromPattern(index_10.PatternNeverExact, type, options);
+}
+// prettier-ignore
+function FromBooleanKey(_key, type, options) {
+    return (0, index_5.Object)({ true: type, false: type }, options);
 }
 // prettier-ignore
 function FromIntegerKey(_key, type, options) {
-    return RecordCreateFromPattern(index_8.PatternNumberExact, type, options);
+    return RecordCreateFromPattern(index_10.PatternNumberExact, type, options);
 }
 // prettier-ignore
 function FromNumberKey(_, type, options) {
-    return RecordCreateFromPattern(index_8.PatternNumberExact, type, options);
+    return RecordCreateFromPattern(index_10.PatternNumberExact, type, options);
 }
 // ------------------------------------------------------------------
 // TRecordOrObject
@@ -84,15 +93,36 @@ function Record(key, type, options = {}) {
     // prettier-ignore
     return ((0, kind_1.IsComputed)(type) ? (0, index_2.Computed)('Record', [key, (0, index_2.Computed)(type.target, type.parameters)], options) :
         (0, kind_1.IsComputed)(key) ? (0, index_2.Computed)('Record', [(0, index_2.Computed)(type.target, type.parameters), type], options) :
-            (0, kind_1.IsRef)(key) ? (0, index_2.Computed)('Record', [(0, index_5.Ref)(key.$ref), type]) :
+            (0, kind_1.IsRef)(key) ? (0, index_2.Computed)('Record', [(0, index_6.Ref)(key.$ref), type]) :
                 (0, kind_1.IsUnion)(key) ? FromUnionKey(key.anyOf, type, options) :
                     (0, kind_1.IsTemplateLiteral)(key) ? FromTemplateLiteralKey(key, type, options) :
                         (0, kind_1.IsLiteral)(key) ? FromLiteralKey(key.const, type, options) :
-                            (0, kind_1.IsInteger)(key) ? FromIntegerKey(key, type, options) :
-                                (0, kind_1.IsNumber)(key) ? FromNumberKey(key, type, options) :
-                                    (0, kind_1.IsRegExp)(key) ? FromRegExpKey(key, type, options) :
-                                        (0, kind_1.IsString)(key) ? FromStringKey(key, type, options) :
-                                            (0, kind_1.IsAny)(key) ? FromAnyKey(key, type, options) :
-                                                (0, kind_1.IsNever)(key) ? FromNeverKey(key, type, options) :
-                                                    (0, index_3.Never)(options));
+                            (0, kind_1.IsBoolean)(key) ? FromBooleanKey(key, type, options) :
+                                (0, kind_1.IsInteger)(key) ? FromIntegerKey(key, type, options) :
+                                    (0, kind_1.IsNumber)(key) ? FromNumberKey(key, type, options) :
+                                        (0, kind_1.IsRegExp)(key) ? FromRegExpKey(key, type, options) :
+                                            (0, kind_1.IsString)(key) ? FromStringKey(key, type, options) :
+                                                (0, kind_1.IsAny)(key) ? FromAnyKey(key, type, options) :
+                                                    (0, kind_1.IsNever)(key) ? FromNeverKey(key, type, options) :
+                                                        (0, index_3.Never)(options));
+}
+// ------------------------------------------------------------------
+// Record Utilities
+// ------------------------------------------------------------------
+/** Gets the Records Pattern */
+function RecordPattern(record) {
+    return globalThis.Object.getOwnPropertyNames(record.patternProperties)[0];
+}
+/** Gets the Records Key Type */
+// prettier-ignore
+function RecordKey(type) {
+    const pattern = RecordPattern(type);
+    return (pattern === index_10.PatternStringExact ? (0, index_7.String)() :
+        pattern === index_10.PatternNumberExact ? (0, index_4.Number)() :
+            (0, index_7.String)({ pattern }));
+}
+/** Gets a Record Value Type */
+// prettier-ignore
+function RecordValue(type) {
+    return type.patternProperties[RecordPattern(type)];
 }

package/build/cjs/type/remap/index.d.ts

@@ -0,0 +1 @@
+export * from './remap';

package/build/cjs/type/remap/index.js

@@ -0,0 +1,18 @@
+"use strict";
+
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./remap"), exports);

package/build/cjs/type/remap/remap.d.ts

@@ -0,0 +1,19 @@
+import * as t from '@sinclair/typebox';
+export type TCallback = (schema: t.TSchema) => t.TSchema;
+export interface TMapping {
+    input: unknown;
+    output: unknown;
+}
+type TApply<Type extends t.TSchema, Mapping extends TMapping, Mapped = (Mapping & {
+    input: Type;
+})['output'], Result = Mapped extends t.TSchema ? Mapped : never> = Result;
+type TFromProperties<Properties extends t.TProperties, Mapping extends TMapping, Result extends t.TProperties = {
+    [Key in keyof Properties]: TRemap<Properties[Key], Mapping>;
+}> = Result;
+type TFromTypes<Types extends t.TSchema[], Mapping extends TMapping, Result extends t.TSchema[] = []> = (Types extends [infer Left extends t.TSchema, ...infer Right extends t.TSchema[]] ? TFromTypes<Right, Mapping, [...Result, TRemap<Left, Mapping>]> : Result);
+type TFromType<Type extends t.TSchema, Mapping extends TMapping, Result extends t.TSchema = (TApply<Type, Mapping>)> = Result;
+/** `[Internal]` Applies a recursive conditional remapping of a type and its sub type constituents */
+export type TRemap<Type extends t.TSchema, Mapping extends TMapping, Mapped extends t.TSchema = TFromType<Type, Mapping>, Result extends t.TSchema = (Mapped extends t.TConstructor<infer Parameters extends t.TSchema[], infer ReturnType extends t.TSchema> ? t.TConstructor<TFromTypes<Parameters, Mapping>, TFromType<ReturnType, Mapping>> : Mapped extends t.TFunction<infer Parameters extends t.TSchema[], infer ReturnType extends t.TSchema> ? t.TFunction<TFromTypes<Parameters, Mapping>, TFromType<ReturnType, Mapping>> : Mapped extends t.TIntersect<infer Types extends t.TSchema[]> ? t.TIntersect<TFromTypes<Types, Mapping>> : Mapped extends t.TUnion<infer Types extends t.TSchema[]> ? t.TUnion<TFromTypes<Types, Mapping>> : Mapped extends t.TTuple<infer Types extends t.TSchema[]> ? t.TTuple<TFromTypes<Types, Mapping>> : Mapped extends t.TArray<infer Type extends t.TSchema> ? t.TArray<TFromType<Type, Mapping>> : Mapped extends t.TAsyncIterator<infer Type extends t.TSchema> ? t.TAsyncIterator<TFromType<Type, Mapping>> : Mapped extends t.TIterator<infer Type extends t.TSchema> ? t.TIterator<TFromType<Type, Mapping>> : Mapped extends t.TPromise<infer Type extends t.TSchema> ? t.TPromise<TFromType<Type, Mapping>> : Mapped extends t.TObject<infer Properties extends t.TProperties> ? t.TObject<TFromProperties<Properties, Mapping>> : Mapped extends t.TRecord<infer Key extends t.TSchema, infer Value extends t.TSchema> ? t.TRecordOrObject<TFromType<Key, Mapping>, TFromType<Value, Mapping>> : Mapped)> = Result;
+/** `[Internal]` Applies a recursive conditional remapping of a type and its sub type constituents */
+export declare function Remap(type: t.TSchema, callback: TCallback): t.TSchema;
+export {};

package/build/cjs/type/remap/remap.js

@@ -0,0 +1,35 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Remap = Remap;
+const t = require("@sinclair/typebox");
+function FromProperties(properties, func) {
+    return globalThis.Object.getOwnPropertyNames(properties).reduce((result, key) => {
+        return { ...result, [key]: Remap(properties[key], func) };
+    }, {});
+}
+function FromTypes(types, callback) {
+    return types.map((type) => Remap(type, callback));
+}
+function FromType(type, callback) {
+    return callback(type);
+}
+/** `[Internal]` Applies a recursive conditional remapping of a type and its sub type constituents */
+// prettier-ignore
+function Remap(type, callback) {
+    // Map incoming type
+    const mapped = t.CloneType(FromType(type, callback));
+    // Return remapped interior
+    return (t.KindGuard.IsConstructor(type) ? t.Constructor(FromTypes(type.parameters, callback), FromType(type.returns, callback), mapped) :
+        t.KindGuard.IsFunction(type) ? t.Function(FromTypes(type.parameters, callback), FromType(type.returns, callback), mapped) :
+            t.KindGuard.IsIntersect(type) ? t.Intersect(FromTypes(type.allOf, callback), mapped) :
+                t.KindGuard.IsUnion(type) ? t.Union(FromTypes(type.anyOf, callback), mapped) :
+                    t.KindGuard.IsTuple(type) ? t.Tuple(FromTypes(type.items || [], callback), mapped) :
+                        t.KindGuard.IsArray(type) ? t.Array(FromType(type.items, callback), mapped) :
+                            t.KindGuard.IsAsyncIterator(type) ? t.AsyncIterator(FromType(type.items, callback), mapped) :
+                                t.KindGuard.IsIterator(type) ? t.Iterator(FromType(type.items, callback), mapped) :
+                                    t.KindGuard.IsPromise(type) ? t.Promise(FromType(type.items, callback), mapped) :
+                                        t.KindGuard.IsObject(type) ? t.Object(FromProperties(type.properties, callback), mapped) :
+                                            t.KindGuard.IsRecord(type) ? t.Record(FromType(t.RecordKey(type), callback), FromType(t.RecordValue(type), callback), mapped) :
+                                                t.CloneType(mapped));
+}

package/build/cjs/type/type/javascript.d.ts

@@ -1,4 +1,5 @@
 import { JsonTypeBuilder } from './json';
+import { type TArgument } from '../argument/index';
 import { type TAsyncIterator } from '../async-iterator/index';
 import { type TAwaited } from '../awaited/index';
 import { type TBigInt, type BigIntOptions } from '../bigint/index';
@@ -7,6 +8,7 @@ import { type TConstructorParameters } from '../constructor-parameters/index';
 import { type TDate, type DateOptions } from '../date/index';
 import { type TFunction } from '../function/index';
 import { type TInstanceType } from '../instance-type/index';
+import { type TInstantiate } from '../instantiate/index';
 import { type TIterator } from '../iterator/index';
 import { type TParameters } from '../parameters/index';
 import { type TPromise } from '../promise/index';
@@ -19,6 +21,8 @@ import { type TUndefined } from '../undefined/index';
 import { type TVoid } from '../void/index';
 /** JavaScript Type Builder with Static Resolution for TypeScript */
 export declare class JavaScriptTypeBuilder extends JsonTypeBuilder {
+    /** `[JavaScript]` Creates a Generic Argument Type */
+    Argument<Index extends number>(index: Index): TArgument<Index>;
     /** `[JavaScript]` Creates a AsyncIterator type */
     AsyncIterator<Type extends TSchema>(items: Type, options?: SchemaOptions): TAsyncIterator<Type>;
     /** `[JavaScript]` Constructs a type by recursively unwrapping Promise types */
@@ -35,6 +39,8 @@ export declare class JavaScriptTypeBuilder extends JsonTypeBuilder {
     Function<Parameters extends TSchema[], ReturnType extends TSchema>(parameters: [...Parameters], returnType: ReturnType, options?: SchemaOptions): TFunction<Parameters, ReturnType>;
     /** `[JavaScript]` Extracts the InstanceType from the given Constructor type */
     InstanceType<Type extends TSchema>(schema: Type, options?: SchemaOptions): TInstanceType<Type>;
+    /** `[JavaScript]` Instantiates a type with the given parameters */
+    Instantiate<Type extends TSchema, Parameters extends TSchema[]>(schema: Type, parameters: [...Parameters]): TInstantiate<Type, Parameters>;
     /** `[JavaScript]` Creates an Iterator type */
     Iterator<Type extends TSchema>(items: Type, options?: SchemaOptions): TIterator<Type>;
     /** `[JavaScript]` Extracts the Parameters from the given Function type */

package/build/cjs/type/type/javascript.js

@@ -3,92 +3,102 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.JavaScriptTypeBuilder = void 0;
 const json_1 = require("./json");
-const index_1 = require("../async-iterator/index");
-const index_2 = require("../awaited/index");
-const index_3 = require("../bigint/index");
-const index_4 = require("../constructor/index");
-const index_5 = require("../constructor-parameters/index");
-const index_6 = require("../date/index");
-const index_7 = require("../function/index");
-const index_8 = require("../instance-type/index");
-const index_9 = require("../iterator/index");
-const index_10 = require("../parameters/index");
-const index_11 = require("../promise/index");
-const index_12 = require("../regexp/index");
-const index_13 = require("../return-type/index");
-const index_14 = require("../symbol/index");
-const index_15 = require("../uint8array/index");
-const index_16 = require("../undefined/index");
-const index_17 = require("../void/index");
+const index_1 = require("../argument/index");
+const index_2 = require("../async-iterator/index");
+const index_3 = require("../awaited/index");
+const index_4 = require("../bigint/index");
+const index_5 = require("../constructor/index");
+const index_6 = require("../constructor-parameters/index");
+const index_7 = require("../date/index");
+const index_8 = require("../function/index");
+const index_9 = require("../instance-type/index");
+const index_10 = require("../instantiate/index");
+const index_11 = require("../iterator/index");
+const index_12 = require("../parameters/index");
+const index_13 = require("../promise/index");
+const index_14 = require("../regexp/index");
+const index_15 = require("../return-type/index");
+const index_16 = require("../symbol/index");
+const index_17 = require("../uint8array/index");
+const index_18 = require("../undefined/index");
+const index_19 = require("../void/index");
 /** JavaScript Type Builder with Static Resolution for TypeScript */
 class JavaScriptTypeBuilder extends json_1.JsonTypeBuilder {
+    /** `[JavaScript]` Creates a Generic Argument Type */
+    Argument(index) {
+        return (0, index_1.Argument)(index);
+    }
     /** `[JavaScript]` Creates a AsyncIterator type */
     AsyncIterator(items, options) {
-        return (0, index_1.AsyncIterator)(items, options);
+        return (0, index_2.AsyncIterator)(items, options);
     }
     /** `[JavaScript]` Constructs a type by recursively unwrapping Promise types */
     Awaited(schema, options) {
-        return (0, index_2.Awaited)(schema, options);
+        return (0, index_3.Awaited)(schema, options);
     }
     /** `[JavaScript]` Creates a BigInt type */
     BigInt(options) {
-        return (0, index_3.BigInt)(options);
+        return (0, index_4.BigInt)(options);
     }
     /** `[JavaScript]` Extracts the ConstructorParameters from the given Constructor type */
     ConstructorParameters(schema, options) {
-        return (0, index_5.ConstructorParameters)(schema, options);
+        return (0, index_6.ConstructorParameters)(schema, options);
     }
     /** `[JavaScript]` Creates a Constructor type */
     Constructor(parameters, instanceType, options) {
-        return (0, index_4.Constructor)(parameters, instanceType, options);
+        return (0, index_5.Constructor)(parameters, instanceType, options);
     }
     /** `[JavaScript]` Creates a Date type */
     Date(options = {}) {
-        return (0, index_6.Date)(options);
+        return (0, index_7.Date)(options);
     }
     /** `[JavaScript]` Creates a Function type */
     Function(parameters, returnType, options) {
-        return (0, index_7.Function)(parameters, returnType, options);
+        return (0, index_8.Function)(parameters, returnType, options);
     }
     /** `[JavaScript]` Extracts the InstanceType from the given Constructor type */
     InstanceType(schema, options) {
-        return (0, index_8.InstanceType)(schema, options);
+        return (0, index_9.InstanceType)(schema, options);
+    }
+    /** `[JavaScript]` Instantiates a type with the given parameters */
+    Instantiate(schema, parameters) {
+        return (0, index_10.Instantiate)(schema, parameters);
     }
     /** `[JavaScript]` Creates an Iterator type */
     Iterator(items, options) {
-        return (0, index_9.Iterator)(items, options);
+        return (0, index_11.Iterator)(items, options);
     }
     /** `[JavaScript]` Extracts the Parameters from the given Function type */
     Parameters(schema, options) {
-        return (0, index_10.Parameters)(schema, options);
+        return (0, index_12.Parameters)(schema, options);
     }
     /** `[JavaScript]` Creates a Promise type */
     Promise(item, options) {
-        return (0, index_11.Promise)(item, options);
+        return (0, index_13.Promise)(item, options);
     }
     /** `[JavaScript]` Creates a RegExp type */
     RegExp(unresolved, options) {
-        return (0, index_12.RegExp)(unresolved, options);
+        return (0, index_14.RegExp)(unresolved, options);
     }
     /** `[JavaScript]` Extracts the ReturnType from the given Function type */
     ReturnType(type, options) {
-        return (0, index_13.ReturnType)(type, options);
+        return (0, index_15.ReturnType)(type, options);
     }
     /** `[JavaScript]` Creates a Symbol type */
     Symbol(options) {
-        return (0, index_14.Symbol)(options);
+        return (0, index_16.Symbol)(options);
     }
     /** `[JavaScript]` Creates a Undefined type */
     Undefined(options) {
-        return (0, index_16.Undefined)(options);
+        return (0, index_18.Undefined)(options);
     }
     /** `[JavaScript]` Creates a Uint8Array type */
     Uint8Array(options) {
-        return (0, index_15.Uint8Array)(options);
+        return (0, index_17.Uint8Array)(options);
     }
     /** `[JavaScript]` Creates a Void type */
     Void(options) {
-        return (0, index_17.Void)(options);
+        return (0, index_19.Void)(options);
     }
 }
 exports.JavaScriptTypeBuilder = JavaScriptTypeBuilder;

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

@@ -1,4 +1,5 @@
 export { Any } from '../any/index';
+export { Argument } from '../argument/index';
 export { Array } from '../array/index';
 export { AsyncIterator } from '../async-iterator/index';
 export { Awaited } from '../awaited/index';
@@ -16,6 +17,7 @@ export { Extract } from '../extract/index';
 export { Function } from '../function/index';
 export { Index } from '../indexed/index';
 export { InstanceType } from '../instance-type/index';
+export { Instantiate } from '../instantiate/index';
 export { Integer } from '../integer/index';
 export { Intersect } from '../intersect/index';
 export { Capitalize, Uncapitalize, Lowercase, Uppercase } from '../intrinsic/index';
@@ -41,6 +43,7 @@ export { Record } from '../record/index';
 export { Recursive } from '../recursive/index';
 export { Ref } from '../ref/index';
 export { RegExp } from '../regexp/index';
+export { Remap } from '../remap/index';
 export { Required } from '../required/index';
 export { Rest } from '../rest/index';
 export { ReturnType } from '../return-type/index';