@sinclair/typebox 0.34.17 → 0.34.19

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

@@ -1,19 +1,30 @@
-import * as t from '@sinclair/typebox';
-export type TCallback = (schema: t.TSchema) => t.TSchema;
+import { TSchema } from '../schema/index';
+import { TObject, TProperties } from '../object/index';
+import { TConstructor } from '../constructor/index';
+import { TFunction } from '../function/index';
+import { TIntersect } from '../intersect/index';
+import { TUnion } from '../union/index';
+import { TTuple } from '../tuple/index';
+import { TArray } from '../array/index';
+import { TAsyncIterator } from '../async-iterator/index';
+import { TIterator } from '../iterator/index';
+import { TPromise } from '../promise/index';
+import { TRecord, TRecordOrObject } from '../record/index';
+export type TCallback = (schema: TSchema) => TSchema;
 export interface TMapping {
     input: unknown;
     output: unknown;
 }
-type TApply<Type extends t.TSchema, Mapping extends TMapping, Mapped = (Mapping & {
+type TApply<Type extends 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 = {
+})['output'], Result = Mapped extends TSchema ? Mapped : never> = Result;
+type TFromProperties<Properties extends TProperties, Mapping extends TMapping, Result extends 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;
+type TFromTypes<Types extends TSchema[], Mapping extends TMapping, Result extends TSchema[] = []> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TFromTypes<Right, Mapping, [...Result, TRemap<Left, Mapping>]> : Result);
+type TFromType<Type extends TSchema, Mapping extends TMapping, Result extends 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;
+export type TRemap<Type extends TSchema, Mapping extends TMapping, Mapped extends TSchema = TFromType<Type, Mapping>, Result extends TSchema = (Mapped extends TConstructor<infer Parameters extends TSchema[], infer ReturnType extends TSchema> ? TConstructor<TFromTypes<Parameters, Mapping>, TFromType<ReturnType, Mapping>> : Mapped extends TFunction<infer Parameters extends TSchema[], infer ReturnType extends TSchema> ? TFunction<TFromTypes<Parameters, Mapping>, TFromType<ReturnType, Mapping>> : Mapped extends TIntersect<infer Types extends TSchema[]> ? TIntersect<TFromTypes<Types, Mapping>> : Mapped extends TUnion<infer Types extends TSchema[]> ? TUnion<TFromTypes<Types, Mapping>> : Mapped extends TTuple<infer Types extends TSchema[]> ? TTuple<TFromTypes<Types, Mapping>> : Mapped extends TArray<infer Type extends TSchema> ? TArray<TFromType<Type, Mapping>> : Mapped extends TAsyncIterator<infer Type extends TSchema> ? TAsyncIterator<TFromType<Type, Mapping>> : Mapped extends TIterator<infer Type extends TSchema> ? TIterator<TFromType<Type, Mapping>> : Mapped extends TPromise<infer Type extends TSchema> ? TPromise<TFromType<Type, Mapping>> : Mapped extends TObject<infer Properties extends TProperties> ? TObject<TFromProperties<Properties, Mapping>> : Mapped extends TRecord<infer Key extends TSchema, infer Value extends TSchema> ? 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 declare function Remap(type: TSchema, callback: TCallback): TSchema;
 export {};

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

@@ -2,7 +2,19 @@
 
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Remap = Remap;
-const t = require("@sinclair/typebox");
+const index_1 = require("../object/index");
+const index_2 = require("../constructor/index");
+const index_3 = require("../function/index");
+const index_4 = require("../intersect/index");
+const index_5 = require("../union/index");
+const index_6 = require("../tuple/index");
+const index_7 = require("../array/index");
+const index_8 = require("../async-iterator/index");
+const index_9 = require("../iterator/index");
+const index_10 = require("../promise/index");
+const index_11 = require("../record/index");
+const KindGuard = require("../guard/kind");
+const type_1 = require("../clone/type");
 function FromProperties(properties, func) {
     return globalThis.Object.getOwnPropertyNames(properties).reduce((result, key) => {
         return { ...result, [key]: Remap(properties[key], func) };
@@ -18,18 +30,18 @@ function FromType(type, callback) {
 // prettier-ignore
 function Remap(type, callback) {
     // Map incoming type
-    const mapped = t.CloneType(FromType(type, callback));
+    const mapped = (0, type_1.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));
+    return (KindGuard.IsConstructor(type) ? (0, index_2.Constructor)(FromTypes(type.parameters, callback), FromType(type.returns, callback), mapped) :
+        KindGuard.IsFunction(type) ? (0, index_3.Function)(FromTypes(type.parameters, callback), FromType(type.returns, callback), mapped) :
+            KindGuard.IsIntersect(type) ? (0, index_4.Intersect)(FromTypes(type.allOf, callback), mapped) :
+                KindGuard.IsUnion(type) ? (0, index_5.Union)(FromTypes(type.anyOf, callback), mapped) :
+                    KindGuard.IsTuple(type) ? (0, index_6.Tuple)(FromTypes(type.items || [], callback), mapped) :
+                        KindGuard.IsArray(type) ? (0, index_7.Array)(FromType(type.items, callback), mapped) :
+                            KindGuard.IsAsyncIterator(type) ? (0, index_8.AsyncIterator)(FromType(type.items, callback), mapped) :
+                                KindGuard.IsIterator(type) ? (0, index_9.Iterator)(FromType(type.items, callback), mapped) :
+                                    KindGuard.IsPromise(type) ? (0, index_10.Promise)(FromType(type.items, callback), mapped) :
+                                        KindGuard.IsObject(type) ? (0, index_1.Object)(FromProperties(type.properties, callback), mapped) :
+                                            KindGuard.IsRecord(type) ? (0, index_11.Record)(FromType((0, index_11.RecordKey)(type), callback), FromType((0, index_11.RecordValue)(type), callback), mapped) :
+                                                (0, type_1.CloneType)(mapped));
 }

package/build/esm/type/remap/remap.d.mts

@@ -1,19 +1,30 @@
-import * as t from '@sinclair/typebox.mjs';
-export type TCallback = (schema: t.TSchema) => t.TSchema;
+import { TSchema } from '../schema/index.mjs';
+import { TObject, TProperties } from '../object/index.mjs';
+import { TConstructor } from '../constructor/index.mjs';
+import { TFunction } from '../function/index.mjs';
+import { TIntersect } from '../intersect/index.mjs';
+import { TUnion } from '../union/index.mjs';
+import { TTuple } from '../tuple/index.mjs';
+import { TArray } from '../array/index.mjs';
+import { TAsyncIterator } from '../async-iterator/index.mjs';
+import { TIterator } from '../iterator/index.mjs';
+import { TPromise } from '../promise/index.mjs';
+import { TRecord, TRecordOrObject } from '../record/index.mjs';
+export type TCallback = (schema: TSchema) => TSchema;
 export interface TMapping {
     input: unknown;
     output: unknown;
 }
-type TApply<Type extends t.TSchema, Mapping extends TMapping, Mapped = (Mapping & {
+type TApply<Type extends 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 = {
+})['output'], Result = Mapped extends TSchema ? Mapped : never> = Result;
+type TFromProperties<Properties extends TProperties, Mapping extends TMapping, Result extends 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;
+type TFromTypes<Types extends TSchema[], Mapping extends TMapping, Result extends TSchema[] = []> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TFromTypes<Right, Mapping, [...Result, TRemap<Left, Mapping>]> : Result);
+type TFromType<Type extends TSchema, Mapping extends TMapping, Result extends 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;
+export type TRemap<Type extends TSchema, Mapping extends TMapping, Mapped extends TSchema = TFromType<Type, Mapping>, Result extends TSchema = (Mapped extends TConstructor<infer Parameters extends TSchema[], infer ReturnType extends TSchema> ? TConstructor<TFromTypes<Parameters, Mapping>, TFromType<ReturnType, Mapping>> : Mapped extends TFunction<infer Parameters extends TSchema[], infer ReturnType extends TSchema> ? TFunction<TFromTypes<Parameters, Mapping>, TFromType<ReturnType, Mapping>> : Mapped extends TIntersect<infer Types extends TSchema[]> ? TIntersect<TFromTypes<Types, Mapping>> : Mapped extends TUnion<infer Types extends TSchema[]> ? TUnion<TFromTypes<Types, Mapping>> : Mapped extends TTuple<infer Types extends TSchema[]> ? TTuple<TFromTypes<Types, Mapping>> : Mapped extends TArray<infer Type extends TSchema> ? TArray<TFromType<Type, Mapping>> : Mapped extends TAsyncIterator<infer Type extends TSchema> ? TAsyncIterator<TFromType<Type, Mapping>> : Mapped extends TIterator<infer Type extends TSchema> ? TIterator<TFromType<Type, Mapping>> : Mapped extends TPromise<infer Type extends TSchema> ? TPromise<TFromType<Type, Mapping>> : Mapped extends TObject<infer Properties extends TProperties> ? TObject<TFromProperties<Properties, Mapping>> : Mapped extends TRecord<infer Key extends TSchema, infer Value extends TSchema> ? 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 declare function Remap(type: TSchema, callback: TCallback): TSchema;
 export {};

package/build/esm/type/remap/remap.mjs

@@ -1,4 +1,16 @@
-import * as t from '@sinclair/typebox.mjs';
+import { Object } from '../object/index.mjs';
+import { Constructor } from '../constructor/index.mjs';
+import { Function } from '../function/index.mjs';
+import { Intersect } from '../intersect/index.mjs';
+import { Union } from '../union/index.mjs';
+import { Tuple } from '../tuple/index.mjs';
+import { Array } from '../array/index.mjs';
+import { AsyncIterator } from '../async-iterator/index.mjs';
+import { Iterator } from '../iterator/index.mjs';
+import { Promise } from '../promise/index.mjs';
+import { Record, RecordKey, RecordValue } from '../record/index.mjs';
+import * as KindGuard from '../guard/kind.mjs';
+import { CloneType } from '../clone/type.mjs';
 function FromProperties(properties, func) {
     return globalThis.Object.getOwnPropertyNames(properties).reduce((result, key) => {
         return { ...result, [key]: Remap(properties[key], func) };
@@ -14,18 +26,18 @@ function FromType(type, callback) {
 // prettier-ignore
 export function Remap(type, callback) {
     // Map incoming type
-    const mapped = t.CloneType(FromType(type, callback));
+    const mapped = 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));
+    return (KindGuard.IsConstructor(type) ? Constructor(FromTypes(type.parameters, callback), FromType(type.returns, callback), mapped) :
+        KindGuard.IsFunction(type) ? Function(FromTypes(type.parameters, callback), FromType(type.returns, callback), mapped) :
+            KindGuard.IsIntersect(type) ? Intersect(FromTypes(type.allOf, callback), mapped) :
+                KindGuard.IsUnion(type) ? Union(FromTypes(type.anyOf, callback), mapped) :
+                    KindGuard.IsTuple(type) ? Tuple(FromTypes(type.items || [], callback), mapped) :
+                        KindGuard.IsArray(type) ? Array(FromType(type.items, callback), mapped) :
+                            KindGuard.IsAsyncIterator(type) ? AsyncIterator(FromType(type.items, callback), mapped) :
+                                KindGuard.IsIterator(type) ? Iterator(FromType(type.items, callback), mapped) :
+                                    KindGuard.IsPromise(type) ? Promise(FromType(type.items, callback), mapped) :
+                                        KindGuard.IsObject(type) ? Object(FromProperties(type.properties, callback), mapped) :
+                                            KindGuard.IsRecord(type) ? Record(FromType(RecordKey(type), callback), FromType(RecordValue(type), callback), mapped) :
+                                                CloneType(mapped));
 }

package/package.json

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

package/readme.md

@@ -1390,25 +1390,26 @@ const S = Syntax({ T }, `{ x: T, y: T, z: T }`)     // const S: TObject<{
 
 ### Generics
 
-Generic types can be created by passing Argument types as parameters.
+Generic types can be created using Argument types.
 
 ```typescript
-// Generic Vector Type
-
-const Vector = Syntax({                             // type Vector<X, Y, Z> = {
-  X: Type.Argument(0),                              //   x: X
-  Y: Type.Argument(1),                              //   y: Y,
-  Z: Type.Argument(2)                               //   z: Z
-},                                                  // }
-`{                            
-  x: X,
-  y: Y,
-  z: Z
+const Vector = Syntax(`{
+  x: Argument<0>,
+  y: Argument<1>,
+  z: Argument<2>
 }`)
 
-// Instanced Vector Type 
+const Basis = Syntax({ Vector }, `{
+  x: Vector<1, 0, 0>,
+  y: Vector<0, 1, 0>,
+  z: Vector<0, 0, 1>,
+}`)
 
-const Up = Syntax({ Vector }, `Vector<0, 1, 0>`)    // type Up = Vector<0, 1, 0>
+type Basis = Static<typeof Basis>                   // type Basis = {
+                                                    //   x: { x: 1, y: 0, z: 0 },
+                                                    //   y: { x: 0, y: 1, z: 0 },
+                                                    //   z: { x: 0, y: 0, z: 1 }
+                                                    // } 
 ```
 
 <a name='typeregistry'></a>