ArrayTail: Enable preserveReadonly option by default and remove the option (#1173)

Author: som-sm

source/array-tail.d.ts

@@ -1,40 +1,7 @@
 import type {If} from './if.d.ts';
-import type {ApplyDefaultOptions, IsArrayReadonly} from './internal/index.d.ts';
+import type {IsArrayReadonly} from './internal/index.d.ts';
 import type {UnknownArray} from './unknown-array.d.ts';
 
-/**
-@see {@link ArrayTail}
-*/
-type ArrayTailOptions = {
-	/**
-	Return a readonly array if the input array is readonly.
-
-	@default false
-
-	@example
-	```
-	import type {ArrayTail} from 'type-fest';
-
-	type Example1 = ArrayTail<readonly [string, number, boolean], {preserveReadonly: true}>;
-	//=> readonly [number, boolean]
-
-	type Example2 = ArrayTail<[string, number, boolean], {preserveReadonly: true}>;
-	//=> [number, boolean]
-
-	type Example3 = ArrayTail<readonly [string, number, boolean], {preserveReadonly: false}>;
-	//=> [number, boolean]
-
-	type Example4 = ArrayTail<[string, number, boolean], {preserveReadonly: false}>;
-	//=> [number, boolean]
-	```
-	*/
-	preserveReadonly?: boolean;
-};
-
-type DefaultArrayTailOptions = {
-	preserveReadonly: false;
-};
-
 /**
 Extracts the type of an array or tuple minus the first element.
 
@@ -55,18 +22,12 @@ add3(4);
 //=> 7
 ```
 
-@see {@link ArrayTailOptions}
-
 @category Array
 */
-export type ArrayTail<TArray extends UnknownArray, Options extends ArrayTailOptions = {}> =
-	ApplyDefaultOptions<ArrayTailOptions, DefaultArrayTailOptions, Options> extends infer ResolvedOptions extends Required<ArrayTailOptions>
-		? TArray extends UnknownArray // For distributing `TArray`
-			? _ArrayTail<TArray> extends infer Result
-				? ResolvedOptions['preserveReadonly'] extends true
-					? If<IsArrayReadonly<TArray>, Readonly<Result>, Result>
-					: Result
-				: never // Should never happen
+export type ArrayTail<TArray extends UnknownArray> =
+	TArray extends UnknownArray // For distributing `TArray`
+		? _ArrayTail<TArray> extends infer Result
+			? If<IsArrayReadonly<TArray>, Readonly<Result>, Result>
 			: never // Should never happen
 		: never; // Should never happen
 

source/merge-deep.d.ts

@@ -86,7 +86,7 @@ type OmitRestTypeHelper<
 	Tail extends UnknownArrayOrTuple,
 	Type extends UnknownArrayOrTuple,
 	Result extends UnknownArrayOrTuple = [],
-> = Tail extends []
+> = Tail extends readonly []
 	? Result
 	: OmitRestType<Tail, [...Result, FirstArrayElement<Type>]>;
 

test-d/array-tail.ts

@@ -1,48 +1,49 @@
 import {expectType} from 'tsd';
-import type {ArrayTail, UnknownArray} from '../index.d.ts';
+import type {ArrayTail} from '../index.d.ts';
 
 declare const getArrayTail: <T extends readonly unknown[]>(array: T) => ArrayTail<T>;
 
-expectType<[]>(getArrayTail([]));
-expectType<[]>(getArrayTail(['a']));
-expectType<[]>(getArrayTail(['a', 'b', 'c']));
+expectType<[]>(getArrayTail([] as []));
+expectType<[]>(getArrayTail(['a'] as ['a']));
+expectType<['b', 'c']>(getArrayTail(['a', 'b', 'c'] as ['a', 'b', 'c']));
 
-expectType<[]>(getArrayTail([] as const));
-expectType<[]>(getArrayTail(['a'] as const));
-expectType<['b', 'c']>(getArrayTail(['a', 'b', 'c'] as const));
+expectType<readonly []>(getArrayTail([] as const));
+expectType<readonly []>(getArrayTail(['a'] as const));
+expectType<readonly ['b', 'c']>(getArrayTail(['a', 'b', 'c'] as const));
 
 // Optional elements tests
-expectType<[undefined, 'c']>(getArrayTail(['a', undefined, 'c'] as const));
+expectType<readonly [undefined, 'c']>(getArrayTail(['a', undefined, 'c'] as const));
 
 // Mixed optional/required
 type MixedArray = [string, undefined?, number?];
 expectType<[undefined?, number?]>(getArrayTail(['hello'] as MixedArray));
 
 // Optional numbers
-expectType<[undefined, 3]>(getArrayTail([1, undefined, 3] as const));
+expectType<readonly [undefined, 3]>(getArrayTail([1, undefined, 3] as const));
 
 // Complex mixed case
 type ComplexArray = [string, boolean, number?, string?];
 expectType<[boolean, number?, string?]>(getArrayTail(['test', false] as ComplexArray));
 
 // All optional elements
 expectType<['b'?]>([] as ArrayTail<['a'?, 'b'?]>);
+expectType<readonly [number?]>({} as ArrayTail<readonly [string?, number?]>);
+
+// Rest element
+expectType<readonly [number, boolean, ...string[]]>({} as ArrayTail<readonly [string, number, boolean, ...string[]]>); // Required & Rest
+expectType<readonly [number?, boolean?, ...string[]]>({} as ArrayTail<readonly [string?, number?, boolean?, ...string[]]>); // Optional & Rest
+expectType<readonly [number, boolean?, ...string[]]>({} as ArrayTail<readonly [string, number, boolean?, ...string[]]>); // Required, Optional & Rest
+// expectType<readonly [...string[], string, number]>({} as ArrayTail<readonly [...string[], string, number]>); // Rest & Required
+expectType<readonly [number, ...string[], boolean, bigint]>({} as ArrayTail<readonly [string, number, ...string[], boolean, bigint]>); // Required, Rest & Required
 
 // Union of tuples
 expectType<[] | ['b']>([] as ArrayTail<[] | ['a', 'b']>);
-expectType<['y'?] | ['b', ...string[]] | []>([] as ArrayTail<readonly ['x'?, 'y'?] | ['a', 'b', ...string[]] | readonly string[]>);
-
-// `preserveReadonly` option
-type ReadonlyPreservingArrayTail<Type extends UnknownArray> = ArrayTail<Type, {preserveReadonly: true}>;
-
-expectType<[]>({} as ReadonlyPreservingArrayTail<[]>);
-expectType<readonly []>({} as ReadonlyPreservingArrayTail<readonly []>);
-expectType<[number?, ...string[]]>({} as ReadonlyPreservingArrayTail<[string?, number?, ...string[]]>);
-expectType<readonly [number?, ...string[]]>({} as ReadonlyPreservingArrayTail<readonly [string?, number?, ...string[]]>);
-
-expectType<[number] | readonly [boolean, string?]>({} as ReadonlyPreservingArrayTail<[string, number] | readonly [number, boolean, string?]>);
-expectType<readonly [number] | readonly []>({} as ReadonlyPreservingArrayTail<readonly [string, number] | readonly string[]>);
-expectType<[number?] | [boolean, string?] | []>({} as ReadonlyPreservingArrayTail<[string?, number?] | [number, boolean, string?] | [...string[], number]>);
-
-expectType<[]>({} as ReadonlyPreservingArrayTail<string[]>);
-expectType<readonly []>({} as ReadonlyPreservingArrayTail<readonly string[]>);
+expectType<readonly ['y'?] | ['b', ...string[]] | readonly []>([] as ArrayTail<readonly ['x'?, 'y'?] | ['a', 'b', ...string[]] | readonly string[]>);
+expectType<[number] | readonly [boolean, string?]>({} as ArrayTail<[string, number] | readonly [number, boolean, string?]>);
+expectType<readonly [number] | readonly []>({} as ArrayTail<readonly [string, number] | readonly string[]>);
+
+// Non tuple arrays
+expectType<[]>({} as ArrayTail<string[]>);
+expectType<readonly []>({} as ArrayTail<readonly string[]>);
+expectType<[]>({} as ArrayTail<never[]>);
+expectType<[]>({} as ArrayTail<any[]>);