Add TupleToObject type (#1055)

Author: som-sm

index.d.ts

@@ -104,6 +104,7 @@ export type {HasWritableKeys} from './source/has-writable-keys';
 export type {Spread} from './source/spread';
 export type {IsInteger} from './source/is-integer';
 export type {IsFloat} from './source/is-float';
+export type {TupleToObject} from './source/tuple-to-object';
 export type {TupleToUnion} from './source/tuple-to-union';
 export type {UnionToTuple} from './source/union-to-tuple';
 export type {IntRange} from './source/int-range';

readme.md

@@ -292,6 +292,7 @@ type ShouldBeNever = IfAny<'not any', 'not never', 'never'>;
 - [`ReadonlyTuple`](source/readonly-tuple.d.ts) - Create a type that represents a read-only tuple of the given type and length.
 - [`TupleToUnion`](source/tuple-to-union.d.ts) - Convert a tuple/array into a union type of its elements.
 - [`UnionToTuple`](source/union-to-tuple.d.ts) - Convert a union type into an unordered tuple type of its elements.
+- [`TupleToObject`](source/tuple-to-object.d.ts) - Transforms a tuple into an object, mapping each tuple index to its corresponding type as a key-value pair.
 
 ### Numeric
 

source/tuple-to-object.d.ts

@@ -0,0 +1,42 @@
+import type {IsTuple} from './is-tuple';
+import type {UnknownArray} from './unknown-array';
+import type {IfAny} from './if-any';
+
+/**
+Transforms a tuple into an object, mapping each tuple index to its corresponding type as a key-value pair.
+
+Note: Tuple labels are [lost in the transformation process](https://stackoverflow.com/a/70398429/11719314). For example, `TupleToObject<[x: number, y: number]>` produces `{0: number; 1: number}`, and not `{x: number; y: number}`.
+
+@example
+```
+type Example1 = TupleToObject<[number, string, boolean]>;
+//=> { 0: number; 1: string; 2: boolean }
+
+// Tuples with optional indices
+type Example2 = TupleToObject<[number, string?, boolean?]>;
+//=> { 0: number; 1?: string; 2?: boolean }
+
+// Readonly tuples
+type Example3 = TupleToObject<readonly [number, string?]>;
+//=> { readonly 0: number; readonly 1?: string }
+
+// Non-tuple arrays get transformed into index signatures
+type Example4 = TupleToObject<string[]>;
+//=> { [x: number]: string }
+
+// Tuples with rest elements
+type Example5 = TupleToObject<[number, string, ...boolean[]]>;
+//=> { [x: number]: number | string | boolean; 0: number; 1: string }
+
+// Tuple labels are not preserved
+type Example6 = TupleToObject<[x: number, y: number]>;
+//=> { 0: number; 1: number }
+```
+
+@category Array
+*/
+export type TupleToObject<TArray extends UnknownArray> = IfAny<TArray, any, {
+	[
+	Key in keyof TArray as Key & (`${number}` | (IsTuple<TArray> extends true ? never : number))
+	]: TArray[Key];
+}>;

test-d/tuple-to-object.ts

@@ -0,0 +1,62 @@
+import {expectType} from 'tsd';
+import type {TupleToObject} from '../source/tuple-to-object';
+
+// Tuples
+expectType<TupleToObject<[]>>({} as {});
+expectType<TupleToObject<[number]>>({} as {0: number});
+expectType<TupleToObject<[number, string]>>({} as {0: number; 1: string});
+expectType<TupleToObject<[number | string, {foo: string}]>>({} as {0: number | string; 1: {foo: string}});
+expectType<TupleToObject<[number, string?]>>({} as {0: number; 1?: string});
+expectType<TupleToObject<[number?, string?, boolean?]>>({} as {0?: number; 1?: string; 2?: boolean});
+
+// Readonly tuples
+expectType<TupleToObject<readonly []>>({} as {});
+expectType<TupleToObject<readonly [number, string]>>({} as {readonly 0: number; readonly 1: string});
+expectType<TupleToObject<readonly [number, string?, boolean?]>>({} as {readonly 0: number; readonly 1?: string; readonly 2?: boolean});
+
+// Non-tuples
+expectType<TupleToObject<number[]>>({} as Record<number, number>);
+expectType<TupleToObject<[...boolean[]]>>({} as Record<number, boolean>);
+expectType<TupleToObject<[number, string, ...boolean[]]>>({} as {[x: number]: number | string | boolean; 0: number; 1: string});
+expectType<TupleToObject<[number, string?, ...boolean[]]>>({} as {[x: number]: number | string | boolean | undefined; 0: number; 1?: string});
+expectType<TupleToObject<[...number[], string, bigint]>>({} as Record<number, number | string | bigint>);
+expectType<TupleToObject<never[]>>({} as Record<number, never>);
+expectType<TupleToObject<any[]>>({} as Record<number, any>);
+
+// Readonly non-tuples
+expectType<TupleToObject<readonly number[]>>({} as Readonly<Record<number, number>>);
+expectType<TupleToObject<readonly [number, string?, ...boolean[]]>>({} as {readonly [x: number]: number | string | boolean | undefined; readonly 0: number; readonly 1?: string});
+expectType<TupleToObject<readonly [...number[], string, bigint]>>({} as Readonly<Record<number, number | string | bigint>>);
+
+// Unions
+expectType<TupleToObject<[number] | [number, string, boolean]>>(
+	{} as {0: number} | {0: number; 1: string; 2: boolean},
+);
+expectType<TupleToObject<[number?, string?] | [] | [number, string, ...number[]]>>(
+	{} as {0?: number; 1?: string} | {} | {[x: number]: number | string; 0: number; 1: string},
+);
+expectType<TupleToObject<Array<number | undefined> | string[]>>(
+	{} as Record<number, number | undefined> | Record<number, string>,
+);
+expectType<TupleToObject<[number, string] | readonly string[]>>(
+	{} as {0: number; 1: string} | Readonly<Record<number, string>>,
+);
+expectType<TupleToObject<readonly [string] | readonly [number?] | number[]>>(
+	{} as {readonly 0: string} | {readonly 0?: number} | Record<number, number>,
+);
+expectType<TupleToObject<[...number[], string] | [number?, string?, ...number[]]>>(
+	{} as Record<number, string | number> | {[x: number]: string | number | undefined; 0?: number; 1?: string},
+);
+
+// Labeled tuples
+expectType<TupleToObject<[x: string, y: number]>>({} as {0: string; 1: number});
+expectType<TupleToObject<[first: string, ...rest: number[]]>>({} as {[x: number]: string | number; 0: string});
+expectType<TupleToObject<[...rest: number[], last: string]>>({} as Record<number, string | number>);
+expectType<TupleToObject<readonly [name: string, age?: number]>>({} as {readonly 0: string; readonly 1?: number});
+
+// Boundary types
+expectType<TupleToObject<any>>({} as any);
+expectType<TupleToObject<never>>({} as never);
+
+// @ts-expect-error only works with arrays
+type T = TupleToObject<{}>;