style: rename BuildTuple to TupleOf

Author: som-sm

index.d.ts

@@ -157,7 +157,7 @@ export type {IsLowercase} from './source/is-lowercase.d.ts';
 export type {IsUppercase} from './source/is-uppercase.d.ts';
 export type {IsOptional} from './source/is-optional.d.ts';
 export type {IsNullable} from './source/is-nullable.d.ts';
-export type {BuildTuple} from './source/build-tuple.d.ts';
+export type {TupleOf} from './source/tuple-of.js';
 
 // Template literal types
 export type {CamelCase, CamelCaseOptions} from './source/camel-case.d.ts';

readme.md

@@ -256,7 +256,7 @@ Click the type names for complete docs.
 - [`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.
-- [`BuildTuple`](source/build-tuple.d.ts) - Creates a tuple type of the specified length with elements of the specified type.
+- [`TupleOf`](source/tuple-of.d.ts) - Creates a tuple type of the specified length with elements of the specified type.
 
 ### Numeric
 

source/array-splice.d.ts

@@ -2,15 +2,15 @@ import type {StaticPartOfArray, VariablePartOfArray} from './internal/index.d.ts
 import type {GreaterThanOrEqual} from './greater-than-or-equal.d.ts';
 import type {Subtract} from './subtract.d.ts';
 import type {UnknownArray} from './unknown-array.d.ts';
-import type {BuildTuple} from './build-tuple.d.ts';
+import type {TupleOf} from './tuple-of.d.ts';
 
 /**
 The implementation of `SplitArrayByIndex` for fixed length arrays.
 */
 type SplitFixedArrayByIndex<T extends UnknownArray, SplitIndex extends number> =
 SplitIndex extends 0
 	? [[], T]
-	: T extends readonly [...BuildTuple<SplitIndex>, ...infer V]
+	: T extends readonly [...TupleOf<SplitIndex>, ...infer V]
 		? T extends readonly [...infer U, ...V]
 			? [U, V]
 			: [never, never]
@@ -23,7 +23,7 @@ type SplitVariableArrayByIndex<T extends UnknownArray,
 	SplitIndex extends number,
 	T1 = Subtract<SplitIndex, StaticPartOfArray<T>['length']>,
 	T2 = T1 extends number
-		? BuildTuple<GreaterThanOrEqual<T1, 0> extends true ? T1 : number, VariablePartOfArray<T>[number]>
+		? TupleOf<GreaterThanOrEqual<T1, 0> extends true ? T1 : number, VariablePartOfArray<T>[number]>
 		: [],
 > =
 SplitIndex extends 0

source/int-range.d.ts

@@ -1,4 +1,4 @@
-import type {BuildTuple} from './build-tuple.d.ts';
+import type {TupleOf} from './tuple-of.d.ts';
 import type {Subtract} from './subtract.d.ts';
 
 /**
@@ -44,16 +44,16 @@ type PrivateIntRange<
 	// The gap between each number, gap = step - 1
 	Gap extends number = Subtract<Step, 1>,
 	// The final `List` is `[...StartLengthTuple, ...[number, ...GapLengthTuple], ...[number, ...GapLengthTuple], ... ...]`, so can initialize the `List` with `[...StartLengthTuple]`
-	List extends unknown[] = BuildTuple<Start, never>,
-	EndLengthTuple extends unknown[] = BuildTuple<End>,
+	List extends unknown[] = TupleOf<Start, never>,
+	EndLengthTuple extends unknown[] = TupleOf<End>,
 > = Gap extends 0 ?
 	// Handle the case that without `Step`
 	List['length'] extends End // The result of "List[length] === End"
 		? Exclude<List[number], never> // All unused elements are `never`, so exclude them
 		: PrivateIntRange<Start, End, Step, Gap, [...List, List['length'] ]>
 	// Handle the case that with `Step`
-	: List extends [...(infer U), ...EndLengthTuple] // The result of "List[length] >= End", because the `...BuildTuple<Gap, never>` maybe make `List` too long.
+	: List extends [...(infer U), ...EndLengthTuple] // The result of "List[length] >= End", because the `...TupleOf<Gap, never>` maybe make `List` too long.
 		? Exclude<List[number], never>
-		: PrivateIntRange<Start, End, Step, Gap, [...List, List['length'], ...BuildTuple<Gap, never>]>;
+		: PrivateIntRange<Start, End, Step, Gap, [...List, List['length'], ...TupleOf<Gap, never>]>;
 
 export {};

source/internal/string.d.ts

@@ -1,4 +1,4 @@
-import type {BuildTuple} from '../build-tuple.d.ts';
+import type {TupleOf} from '../tuple-of.d.ts';
 import type {NegativeInfinity, PositiveInfinity} from '../numeric.d.ts';
 import type {Trim} from '../trim.d.ts';
 import type {Whitespace} from './characters.d.ts';
@@ -171,7 +171,7 @@ PositiveNumericStringGt<'1', '500'>;
 */
 export type PositiveNumericStringGt<A extends string, B extends string> = A extends B
 	? false
-	: [BuildTuple<StringLength<A>, 0>, BuildTuple<StringLength<B>, 0>] extends infer R extends [readonly unknown[], readonly unknown[]]
+	: [TupleOf<StringLength<A>, 0>, TupleOf<StringLength<B>, 0>] extends infer R extends [readonly unknown[], readonly unknown[]]
 		? R[0] extends [...R[1], ...infer Remain extends readonly unknown[]]
 			? 0 extends Remain['length']
 				? SameLengthPositiveNumericStringGt<A, B>

source/pick-deep.d.ts

@@ -1,4 +1,4 @@
-import type {BuildTuple} from './build-tuple.d.ts';
+import type {TupleOf} from './tuple-of.d.ts';
 import type {BuildObject, NonRecursiveType, ObjectValue} from './internal/index.d.ts';
 import type {IsNever} from './is-never.d.ts';
 import type {Paths} from './paths.d.ts';
@@ -132,9 +132,9 @@ type PickDeepArray<ArrayType extends UnknownArray, P extends string | number> =
 					: never
 			// When `ArrayIndex` is a number literal
 			: ArrayType extends unknown[]
-				? [...BuildTuple<ArrayIndex>, InternalPickDeep<NonNullable<ArrayType[ArrayIndex]>, SubPath>]
+				? [...TupleOf<ArrayIndex>, InternalPickDeep<NonNullable<ArrayType[ArrayIndex]>, SubPath>]
 				: ArrayType extends readonly unknown[]
-					? readonly [...BuildTuple<ArrayIndex>, InternalPickDeep<NonNullable<ArrayType[ArrayIndex]>, SubPath>]
+					? readonly [...TupleOf<ArrayIndex>, InternalPickDeep<NonNullable<ArrayType[ArrayIndex]>, SubPath>]
 					: never
 		// When the path is equal to `number`
 		: P extends `${infer ArrayIndex extends number}`
@@ -143,9 +143,9 @@ type PickDeepArray<ArrayType extends UnknownArray, P extends string | number> =
 				? ArrayType
 				// When `ArrayIndex` is a number literal
 				: ArrayType extends unknown[]
-					? [...BuildTuple<ArrayIndex>, ArrayType[ArrayIndex]]
+					? [...TupleOf<ArrayIndex>, ArrayType[ArrayIndex]]
 					: ArrayType extends readonly unknown[]
-						? readonly [...BuildTuple<ArrayIndex>, ArrayType[ArrayIndex]]
+						? readonly [...TupleOf<ArrayIndex>, ArrayType[ArrayIndex]]
 						: never
 			: never;
 

source/subtract.d.ts

@@ -1,7 +1,7 @@
 import type {NumberAbsolute, ReverseSign} from './internal/index.d.ts';
 import type {PositiveInfinity, NegativeInfinity, IsNegative} from './numeric.d.ts';
 import type {LessThan} from './less-than.d.ts';
-import type {BuildTuple} from './build-tuple.d.ts';
+import type {TupleOf} from './tuple-of.d.ts';
 
 /**
 Returns the difference between two numbers.
@@ -61,7 +61,7 @@ type SubtractPostChecks<A extends number, B extends number, AreNegative = [IsNeg
 			// When both numbers are negative we subtract the absolute values and then reverse the sign
 			? ReverseSign<SubtractPositives<NumberAbsolute<A>, NumberAbsolute<B>>>
 			// When the signs are different we can add the absolute values and then reverse the sign if A < B
-			: [...BuildTuple<NumberAbsolute<A>>, ...BuildTuple<NumberAbsolute<B>>] extends infer R extends unknown[]
+			: [...TupleOf<NumberAbsolute<A>>, ...TupleOf<NumberAbsolute<B>>] extends infer R extends unknown[]
 				? LessThan<A, B> extends true ? ReverseSign<R['length']> : R['length']
 				: never;
 
@@ -79,7 +79,7 @@ Subtracts two positive numbers A and B such that A > B.
 */
 type SubtractIfAGreaterThanB<A extends number, B extends number> =
 	// This is where we always want to end up and do the actual subtraction
-	BuildTuple<A> extends [...BuildTuple<B>, ...infer R]
+	TupleOf<A> extends [...TupleOf<B>, ...infer R]
 		? R['length']
 		: never;
 

source/sum.d.ts

@@ -1,4 +1,4 @@
-import type {BuildTuple} from './build-tuple.d.ts';
+import type {TupleOf} from './tuple-of.d.ts';
 import type {NumberAbsolute, TupleMax, ReverseSign} from './internal/index.d.ts';
 import type {PositiveInfinity, NegativeInfinity, IsNegative} from './numeric.d.ts';
 import type {Subtract} from './subtract.d.ts';
@@ -74,7 +74,7 @@ type SumPostChecks<A extends number, B extends number, AreNegative = [IsNegative
 Adds two positive numbers.
 */
 type SumPositives<A extends number, B extends number> =
-	[...BuildTuple<A>, ...BuildTuple<B>]['length'] extends infer Result extends number
+	[...TupleOf<A>, ...TupleOf<B>]['length'] extends infer Result extends number
 		? Result
 		: never;
 

source/build-tuple.d.ts source/tuple-of.d.tssource/build-tuple.d.ts renamed to source/tuple-of.d.ts

@@ -8,58 +8,58 @@ Creates a tuple type of the specified length with elements of the specified type
 
 @example
 ```
-import type {BuildTuple} from 'type-fest';
+import type {TupleOf} from 'type-fest';
 
-type RGB = BuildTuple<3, number>;
-//=> [number, number, number]
+type RGB = TupleOf<3, number>;
+// => [number, number, number]
 
-type Line = BuildTuple<2, {x: number; y: number}>;
+type Line = TupleOf<2, {x: number; y: number}>;
 //=> [{x: number; y: number}, {x: number; y: number}]
 
-type TicTacToeBoard = BuildTuple<3, BuildTuple<3, 'X' | 'O' | null>>;
+type TicTacToeBoard = TupleOf<3, TupleOf<3, 'X' | 'O' | null>>;
 //=> [['X' | 'O' | null, 'X' | 'O' | null, 'X' | 'O' | null], ['X' | 'O' | null, 'X' | 'O' | null, 'X' | 'O' | null], ['X' | 'O' | null, 'X' | 'O' | null, 'X' | 'O' | null]]
 ```
 
 Note: If the specified length is the non-literal `number` type, the result will not be a tuple but a regular array.
 
 @example
 ```
-import type {BuildTuple} from 'type-fest';
+import type {TupleOf} from 'type-fest';
 
-type StringArray = BuildTuple<number, string>;
+type StringArray = TupleOf<number, string>;
 //=> string[]
 ```
 
 Note: If the type for elements is not specified, it will default to `unknown`.
 
 @example
 ```
-import type {BuildTuple} from 'type-fest';
+import type {TupleOf} from 'type-fest';
 
-type UnknownTriplet = BuildTuple<3>;
+type UnknownTriplet = TupleOf<3>;
 //=> [unknown, unknown, unknown]
 ```
 
 Note: If the specified length is negative, the result will be an empty tuple.
 
 @example
 ```
-import type {BuildTuple} from 'type-fest';
+import type {TupleOf} from 'type-fest';
 
-type EmptyTuple = BuildTuple<-3, string>;
+type EmptyTuple = TupleOf<-3, string>;
 //=> []
 ```
 
 @category Array
 */
-export type BuildTuple<Length extends number, Fill = unknown> = IfNotAnyOrNever<Length,
-	_BuildTuple<If<IsNegative<Length>, 0, Length>, Fill, []>,
+export type TupleOf<Length extends number, Fill = unknown> = IfNotAnyOrNever<Length,
+	_TupleOf<If<IsNegative<Length>, 0, Length>, Fill, []>,
 	Fill[], []>;
 
-type _BuildTuple<L extends number, Fill, Accumulator extends UnknownArray> = number extends L
+type _TupleOf<L extends number, Fill, Accumulator extends UnknownArray> = number extends L
 	? Fill[]
 	: L extends Accumulator['length']
 		? Accumulator
-		: _BuildTuple<L, Fill, [...Accumulator, Fill]>;
+		: _TupleOf<L, Fill, [...Accumulator, Fill]>;
 
 export {};

test-d/is-equal.ts

@@ -1,5 +1,5 @@
 import {expectType} from 'tsd';
-import type {BuildTuple, IsEqual} from '../index.d.ts';
+import type {IsEqual, TupleOf} from '../index.d.ts';
 
 expectType<false>({} as IsEqual<number, string>);
 expectType<true>({} as IsEqual<1, 1>);
@@ -38,10 +38,10 @@ expectType<true>({} as IsEqual<[string], [string]>);
 expectType<false>({} as IsEqual<[string], [string, number]>);
 expectType<false>({} as IsEqual<[0, 1] | [0, 2], [0, 2]>);
 
-type LongTupleNumber = BuildTuple<50, 0>;
+type LongTupleNumber = TupleOf<50, 0>;
 expectType<true>({} as IsEqual<LongTupleNumber, LongTupleNumber>);
 
-type ReadonlyLongTupleNumber = Readonly<BuildTuple<50, 0>>;
+type ReadonlyLongTupleNumber = Readonly<TupleOf<50, 0>>;
 expectType<true>({} as IsEqual<ReadonlyLongTupleNumber, ReadonlyLongTupleNumber>);
 
 expectType<false>({} as IsEqual<ReadonlyLongTupleNumber, LongTupleNumber>);