type-fest 4.5.0 → 4.7.0

package/index.d.ts

@@ -9,6 +9,7 @@ export type {KeysOfUnion} from './source/keys-of-union';
 export type {EmptyObject, IsEmptyObject} from './source/empty-object';
 export type {NonEmptyObject} from './source/non-empty-object';
 export type {UnknownRecord} from './source/unknown-record';
+export type {UnknownArray} from './source/unknown-array';
 export type {Except} from './source/except';
 export type {TaggedUnion} from './source/tagged-union';
 export type {Writable} from './source/writable';
@@ -24,6 +25,7 @@ export type {OmitIndexSignature} from './source/omit-index-signature';
 export type {PickIndexSignature} from './source/pick-index-signature';
 export type {PartialDeep, PartialDeepOptions} from './source/partial-deep';
 export type {RequiredDeep} from './source/required-deep';
+export type {PickDeep} from './source/pick-deep';
 export type {PartialOnUndefinedDeep, PartialOnUndefinedDeepOptions} from './source/partial-on-undefined-deep';
 export type {UndefinedOnPartialDeep} from './source/undefined-on-partial-deep';
 export type {ReadonlyDeep} from './source/readonly-deep';
@@ -50,6 +52,7 @@ export type {IterableElement} from './source/iterable-element';
 export type {Entry} from './source/entry';
 export type {Entries} from './source/entries';
 export type {SetReturnType} from './source/set-return-type';
+export type {SetParameterType} from './source/set-parameter-type';
 export type {Asyncify} from './source/asyncify';
 export type {Simplify} from './source/simplify';
 export type {Jsonify} from './source/jsonify';
@@ -98,6 +101,10 @@ export type {IsNever} from './source/is-never';
 export type {IfNever} from './source/if-never';
 export type {IsUnknown} from './source/is-unknown';
 export type {IfUnknown} from './source/if-unknown';
+export type {ArrayIndices} from './source/array-indices';
+export type {ArrayValues} from './source/array-values';
+export type {SetFieldType} from './source/set-field-type';
+export type {Paths} from './source/paths';
 
 // Template literal types
 export type {CamelCase} from './source/camel-case';

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "type-fest",
-	"version": "4.5.0",
+	"version": "4.7.0",
 	"description": "A collection of essential TypeScript types",
 	"license": "(MIT OR CC0-1.0)",
 	"repository": "sindresorhus/type-fest",
@@ -11,6 +11,7 @@
 		"url": "https://sindresorhus.com"
 	},
 	"types": "./index.d.ts",
+	"sideEffects": false,
 	"engines": {
 		"node": ">=16"
 	},

package/readme.md

@@ -113,8 +113,9 @@ Click the type names for complete docs.
 - [`IsEmptyObject`](source/empty-object.d.ts) - Returns a `boolean` for whether the type is strictly equal to an empty plain object, the `{}` value.
 - [`NonEmptyObject`](source/non-empty-object.d.ts) - Represents an object with at least 1 non-optional key.
 - [`UnknownRecord`](source/unknown-record.d.ts) - Represents an object with `unknown` value. You probably want this instead of `{}`.
+- [`UnknownArray`](source/unknown-array.d.ts) - Represents an array with `unknown` value.
 - [`Except`](source/except.d.ts) - Create a type from an object type without certain keys. This is a stricter version of [`Omit`](https://www.typescriptlang.org/docs/handbook/utility-types.html#omittype-keys).
-- [`Writable`](source/writable.d.ts) - Create a type that strips `readonly` from all or some of an object's keys. The inverse of `Readonly<T>`.
+- [`Writable`](source/writable.d.ts) - Create a type that strips `readonly` from the given type. Inverse of `Readonly<T>`.
 - [`WritableDeep`](source/writable-deep.d.ts) - Create a deeply mutable version of an `object`/`ReadonlyMap`/`ReadonlySet`/`ReadonlyArray` type. The inverse of `ReadonlyDeep<T>`. Use `Writable<T>` if you only need one level deep.
 - [`Merge`](source/merge.d.ts) - Merge two types into a new type. Keys of the second type overrides keys of the first type.
 - [`MergeDeep`](source/merge-deep.d.ts) - Merge two objects or two arrays/tuples recursively into a new type.
@@ -125,6 +126,7 @@ Click the type names for complete docs.
 - [`RequireAllOrNone`](source/require-all-or-none.d.ts) - Create a type that requires all of the given keys or none of the given keys.
 - [`RequireOneOrNone`](source/require-one-or-none.d.ts) - Create a type that requires exactly a single key of the given keys and disallows more, or none of the given keys.
 - [`RequiredDeep`](source/required-deep.d.ts) - Create a deeply required version of another type. Use [`Required<T>`](https://www.typescriptlang.org/docs/handbook/utility-types.html#requiredtype) if you only need one level deep.
+- [`PickDeep`](source/pick-deep.d.ts) - Pick properties from a deeply-nested object. Use [`Pick<T>`](https://www.typescriptlang.org/docs/handbook/utility-types.html#picktype-keys) if you only need one level deep.
 - [`OmitIndexSignature`](source/omit-index-signature.d.ts) - Omit any index signatures from the given object type, leaving only explicitly defined properties.
 - [`PickIndexSignature`](source/pick-index-signature.d.ts) - Pick only index signatures from the given object type, leaving out all explicitly defined properties.
 - [`PartialDeep`](source/partial-deep.d.ts) - Create a deeply optional version of another type. Use [`Partial<T>`](https://www.typescriptlang.org/docs/handbook/utility-types.html#partialtype) if you only need one level deep.
@@ -154,6 +156,7 @@ Click the type names for complete docs.
 - [`Entry`](source/entry.d.ts) - Create a type that represents the type of an entry of a collection.
 - [`Entries`](source/entries.d.ts) - Create a type that represents the type of the entries of a collection.
 - [`SetReturnType`](source/set-return-type.d.ts) - Create a function type with a return type of your choice and the same parameters as the given function type.
+- [`SetParameterType`](source/set-parameter-type.d.ts) - Create a function that replaces some parameters with the given parameters.
 - [`Simplify`](source/simplify.d.ts) - Useful to flatten the type output to improve type hints shown in editors. And also to transform an interface into a type to aide with assignability.
 - [`Get`](source/get.d.ts) - Get a deeply-nested property from an object using a key path, like [Lodash's `.get()`](https://lodash.com/docs/latest#get) function.
 - [`StringKeyOf`](source/string-key-of.d.ts) - Get keys of the given type as strings.
@@ -172,6 +175,10 @@ Click the type names for complete docs.
 - [`IsEqual`](source/is-equal.d.ts) - Returns a boolean for whether the two given types are equal.
 - [`TaggedUnion`](source/tagged-union.d.ts) - Create a union of types that share a common discriminant property.
 - [`IntRange`](source/int-range.d.ts) - Generate a union of numbers.
+- [`ArrayIndices`](source/array-indices.d.ts) - Provides valid indices for a constant array or tuple.
+- [`ArrayValues`](source/array-values.d.ts) - Provides all values for a constant array or tuple.
+- [`SetFieldType`](source/set-field-type.d.ts) - Create a type that changes the type of the given keys.
+- [`Paths`](source/paths.d.ts) - Generate a union of all possible paths to properties in the given object.
 
 ### Type Guard
 
@@ -937,6 +944,7 @@ You can find some examples in the [TypeScript docs](https://www.typescriptlang.o
 ## Maintainers
 
 - [Sindre Sorhus](https://github.com/sindresorhus)
+- [Haozheng Li](https://github.com/Emiyaaaaa)
 - [Jarek Radosz](https://github.com/CvX)
 - [Dimitri Benin](https://github.com/BendingBender)
 - [Pelle Wessman](https://github.com/voxpelli)

package/source/array-indices.d.ts

@@ -0,0 +1,23 @@
+/**
+Provides valid indices for a constant array or tuple.
+
+Use-case: This type is useful when working with constant arrays or tuples and you want to enforce type-safety for accessing elements by their indices.
+
+@example
+```
+import type {ArrayIndices, ArrayValues} from 'type-fest';
+
+const weekdays = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday'] as const;
+
+type Weekday = ArrayIndices<typeof weekdays>;
+type WeekdayName = ArrayValues<typeof weekdays>;
+
+const getWeekdayName = (day: Weekday): WeekdayName => weekdays[day];
+```
+
+@see {@link ArrayValues}
+
+@category Array
+*/
+export type ArrayIndices<Element extends readonly unknown[]> =
+	Exclude<Partial<Element>['length'], Element['length']>;

package/source/array-values.d.ts

@@ -0,0 +1,22 @@
+/**
+Provides all values for a constant array or tuple.
+
+Use-case: This type is useful when working with constant arrays or tuples and you want to enforce type-safety with their values.
+
+@example
+```
+import type {ArrayValues, ArrayIndices} from 'type-fest';
+
+const weekdays = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday'] as const;
+
+type WeekdayName = ArrayValues<typeof weekdays>;
+type Weekday = ArrayIndices<typeof weekdays>;
+
+const getWeekdayName = (day: Weekday): WeekdayName => weekdays[day];
+```
+
+@see {@link ArrayIndices}
+
+@category Array
+*/
+export type ArrayValues<T extends readonly unknown[]> = T[number];

package/source/conditional-pick-deep.d.ts

@@ -1,6 +1,8 @@
 import type {IsEqual} from './is-equal';
 import type {ConditionalExcept} from './conditional-except';
 import type {ConditionalSimplifyDeep} from './conditional-simplify';
+import type {UnknownRecord} from './unknown-record';
+import type {EmptyObject} from './empty-object';
 
 /**
 Used to mark properties that should be excluded.
@@ -95,7 +97,7 @@ export type ConditionalPickDeep<
 > = ConditionalSimplifyDeep<ConditionalExcept<{
 	[Key in keyof Type]: AssertCondition<Type[Key], Condition, Options> extends true
 		? Type[Key]
-		: Type[Key] extends object
+		: Type[Key] extends UnknownRecord
 			? ConditionalPickDeep<Type[Key], Condition, Options>
 			: typeof conditionalPickDeepSymbol;
-}, (typeof conditionalPickDeepSymbol | undefined) | Record<PropertyKey, never>>>;
+}, (typeof conditionalPickDeepSymbol | undefined) | EmptyObject>, never, UnknownRecord>;

package/source/internal.d.ts

@@ -2,6 +2,7 @@ import type {Primitive} from './primitive';
 import type {Simplify} from './simplify';
 import type {Trim} from './trim';
 import type {IsAny} from './is-any';
+import type {UnknownRecord} from './unknown-record';
 
 // TODO: Remove for v5.
 export type {UnknownRecord} from './unknown-record';
@@ -24,6 +25,37 @@ export type BuildTuple<L extends number, Fill = unknown, T extends readonly unkn
 	? T
 	: BuildTuple<L, Fill, [...T, Fill]>;
 
+/**
+Create an object type with the given key `<Key>` and value `<Value>`.
+
+It will copy the prefix and optional status of the same key from the given object `CopiedFrom` into the result.
+
+@example
+```
+type A = BuildObject<'a', string>;
+//=> {a: string}
+
+// Copy `readonly` and `?` from the key `a` of `{readonly a?: any}`
+type B = BuildObject<'a', string, {readonly a?: any}>;
+//=> {readonly a?: string}
+```
+*/
+export type BuildObject<Key extends PropertyKey, Value, CopiedFrom extends UnknownRecord = {}> =
+	Key extends keyof CopiedFrom
+		? Pick<{[_ in keyof CopiedFrom]: Value}, Key>
+		: Key extends `${infer NumberKey extends number}`
+			? NumberKey extends keyof CopiedFrom
+				? Pick<{[_ in keyof CopiedFrom]: Value}, NumberKey>
+				: {[_ in Key]: Value}
+			: {[_ in Key]: Value};
+
+/**
+Return a string representation of the given string or number.
+
+Note: This type is not the return type of the `.toString()` function.
+*/
+export type ToString<T> = T extends string | number ? `${T}` : never;
+
 /**
 Create a tuple of length `A` and a tuple composed of two other tuples,
 the inferred tuple `U` and a tuple of length `B`, then extracts the length of tuple `U`.

package/source/last-array-element.d.ts

@@ -13,16 +13,26 @@ const array = ['foo', 2];
 
 typeof lastOf(array);
 //=> number
+
+const array = ['foo', 2] as const;
+
+typeof lastOf(array);
+//=> 2
 ```
 
 @category Array
 @category Template literal
 */
-export type LastArrayElement<Elements extends readonly unknown[]>
-		= number extends Elements['length']
-			? Elements extends ReadonlyArray<infer Element>
-				? Element
-				: never
-			: Elements extends readonly [...any, infer Target]
-				? Target
-				: never;
+export type LastArrayElement<Elements extends readonly unknown[], ElementBeforeTailingSpreadElement = never> =
+	// If the last element of an array is a spread element, the `LastArrayElement` result should be `'the type of the element before the spread element' | 'the type of the spread element'`.
+	Elements extends readonly []
+		? ElementBeforeTailingSpreadElement
+		: Elements extends readonly [...infer U, infer V]
+			? V
+			: Elements extends readonly [infer U, ...infer V]
+				// If we return `V[number] | U` directly, it would be wrong for `[[string, boolean, object, ...number[]]`.
+				// So we need to recurse type `V` and carry over the type of the element before the spread element.
+				? LastArrayElement<V, U>
+				: Elements extends ReadonlyArray<infer U>
+					? U | ElementBeforeTailingSpreadElement
+					: never;

package/source/partial-deep.d.ts

@@ -1,4 +1,4 @@
-import type {BuiltIns} from './internal';
+import type {BuiltIns, UnknownRecord} from './internal';
 
 /**
 @see PartialDeep
@@ -59,7 +59,7 @@ const partialSettings: PartialDeep<Settings, {recurseIntoArrays: true}> = {
 @category Set
 @category Map
 */
-export type PartialDeep<T, Options extends PartialDeepOptions = {}> = T extends BuiltIns
+export type PartialDeep<T, Options extends PartialDeepOptions = {}> = T extends BuiltIns | (((...arguments_: any[]) => unknown)) | (new (...arguments_: any[]) => unknown)
 	? T
 	: T extends Map<infer KeyType, infer ValueType>
 		? PartialMapDeep<KeyType, ValueType, Options>
@@ -69,19 +69,17 @@ export type PartialDeep<T, Options extends PartialDeepOptions = {}> = T extends
 				? PartialReadonlyMapDeep<KeyType, ValueType, Options>
 				: T extends ReadonlySet<infer ItemType>
 					? PartialReadonlySetDeep<ItemType, Options>
-					: T extends ((...arguments_: any[]) => unknown)
-						? T | undefined
-						: T extends object
-							? T extends ReadonlyArray<infer ItemType> // Test for arrays/tuples, per https://github.com/microsoft/TypeScript/issues/35156
-								? Options['recurseIntoArrays'] extends true
-									? ItemType[] extends T // Test for arrays (non-tuples) specifically
-										? readonly ItemType[] extends T // Differentiate readonly and mutable arrays
-											? ReadonlyArray<PartialDeep<ItemType | undefined, Options>>
-											: Array<PartialDeep<ItemType | undefined, Options>>
-										: PartialObjectDeep<T, Options> // Tuples behave properly
-									: T // If they don't opt into array testing, just use the original type
-								: PartialObjectDeep<T, Options>
-							: unknown;
+					: T extends UnknownRecord
+						? PartialObjectDeep<T, Options>
+						: T extends ReadonlyArray<infer ItemType> // Test for arrays/tuples, per https://github.com/microsoft/TypeScript/issues/35156
+							? Options['recurseIntoArrays'] extends true
+								? ItemType[] extends T // Test for arrays (non-tuples) specifically
+									? readonly ItemType[] extends T // Differentiate readonly and mutable arrays
+										? ReadonlyArray<PartialDeep<ItemType | undefined, Options>>
+										: Array<PartialDeep<ItemType | undefined, Options>>
+									: PartialObjectDeep<T, Options> // Tuples behave properly
+								: T // If they don't opt into array testing, just use the original type
+							: T;
 
 /**
 Same as `PartialDeep`, but accepts only `Map`s and as inputs. Internal helper for `PartialDeep`.

package/source/paths.d.ts

@@ -0,0 +1,107 @@
+import type {ToString} from './internal';
+import type {EmptyObject} from './empty-object';
+import type {IsAny} from './is-any';
+import type {IsNever} from './is-never';
+import type {UnknownArray} from './unknown-array';
+import type {UnknownRecord} from './unknown-record';
+
+/**
+Return the part of the given array with a fixed index.
+
+@example
+```
+type A = [string, number, boolean, ...string[]];
+type B = FilterFixedIndexArray<A>;
+//=> [string, number, boolean]
+```
+*/
+type FilterFixedIndexArray<T extends UnknownArray, Result extends UnknownArray = []> =
+	number extends T['length'] ?
+		T extends readonly [infer U, ...infer V]
+			? FilterFixedIndexArray<V, [...Result, U]>
+			: Result
+		: T;
+
+/**
+Return the part of the given array with a non-fixed index.
+
+@example
+```
+type A = [string, number, boolean, ...string[]];
+type B = FilterNotFixedIndexArray<A>;
+//=> string[]
+```
+*/
+type FilterNotFixedIndexArray<T extends UnknownArray> =
+T extends readonly [...FilterFixedIndexArray<T>, ...infer U]
+	? U
+	: [];
+
+/**
+Generate a union of all possible paths to properties in the given object.
+
+It also works with arrays.
+
+Use-case: You want a type-safe way to access deeply nested properties in an object.
+
+@example
+```
+import type {Paths} from 'type-fest';
+
+type Project = {
+	filename: string;
+	listA: string[];
+	listB: [{filename: string}];
+	folder: {
+		subfolder: {
+			filename: string;
+		};
+	};
+};
+
+type ProjectPaths = Paths<Project>;
+//=> 'filename' | 'listA' | 'listB' | 'folder' | `listA.${number}` | 'listB.0' | 'listB.0.filename' | 'folder.subfolder' | 'folder.subfolder.filename'
+
+declare function open<Path extends ProjectPaths>(path: Path): void;
+
+open('filename'); // Pass
+open('folder.subfolder'); // Pass
+open('folder.subfolder.filename'); // Pass
+open('foo'); // TypeError
+
+// Also works with arrays
+open('listA.1'); // Pass
+open('listB.0'); // Pass
+open('listB.1'); // TypeError. Because listB only has one element.
+```
+
+@category Object
+@category Array
+*/
+export type Paths<T extends UnknownRecord | UnknownArray> =
+	IsAny<T> extends true
+		? never
+		: T extends UnknownArray
+			? number extends T['length']
+				// We need to handle the fixed and non-fixed index part of the array separately.
+				? InternalPaths<FilterFixedIndexArray<T>>
+				| InternalPaths<Array<FilterNotFixedIndexArray<T>[number]>>
+				: InternalPaths<T>
+			: InternalPaths<T>;
+
+export type InternalPaths<_T extends UnknownRecord | UnknownArray, T = Required<_T>> =
+	T extends EmptyObject | readonly []
+		? never
+		: {
+			[Key in keyof T]:
+			Key extends string | number // Limit `Key` to string or number.
+				? T[Key] extends UnknownRecord | UnknownArray
+					? (
+						IsNever<Paths<T[Key]>> extends false
+							// If `Key` is a number, return `Key | `${Key}``, because both `array[0]` and `array['0']` work.
+							? Key | ToString<Key> | `${Key}.${Paths<T[Key]>}`
+							: Key | ToString<Key>
+					)
+					: Key | ToString<Key>
+				: never
+		}[keyof T & (T extends UnknownArray ? number : unknown)];

package/source/pick-deep.d.ts

@@ -0,0 +1,141 @@
+import type {BuildObject, BuildTuple, ToString} from './internal';
+import type {Paths} from './paths';
+import type {Simplify} from './simplify.d';
+import type {UnionToIntersection} from './union-to-intersection.d';
+import type {UnknownArray} from './unknown-array';
+import type {UnknownRecord} from './unknown-record.d';
+
+/**
+Pick properties from a deeply-nested object.
+
+It supports recursing into arrays.
+
+Use-case: Distill complex objects down to the components you need to target.
+
+@example
+```
+import type {PickDeep, PartialDeep} from 'type-fest';
+
+type Configuration = {
+	userConfig: {
+		name: string;
+		age: number;
+		address: [
+			{
+				city1: string;
+				street1: string;
+			},
+			{
+				city2: string;
+				street2: string;
+			}
+		]
+	};
+	otherConfig: any;
+};
+
+type NameConfig = PickDeep<Configuration, 'userConfig.name'>;
+// type NameConfig = {
+// 	userConfig: {
+// 	name: string;
+// };
+
+// Supports optional properties
+type User = PickDeep<PartialDeep<Configuration>, 'userConfig.name' | 'userConfig.age'>;
+// type User = {
+// 	userConfig?: {
+// 		name?: string;
+// 		age?: number;
+// 	};
+// };
+
+// Supports array
+type AddressConfig = PickDeep<Configuration, `userConfig.address.0`>;
+// type AddressConfig = {
+// 	userConfig: {
+// 		address: [{
+// 			city1: string;
+// 			street1: string;
+// 		}];
+// 	};
+// }
+
+// Supports recurse into array
+type Street = PickDeep<Configuration, `userConfig.address.1.street2`>;
+// type AddressConfig = {
+// 	userConfig: {
+// 		address: [
+// 			unknown,
+// 			{street2: string}
+// 		];
+// 	};
+// }
+```
+
+@category Object
+@category Array
+*/
+export type PickDeep<T extends UnknownRecord | UnknownArray, PathUnion extends Paths<T>> =
+	T extends UnknownRecord
+		? Simplify<UnionToIntersection<{
+			[P in PathUnion]: InternalPickDeep<T, P>;
+		}[PathUnion]>>
+		: T extends UnknownArray
+			? UnionToIntersection<{
+				[P in PathUnion]: InternalPickDeep<T, P>;
+			}[PathUnion]
+			>
+			: never;
+
+/**
+Pick an object/array from the given object/array by one path.
+*/
+type InternalPickDeep<
+	T extends UnknownRecord | UnknownArray,
+	Path extends string | number, // Checked paths, extracted from unchecked paths
+> =
+	T extends UnknownArray ? PickDeepArray<T, Path>
+		: T extends UnknownRecord ? Simplify<PickDeepObject<T, Path>>
+			: never;
+
+/**
+Pick an object from the given object by one path.
+*/
+type PickDeepObject<RecordType extends UnknownRecord, P extends string | number> =
+	P extends `${infer RecordKeyInPath}.${infer SubPath}`
+		? BuildObject<RecordKeyInPath, InternalPickDeep<NonNullable<RecordType[RecordKeyInPath]>, SubPath>, RecordType>
+		: P extends keyof RecordType | ToString<keyof RecordType> // Handle number keys
+			? BuildObject<P, RecordType[P], RecordType>
+			: never;
+
+/**
+Pick an array from the given array by one path.
+*/
+type PickDeepArray<ArrayType extends UnknownArray, P extends string | number> =
+	// Handle paths that are `${number}.${string}`
+	P extends `${infer ArrayIndex extends number}.${infer SubPath}`
+		// When `ArrayIndex` is equal to `number`
+		? number extends ArrayIndex
+			? ArrayType extends unknown[]
+				? Array<InternalPickDeep<NonNullable<ArrayType[number]>, SubPath>>
+				: ArrayType extends readonly unknown[]
+					? ReadonlyArray<InternalPickDeep<NonNullable<ArrayType[number]>, SubPath>>
+					: never
+			// When `ArrayIndex` is a number literal
+			: ArrayType extends unknown[]
+				? [...BuildTuple<ArrayIndex>, InternalPickDeep<NonNullable<ArrayType[ArrayIndex]>, SubPath>]
+				: ArrayType extends readonly unknown[]
+					? readonly [...BuildTuple<ArrayIndex>, InternalPickDeep<NonNullable<ArrayType[ArrayIndex]>, SubPath>]
+					: never
+		// When the path is equal to `number`
+		: P extends `${infer ArrayIndex extends number}`
+			// When `ArrayIndex` is `number`
+			? number extends ArrayIndex
+				? ArrayType
+				// When `ArrayIndex` is a number literal
+				: ArrayType extends unknown[]
+					? [...BuildTuple<ArrayIndex>, ArrayType[ArrayIndex]]
+					: ArrayType extends readonly unknown[]
+						? readonly [...BuildTuple<ArrayIndex>, ArrayType[ArrayIndex]]
+						: never
+			: never;

package/source/readonly-deep.d.ts

@@ -38,28 +38,30 @@ Note that types containing overloaded functions are not made deeply readonly due
 */
 export type ReadonlyDeep<T> = T extends BuiltIns
 	? T
-	: T extends (...arguments_: any[]) => unknown
-		? {} extends ReadonlyObjectDeep<T>
-			? T
-			: HasMultipleCallSignatures<T> extends true
+	: T extends new (...args: any[]) => unknown
+		? T // Skip class constructors
+		: T extends (...arguments_: any[]) => unknown
+			? {} extends ReadonlyObjectDeep<T>
 				? T
-				: ((...arguments_: Parameters<T>) => ReturnType<T>) & ReadonlyObjectDeep<T>
-		: T extends Readonly<ReadonlyMap<infer KeyType, infer ValueType>>
-			? ReadonlyMapDeep<KeyType, ValueType>
-			: T extends Readonly<ReadonlySet<infer ItemType>>
-				? ReadonlySetDeep<ItemType>
-				: // Identify tuples to avoid converting them to arrays inadvertently; special case `readonly [...never[]]`, as it emerges undesirably from recursive invocations of ReadonlyDeep below.
-				T extends readonly [] | readonly [...never[]]
-					? readonly []
-					: T extends readonly [infer U, ...infer V]
-						? readonly [ReadonlyDeep<U>, ...ReadonlyDeep<V>]
-						: T extends readonly [...infer U, infer V]
-							? readonly [...ReadonlyDeep<U>, ReadonlyDeep<V>]
-							: T extends ReadonlyArray<infer ItemType>
-								? ReadonlyArray<ReadonlyDeep<ItemType>>
-								: T extends object
-									? ReadonlyObjectDeep<T>
-									: unknown;
+				: HasMultipleCallSignatures<T> extends true
+					? T
+					: ((...arguments_: Parameters<T>) => ReturnType<T>) & ReadonlyObjectDeep<T>
+			: T extends Readonly<ReadonlyMap<infer KeyType, infer ValueType>>
+				? ReadonlyMapDeep<KeyType, ValueType>
+				: T extends Readonly<ReadonlySet<infer ItemType>>
+					? ReadonlySetDeep<ItemType>
+					: // Identify tuples to avoid converting them to arrays inadvertently; special case `readonly [...never[]]`, as it emerges undesirably from recursive invocations of ReadonlyDeep below.
+					T extends readonly [] | readonly [...never[]]
+						? readonly []
+						: T extends readonly [infer U, ...infer V]
+							? readonly [ReadonlyDeep<U>, ...ReadonlyDeep<V>]
+							: T extends readonly [...infer U, infer V]
+								? readonly [...ReadonlyDeep<U>, ReadonlyDeep<V>]
+								: T extends ReadonlyArray<infer ItemType>
+									? ReadonlyArray<ReadonlyDeep<ItemType>>
+									: T extends object
+										? ReadonlyObjectDeep<T>
+										: unknown;
 
 /**
 Same as `ReadonlyDeep`, but accepts only `ReadonlyMap`s as inputs. Internal helper for `ReadonlyDeep`.

package/source/set-field-type.d.ts

@@ -0,0 +1,37 @@
+import type {Except} from './except';
+import type {Simplify} from './simplify';
+
+/**
+Create a type that changes the type of the given keys.
+
+Use-cases:
+- Creating variations of a base model.
+- Fixing incorrect external types.
+
+@see `Merge` if you need to change multiple properties to different types.
+
+@example
+```
+import type {SetFieldType} from 'type-fest';
+
+type MyModel = {
+	id: number;
+	createdAt: Date;
+	updatedAt: Date;
+};
+
+type MyModelApi = SetFieldType<MyModel, 'createdAt' | 'updatedAt', string>;
+// {
+// 	id: number;
+// 	createdAt: string;
+// 	updatedAt: string;
+// }
+```
+
+@category Object
+*/
+export type SetFieldType<BaseType, Keys extends keyof BaseType, NewType> =
+	Simplify<
+	Except<BaseType, Keys> &
+	Record<Keys, NewType>
+	>;

package/source/set-parameter-type.d.ts

@@ -0,0 +1,68 @@
+import type {IsUnknown} from './is-unknown';
+
+/**
+Create a tuple that replaces the given `Tuple`'s elements with the given `Record_`'s values at the given indices.
+*/
+type MergeObjectToTuple<Tuple extends unknown[], Record_ extends Record<number, unknown>> = {
+	[K in keyof Tuple]: Record_ extends Record<string, unknown>
+		// Handle object case like `{0: string, 1: number}`
+		? K extends `${infer NumberK extends number}`
+			? NumberK extends keyof Record_ ? Record_[K] : Tuple[K]
+			: never // Should not happen
+		// Handle tuple case like `[string, number]`
+		: K extends keyof Record_ ? Record_[K] : Tuple[K]
+};
+
+/**
+Create a function that replaces some parameters with the given parameters.
+
+The parameters that are not specified will be kept as-is.
+
+Note:
+- This type will ignore the given function's generic type.
+- If you change the parameter type that return type depends on, the return type will not change:
+	```
+	const fn = (a: number) => a;
+	//=> fn: (a: number) => number;
+
+ 	// We change type of `a` to `string`, but return type is still `number`.
+	type Fn = SetParameterType<typeof fn, {0: string}>;
+ 	//=> (a: string) => number;
+	```
+
+Use-case:
+- Define a wrapped function that receives something different while returning the same type.
+- Mocking and testing.
+- Overload function type. (See example)
+
+@example
+```
+import type {SetParameterType} from 'type-fest';
+
+type HandleMessage = (data: Data, message: string) => void;
+
+type HandleOk = SetParameterType<HandleMessage, {0: SuccessData, 1: 'ok'}>;
+//=> type HandleOk = (data: SuccessData, message: 'ok') => void;
+
+// Another way to define the parameters to replace.
+type HandleError = SetParameterType<HandleMessage, [data: ErrorData, message: 'error']>;
+//=> type HandleError = (data: ErrorData, message: 'error') => void;
+
+// Could change single parameter type.
+type HandleWarn = SetParameterType<HandleMessage, {1: 'warn'}>;
+//=> type HandleWarn = (data: Data, message: 'warn') => void;
+```
+
+@category Function
+*/
+export type SetParameterType<Fn extends (...arguments_: any[]) => unknown, P extends Record<number, unknown>> =
+	// Just using `Parameters<Fn>` isn't ideal because it doesn't handle the `this` fake parameter.
+	Fn extends (this: infer ThisArg, ...arguments_: infer Arguments) => unknown
+		? (
+			// If a function did not specify the `this` fake parameter, it will be inferred to `unknown`.
+			// We want to detect this situation just to display a friendlier type upon hovering on an IntelliSense-powered IDE.
+			IsUnknown<ThisArg> extends true
+				? (...arguments_: MergeObjectToTuple<Arguments, P>) => ReturnType<Fn>
+				: (this: ThisArg, ...arguments_: MergeObjectToTuple<Arguments, P>) => ReturnType<Fn>
+		)
+		: Fn;	// This part should be unreachable

package/source/unknown-array.d.ts

@@ -0,0 +1,25 @@
+/**
+Represents an array with `unknown` value.
+
+Use case: You want a type that all arrays can be assigned to, but you don't care about the value.
+
+@example
+```
+import type {UnknownArray} from 'type-fest';
+
+type IsArray<T> = T extends UnknownArray ? true : false;
+
+type A = IsArray<['foo']>;
+//=> true
+
+type B = IsArray<readonly number[]>;
+//=> true
+
+type C = IsArray<string>;
+//=> false
+```
+
+@category Type
+@category Array
+*/
+export type UnknownArray = readonly unknown[];

package/source/writable-deep.d.ts

@@ -38,23 +38,31 @@ export type WritableDeep<T> = T extends BuiltIns
 			: HasMultipleCallSignatures<T> extends true
 				? T
 				: ((...arguments_: Parameters<T>) => ReturnType<T>) & WritableObjectDeep<T>
-		: T extends Readonly<ReadonlyMap<infer KeyType, infer ValueType>>
-			? WritableMapDeep<KeyType, ValueType>
-			: T extends Readonly<ReadonlySet<infer ItemType>>
-				? WritableSetDeep<ItemType>
-				: T extends object
-					? WritableObjectDeep<T>
-					: unknown;
+		: T extends ReadonlyMap<unknown, unknown>
+			? WritableMapDeep<T>
+			: T extends ReadonlySet<unknown>
+				? WritableSetDeep<T>
+				: T extends readonly unknown[]
+					? WritableArrayDeep<T>
+					: T extends object
+						? WritableObjectDeep<T>
+						: unknown;
 
 /**
 Same as `WritableDeep`, but accepts only `Map`s as inputs. Internal helper for `WritableDeep`.
 */
-type WritableMapDeep<KeyType, ValueType> = {} & Writable<Map<WritableDeep<KeyType>, WritableDeep<ValueType>>>;
+type WritableMapDeep<MapType extends ReadonlyMap<unknown, unknown>> =
+	MapType extends ReadonlyMap<infer KeyType, infer ValueType>
+		? Map<WritableDeep<KeyType>, WritableDeep<ValueType>>
+		: MapType; // Should not heppen
 
 /**
 Same as `WritableDeep`, but accepts only `Set`s as inputs. Internal helper for `WritableDeep`.
 */
-type WritableSetDeep<ItemType> = {} & Writable<Set<WritableDeep<ItemType>>>;
+type WritableSetDeep<SetType extends ReadonlySet<unknown>> =
+	SetType extends ReadonlySet<infer ItemType>
+		? Set<WritableDeep<ItemType>>
+		: SetType; // Should not heppen
 
 /**
 Same as `WritableDeep`, but accepts only `object`s as inputs. Internal helper for `WritableDeep`.
@@ -62,3 +70,15 @@ Same as `WritableDeep`, but accepts only `object`s as inputs. Internal helper fo
 type WritableObjectDeep<ObjectType extends object> = {
 	-readonly [KeyType in keyof ObjectType]: WritableDeep<ObjectType[KeyType]>
 };
+
+/**
+Same as `WritableDeep`, but accepts only `Array`s as inputs. Internal helper for `WritableDeep`.
+*/
+type WritableArrayDeep<ArrayType extends readonly unknown[]> =
+	ArrayType extends readonly [] ? []
+		: ArrayType extends readonly [...infer U, infer V] ? [...WritableArrayDeep<U>, WritableDeep<V>]
+			: ArrayType extends readonly [infer U, ...infer V] ? [WritableDeep<U>, ...WritableArrayDeep<V>]
+				: ArrayType extends ReadonlyArray<infer U> ? Array<WritableDeep<U>>
+					: ArrayType extends Array<infer U> ? Array<WritableDeep<U>>
+						: ArrayType;
+

package/source/writable.d.ts

@@ -2,7 +2,21 @@ import type {Except} from './except';
 import type {Simplify} from './simplify';
 
 /**
-Create a type that strips `readonly` from all or some of an object's keys. Inverse of `Readonly<T>`.
+Create a writable version of the given array type.
+*/
+type WritableArray<ArrayType extends readonly unknown[]> =
+	ArrayType extends readonly [] ? []
+		: ArrayType extends readonly [...infer U, infer V] ? [...U, V]
+			: ArrayType extends readonly [infer U, ...infer V] ? [U, ...V]
+				: ArrayType extends ReadonlyArray<infer U> ? U[]
+					: ArrayType;
+
+/**
+Create a type that strips `readonly` from the given type. Inverse of `Readonly<T>`.
+
+The 2nd argument will be ignored if the input type is not an object.
+
+Note: This type can make readonly `Set` and `Map` writable. This behavior is different from `Readonly<T>` (as of TypeScript 5.2.2). See: https://github.com/microsoft/TypeScript/issues/29655
 
 This can be used to [store and mutate options within a class](https://github.com/sindresorhus/pageres/blob/4a5d05fca19a5fbd2f53842cbf3eb7b1b63bddd2/source/index.ts#L72), [edit `readonly` objects within tests](https://stackoverflow.com/questions/50703834), [construct a `readonly` object within a function](https://github.com/Microsoft/TypeScript/issues/24509), or to define a single model where the only thing that changes is whether or not some of the keys are writable.
 
@@ -27,14 +41,28 @@ type SomeWritable = Writable<Foo, 'b' | 'c'>;
 // 	b: readonly string[]; // It's now writable. The type of the property remains unaffected.
 // 	c: boolean; // It's now writable.
 // }
+
+// Also supports array
+const readonlyArray: readonly number[] = [1, 2, 3];
+readonlyArray.push(4); // Will fail as the array itself is readonly.
+const writableArray: Writable<typeof readonlyArray> = readonlyArray as Writable<typeof readonlyArray>;
+writableArray.push(4); // Will work as the array itself is now writable.
 ```
 
 @category Object
 */
 export type Writable<BaseType, Keys extends keyof BaseType = keyof BaseType> =
-	Simplify<
-	// Pick just the keys that are not writable from the base type.
-	Except<BaseType, Keys> &
-	// Pick the keys that should be writable from the base type and make them writable by removing the `readonly` modifier from the key.
-	{-readonly [KeyType in keyof Pick<BaseType, Keys>]: Pick<BaseType, Keys>[KeyType]}
-	>;
+BaseType extends ReadonlyMap<infer KeyType, infer ValueType>
+	? Map<KeyType, ValueType>
+	: BaseType extends ReadonlySet<infer ItemType>
+		? Set<ItemType>
+		: BaseType extends readonly unknown[]
+			// Handle array
+			? WritableArray<BaseType>
+			// Handle object
+			: Simplify<
+			// Pick just the keys that are not writable from the base type.
+			Except<BaseType, Keys> &
+			// Pick the keys that should be writable from the base type and make them writable by removing the `readonly` modifier from the key.
+			{-readonly [KeyType in keyof Pick<BaseType, Keys>]: Pick<BaseType, Keys>[KeyType]}
+			>;