@sinclair/typebox 0.28.4 → 0.28.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.28.4",
+  "version": "0.28.5",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",

package/readme.md

@@ -83,7 +83,7 @@ License MIT
   - [Conditional](#types-conditional)
   - [Template](#types-template-literal)
   - [Indexed](#types-indexed)
-  - [Variadic](#types-variadic)
+  - [Rest](#types-rest)
   - [Guards](#types-guards)
   - [Unsafe](#types-unsafe)
   - [Strict](#types-strict)
@@ -872,30 +872,43 @@ const A = Type.Index(T, ['x'])                       // type A = T['x']
 
 const B = Type.Index(T, Type.KeyOf(T))               // type B = T[keyof T]
 ```
-<a name='types-variadic'></a>
+<a name='types-rest'></a>
 
-### Variadic Types
+### Rest Types
 
-Variadic types are supported with `Type.Rest`. This type will extract interior types from a tuple and return them as a flat array. This array can then be passed to other types that accept arrays as arguments.
-
-The following creates variadic functions using the Rest type.
+Rest parameters are supported with `Type.Rest`. This function is used to extract interior arrays from tuples to allow them to compose with the JavaScript spread operator `...`. This type can be used for tuple concatination and variadic function composition.
 
 ```typescript
 // TypeScript
 
-type P = [number, number]
+type T = [number, number]                            // type T = [number, number]
 
-type F1 = (param: [...P]) => void
+type C = [...T, number]                              // type C = [number, number, number]
 
-type F2 = (param: [...P, number]) => void
+type F = (...param: C) => void                       // type F = (
+                                                     //   param0: number,
+                                                     //   param1: number,
+                                                     //   param2: number,
+                                                     // ) => void
 
 // TypeBox
 
-const P = Type.Tuple([Type.Number(), Type.Number()])
-
-const F1 = Type.Function(Type.Rest(P), Type.Void())
-
-const F2 = Type.Function([...Type.Rest(P), Type.Number()], Type.Void())
+const T = Type.Tuple([                               // const T: TTuple<[
+  Type.Number(),                                     //   TNumber,
+  Type.Number()                                      //   TNumber,
+])                                                   // ]>
+
+const C = Type.Tuple([                               // const C: TTuple<[
+  ...Type.Rest(T),                                   //   TNumber,
+  Type.Number()                                      //   TNumber,
+])                                                   //   TNumber
+                                                     // ]>
+
+const F = Type.Function(Type.Rest(C), Type.Void())   // const F: TFunction<[
+                                                     //   TNumber,
+                                                     //   TNumber,
+                                                     //   TNumber
+                                                     // ], TVoid>
 ```
 <a name='types-unsafe'></a>
 

package/typebox.d.ts

@@ -181,7 +181,14 @@ export type TIndexKeys<T extends TSchema, K extends Key[]> = K extends [infer L,
     ...TIndexKeys<T, Assert<R, Key[]>>
 ] : [
 ];
-export type TIndex<T extends TSchema, K extends Key[]> = TIndexKeys<T, K> extends infer R ? T extends TRecursive<infer S> ? TIndex<S, K> : T extends TTuple ? UnionType<AssertRest<R>> : T extends TIntersect ? UnionType<AssertRest<R>> : T extends TUnion ? UnionType<AssertRest<R>> : T extends TObject ? UnionType<AssertRest<R>> : T extends TArray ? UnionType<AssertRest<R>> : TNever : TNever;
+export type TIndexFromKeyTuple<T extends TSchema, K extends Key[]> = TIndexKeys<T, K> extends infer R ? T extends TRecursive<infer S> ? TIndexFromKeyTuple<S, K> : T extends TTuple ? UnionType<AssertRest<R>> : T extends TIntersect ? UnionType<AssertRest<R>> : T extends TUnion ? UnionType<AssertRest<R>> : T extends TObject ? UnionType<AssertRest<R>> : T extends TArray ? UnionType<AssertRest<R>> : TNever : TNever;
+export type TIndex<T extends TSchema, K extends TSchema> = [
+    T,
+    K
+] extends [TTuple, TNumber] ? UnionType<Assert<T['items'], TSchema[]>> : [
+    T,
+    K
+] extends [TArray, TNumber] ? AssertType<T['items']> : K extends TTemplateLiteral ? TIndexFromKeyTuple<T, TTemplateLiteralKeyTuple<K>> : K extends TUnion<TLiteral<Key>[]> ? TIndexFromKeyTuple<T, TUnionLiteral<K>> : K extends TLiteral<Key> ? TIndexFromKeyTuple<T, [K['const']]> : TNever;
 export interface TInteger extends TSchema, NumericOptions<number> {
     [Kind]: 'Integer';
     static: number;
@@ -372,7 +379,7 @@ export type TTemplateLiteralConst<T, Acc extends string> = T extends TUnion<infe
     [K in keyof U]: TTemplateLiteralUnion<Assert<[U[K]], TTemplateLiteralKind[]>, Acc>;
 }[number] : T extends TTemplateLiteral ? `${Static<T>}` : T extends TLiteral<infer U> ? `${U}` : T extends TString ? `${string}` : T extends TNumber ? `${number}` : T extends TBigInt ? `${bigint}` : T extends TBoolean ? `${boolean}` : never;
 export type TTemplateLiteralUnion<T extends TTemplateLiteralKind[], Acc extends string = ''> = T extends [infer L, ...infer R] ? `${TTemplateLiteralConst<L, Acc>}${TTemplateLiteralUnion<Assert<R, TTemplateLiteralKind[]>, Acc>}` : Acc;
-export type TTemplateLiteralKeyArray<T extends TTemplateLiteral> = Assert<UnionToTuple<Static<T>>, Key[]>;
+export type TTemplateLiteralKeyTuple<T extends TTemplateLiteral> = Assert<UnionToTuple<Static<T>>, Key[]>;
 export interface TTemplateLiteral<T extends TTemplateLiteralKind[] = TTemplateLiteralKind[]> extends TSchema {
     [Kind]: 'TemplateLiteral';
     static: TTemplateLiteralUnion<T>;
@@ -380,11 +387,10 @@ export interface TTemplateLiteral<T extends TTemplateLiteralKind[] = TTemplateLi
     pattern: string;
 }
 export type TTupleIntoArray<T extends TTuple<TSchema[]>> = T extends TTuple<infer R> ? AssertRest<R> : never;
+export type TTupleInfer<T extends TSchema[], P extends unknown[]> = T extends [infer L, ...infer R] ? [Static<AssertType<L>, P>, ...TTupleInfer<AssertRest<R>, P>] : [];
 export interface TTuple<T extends TSchema[] = TSchema[]> extends TSchema {
     [Kind]: 'Tuple';
-    static: {
-        [K in keyof T]: T[K] extends TSchema ? Static<T[K], this['params']> : T[K];
-    };
+    static: TTupleInfer<T, this['params']>;
     type: 'array';
     items?: T;
     additionalItems?: false;
@@ -399,7 +405,8 @@ export interface TUndefined extends TSchema {
 }
 export type TLiteralUnionReduce<T extends TLiteral<string | number>[]> = T extends [infer L, ...infer R] ? [Assert<L, TLiteral<string | number>>['const'], ...TLiteralUnionReduce<Assert<R, TLiteral<string | number>[]>>] : [
 ];
-export type TLiteralUnion<T extends TUnion<TLiteral<string | number>[]>> = T extends TUnion<infer S> ? TLiteralUnionReduce<Assert<S, TLiteral<string | number>[]>> : [];
+export type TUnionLiteral<T extends TUnion<TLiteral<string | number>[]>> = T extends TUnion<infer S> ? TLiteralUnionReduce<Assert<S, TLiteral<string | number>[]>> : [
+];
 export type TUnionTemplateLiteral<T extends TTemplateLiteral, S extends string = Static<T>> = Ensure<UnionType<Assert<UnionToTuple<{
     [K in S]: TLiteral<K>;
 }[S]>, TLiteral[]>>>;
@@ -501,8 +508,6 @@ export declare namespace TypeGuard {
     function TLiteralNumber(schema: unknown): schema is TLiteral<number>;
     /** Returns true if the given schema is TLiteral<boolean> */
     function TLiteralBoolean(schema: unknown): schema is TLiteral<boolean>;
-    /** Returns true if the given schema is TUnion<Literal<string | number>[]> */
-    function TLiteralUnion(schema: unknown): schema is TUnion<TLiteral[]>;
     /** Returns true if the given schema is TLiteral */
     function TLiteral(schema: unknown): schema is TLiteral;
     /** Returns true if the given schema is TNever */
@@ -533,6 +538,8 @@ export declare namespace TypeGuard {
     function TTuple(schema: unknown): schema is TTuple;
     /** Returns true if the given schema is TUndefined */
     function TUndefined(schema: unknown): schema is TUndefined;
+    /** Returns true if the given schema is TUnion<Literal<string | number>[]> */
+    function TUnionLiteral(schema: unknown): schema is TUnion<TLiteral[]>;
     /** Returns true if the given schema is TUnion */
     function TUnion(schema: unknown): schema is TUnion;
     /** Returns true if the given schema is TUint8Array */
@@ -657,19 +664,9 @@ export declare class StandardTypeBuilder extends TypeBuilder {
     /** `[Standard]` Extracts from the left type any type that is assignable to the right */
     Extract<L extends TSchema, R extends TSchema>(left: L, right: R, options?: SchemaOptions): TExtract<L, R>;
     /** `[Standard]` Returns indexed property types for the given keys */
-    Index<T extends TSchema, K extends (keyof Static<T>)[]>(schema: T, keys: [...K], options?: SchemaOptions): TIndex<T, Assert<K, Key[]>>;
-    /** `[Standard]` Returns indexed property types for the given keys */
-    Index<T extends TSchema, K extends TUnion<TLiteral<Key>[]>>(schema: T, keys: K, options?: SchemaOptions): TIndex<T, TLiteralUnion<K>>;
-    /** `[Standard]` Returns indexed property types for the given keys */
-    Index<T extends TSchema, K extends TLiteral<Key>>(schema: T, key: K, options?: SchemaOptions): TIndex<T, [K['const']]>;
-    /** `[Standard]` Returns indexed property types for the given keys */
-    Index<T extends TSchema, K extends TTemplateLiteral>(schema: T, key: K, options?: SchemaOptions): TIndex<T, TTemplateLiteralKeyArray<K>>;
-    /** `[Standard]` Returns indexed property types for the given keys */
-    Index<T extends TTuple, K extends TNumber>(schema: T, key: K, options?: SchemaOptions): UnionType<Assert<T['items'], TSchema[]>>;
-    /** `[Standard]` Returns indexed property types for the given keys */
-    Index<T extends TArray, K extends TNumber>(schema: T, key: K, options?: SchemaOptions): AssertType<T['items']>;
+    Index<T extends TSchema, K extends (keyof Static<T>)[]>(schema: T, keys: [...K], options?: SchemaOptions): TIndexFromKeyTuple<T, Assert<K, Key[]>>;
     /** `[Standard]` Returns indexed property types for the given keys */
-    Index<T extends TSchema, K extends TNever>(schema: T, key: K, options?: SchemaOptions): TIndex<T, never>;
+    Index<T extends TSchema, K extends TSchema>(schema: T, key: K, options?: SchemaOptions): TIndex<T, K>;
     /** `[Standard]` Creates an Integer type */
     Integer(options?: NumericOptions<number>): TInteger;
     /** `[Standard]` Creates a Intersect type */
@@ -694,11 +691,11 @@ export declare class StandardTypeBuilder extends TypeBuilder {
     /** `[Standard]` Creates a mapped type whose keys are omitted from the given type */
     Omit<T extends TSchema, K extends (keyof Static<T>)[]>(schema: T, keys: readonly [...K], options?: SchemaOptions): TOmit<T, K[number]>;
     /** `[Standard]` Creates a mapped type whose keys are omitted from the given type */
-    Omit<T extends TSchema, K extends TUnion<TLiteral<string>[]>>(schema: T, keys: K, options?: SchemaOptions): TOmit<T, TLiteralUnion<K>[number]>;
+    Omit<T extends TSchema, K extends TUnion<TLiteral<string>[]>>(schema: T, keys: K, options?: SchemaOptions): TOmit<T, TUnionLiteral<K>[number]>;
     /** `[Standard]` Creates a mapped type whose keys are omitted from the given type */
     Omit<T extends TSchema, K extends TLiteral<string>>(schema: T, key: K, options?: SchemaOptions): TOmit<T, K['const']>;
     /** `[Standard]` Creates a mapped type whose keys are omitted from the given type */
-    Omit<T extends TSchema, K extends TTemplateLiteral>(schema: T, key: K, options?: SchemaOptions): TOmit<T, TTemplateLiteralKeyArray<K>[number]>;
+    Omit<T extends TSchema, K extends TTemplateLiteral>(schema: T, key: K, options?: SchemaOptions): TOmit<T, TTemplateLiteralKeyTuple<K>[number]>;
     /** `[Standard]` Creates a mapped type whose keys are omitted from the given type */
     Omit<T extends TSchema, K extends TNever>(schema: T, key: K, options?: SchemaOptions): TOmit<T, never>;
     /** `[Standard]` Creates a mapped type where all properties are Optional */
@@ -706,11 +703,11 @@ export declare class StandardTypeBuilder extends TypeBuilder {
     /** `[Standard]` Creates a mapped type whose keys are picked from the given type */
     Pick<T extends TSchema, K extends (keyof Static<T>)[]>(schema: T, keys: readonly [...K], options?: SchemaOptions): TPick<T, K[number]>;
     /** `[Standard]` Creates a mapped type whose keys are picked from the given type */
-    Pick<T extends TSchema, K extends TUnion<TLiteral<string>[]>>(schema: T, keys: K, options?: SchemaOptions): TPick<T, TLiteralUnion<K>[number]>;
+    Pick<T extends TSchema, K extends TUnion<TLiteral<string>[]>>(schema: T, keys: K, options?: SchemaOptions): TPick<T, TUnionLiteral<K>[number]>;
     /** `[Standard]` Creates a mapped type whose keys are picked from the given type */
     Pick<T extends TSchema, K extends TLiteral<string>>(schema: T, key: K, options?: SchemaOptions): TPick<T, K['const']>;
     /** `[Standard]` Creates a mapped type whose keys are picked from the given type */
-    Pick<T extends TSchema, K extends TTemplateLiteral>(schema: T, key: K, options?: SchemaOptions): TPick<T, TTemplateLiteralKeyArray<K>[number]>;
+    Pick<T extends TSchema, K extends TTemplateLiteral>(schema: T, key: K, options?: SchemaOptions): TPick<T, TTemplateLiteralKeyTuple<K>[number]>;
     /** `[Standard]` Creates a mapped type whose keys are picked from the given type */
     Pick<T extends TSchema, K extends TNever>(schema: T, key: K, options?: SchemaOptions): TPick<T, never>;
     /** `[Standard]` Creates a Record type */

package/typebox.js

@@ -324,11 +324,6 @@ var TypeGuard;
         return TKind(schema) && schema[exports.Kind] === 'Literal' && IsOptionalString(schema.$id) && typeof schema.const === 'boolean';
     }
     TypeGuard.TLiteralBoolean = TLiteralBoolean;
-    /** Returns true if the given schema is TUnion<Literal<string | number>[]> */
-    function TLiteralUnion(schema) {
-        return TUnion(schema) && schema.anyOf.every((schema) => TLiteralString(schema) || TLiteralNumber(schema));
-    }
-    TypeGuard.TLiteralUnion = TLiteralUnion;
     /** Returns true if the given schema is TLiteral */
     function TLiteral(schema) {
         return TLiteralString(schema) || TLiteralNumber(schema) || TLiteralBoolean(schema);
@@ -515,6 +510,11 @@ var TypeGuard;
             IsOptionalString(schema.$id));
     }
     TypeGuard.TUndefined = TUndefined;
+    /** Returns true if the given schema is TUnion<Literal<string | number>[]> */
+    function TUnionLiteral(schema) {
+        return TUnion(schema) && schema.anyOf.every((schema) => TLiteralString(schema) || TLiteralNumber(schema));
+    }
+    TypeGuard.TUnionLiteral = TUnionLiteral;
     /** Returns true if the given schema is TUnion */
     function TUnion(schema) {
         // prettier-ignore
@@ -1519,7 +1519,7 @@ var KeyArrayResolver;
     function Resolve(schema) {
         if (globalThis.Array.isArray(schema))
             return schema;
-        if (TypeGuard.TLiteralUnion(schema))
+        if (TypeGuard.TUnionLiteral(schema))
             return schema.anyOf.map((schema) => schema.const.toString());
         if (TypeGuard.TLiteral(schema))
             return [schema.const];
@@ -2138,7 +2138,7 @@ class StandardTypeBuilder extends TypeBuilder {
         }
         else if (TypeGuard.TUnion(key)) {
             const union = UnionResolver.Resolve(key);
-            if (TypeGuard.TLiteralUnion(union)) {
+            if (TypeGuard.TUnionLiteral(union)) {
                 const properties = union.anyOf.reduce((acc, literal) => ({ ...acc, [literal.const]: TypeClone.Clone(schema, {}) }), {});
                 return this.Object(properties, { ...options, [exports.Hint]: 'Record' });
             }