ExcludeRestElement: Fix generic assignability with arrays

source/exclude-rest-element.d.ts

@@ -1,6 +1,7 @@
 import type {SplitOnRestElement} from './split-on-rest-element.d.ts';
 import type {IsArrayReadonly} from './internal/array.d.ts';
 import type {UnknownArray} from './unknown-array.d.ts';
+import type {IfNotAnyOrNever} from './internal/type.d.ts';
 
 /**
 Create a tuple with the [`rest`](https://www.typescriptlang.org/docs/handbook/2/objects.html#tuple-types) element removed.
@@ -26,13 +27,14 @@ type T4 = ExcludeRestElement<[number, string]>;
 @see {@link SplitOnRestElement}
 @category Array
 */
-export type ExcludeRestElement<Array_ extends UnknownArray> =
+export type ExcludeRestElement<Array_ extends UnknownArray> = IfNotAnyOrNever<Array_,
 	SplitOnRestElement<Array_> extends infer Result
 		? Result extends readonly UnknownArray[]
 			? IsArrayReadonly<Array_> extends true
 				? Readonly<[...Result[0], ...Result[2]]>
 				: [...Result[0], ...Result[2]]
-			: Result
-		: never;
+			: never
+		: never
+>;
 
 export {};

test-d/exclude-rest-element.ts

@@ -1,5 +1,5 @@
 import {expectType} from 'tsd';
-import type {ExcludeRestElement} from '../index.d.ts';
+import type {ExcludeRestElement, TupleOf, UnknownArray} from '../index.d.ts';
 
 // Basic static tuples (No rest element)
 expectType<ExcludeRestElement<[]>>({} as []);
@@ -51,3 +51,14 @@ expectType<ExcludeRestElement<[['a'], ...string[], ['z']]>>({} as [['a'], ['z']]
 // Edge: `never` / `any`
 expectType<ExcludeRestElement<any>>({} as any);
 expectType<ExcludeRestElement<never>>({} as never);
+
+// Long tuples
+type FiftyZeroes = TupleOf<50, '0'>;
+expectType<ExcludeRestElement<[...FiftyZeroes, ...number[]]>>({} as FiftyZeroes);
+
+type NineHundredNinetyNineZeroes = TupleOf<999, '0'>;
+expectType<ExcludeRestElement<[...NineHundredNinetyNineZeroes, ...number[]]>>({} as NineHundredNinetyNineZeroes);
+
+// Generic instantiations
+type Assignability<_T extends UnknownArray> = unknown;
+type TestAssignability<T extends UnknownArray> = Assignability<ExcludeRestElement<T>>;

test-d/extract-rest-element.ts

@@ -1,5 +1,5 @@
 import {expectType} from 'tsd';
-import type {ExtractRestElement} from '../index.d.ts';
+import type {ExtractRestElement, TupleOf} from '../index.d.ts';
 
 // Leading rest element
 expectType<ExtractRestElement<[...string[], 1]>>({} as string);
@@ -49,3 +49,10 @@ expectType<ExtractRestElement<[['a'], ...boolean[], ['z']]>>({} as boolean);
 // Edge: `never` / `any`
 expectType<ExtractRestElement<any>>({} as any);
 expectType<ExtractRestElement<never>>({} as never);
+
+// Long tuples
+type FiftyZeroes = TupleOf<50, '0'>;
+expectType<ExtractRestElement<[...FiftyZeroes, ...number[]]>>({} as number);
+
+type NineHundredNinetyNineZeroes = TupleOf<999, '0'>;
+expectType<ExtractRestElement<[...NineHundredNinetyNineZeroes, ...number[]]>>({} as number);

test-d/split-on-rest-element.ts

@@ -1,5 +1,5 @@
 import {expectType} from 'tsd';
-import type {SplitOnRestElement} from '../index.d.ts';
+import type {SplitOnRestElement, TupleOf, UnknownArray} from '../index.d.ts';
 
 // Fixed tuples (No rest element)
 expectType<SplitOnRestElement<[]>>({} as [[], [], []]);
@@ -53,3 +53,14 @@ expectType<SplitOnRestElement<readonly [1, 2, 3]>>({} as readonly [[1, 2, 3], []
 // Edge: `never` / `any`
 expectType<SplitOnRestElement<any>>({} as any);
 expectType<SplitOnRestElement<never>>({} as never);
+
+// Long tuples
+type FiftyZeroes = TupleOf<50, '0'>;
+expectType<SplitOnRestElement<[...FiftyZeroes, ...number[], ...FiftyZeroes]>>({} as [FiftyZeroes, number[], FiftyZeroes]);
+
+type FourHundredNinetyNineZeroes = TupleOf<499, '0'>;
+expectType<SplitOnRestElement<[...FourHundredNinetyNineZeroes, ...number[], ...FourHundredNinetyNineZeroes]>>({} as [FourHundredNinetyNineZeroes, number[], FourHundredNinetyNineZeroes]);
+
+// Generic instantiations
+type Assignability<_T extends UnknownArray> = unknown;
+type TestAssignability<T extends UnknownArray> = Assignability<SplitOnRestElement<T>>;