type-fest 4.4.0 → 4.6.0

package/index.d.ts

@@ -5,6 +5,7 @@ export * from './source/basic';
 export * from './source/observable-like';
 
 // Utilities
+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';
@@ -24,6 +25,7 @@ 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 {PartialOnUndefinedDeep, PartialOnUndefinedDeepOptions} from './source/partial-on-undefined-deep';
+export type {UndefinedOnPartialDeep} from './source/undefined-on-partial-deep';
 export type {ReadonlyDeep} from './source/readonly-deep';
 export type {LiteralUnion} from './source/literal-union';
 export type {Promisable} from './source/promisable';
@@ -48,6 +50,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';
@@ -81,6 +84,7 @@ export type {WritableKeysOf} from './source/writable-keys-of';
 export type {HasWritableKeys} from './source/has-writable-keys';
 export type {Spread} from './source/spread';
 export type {TupleToUnion} from './source/tuple-to-union';
+export type {IntRange} from './source/int-range';
 export type {IsEqual} from './source/is-equal';
 export type {
 	IsLiteral,
@@ -95,6 +99,8 @@ 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';
 
 // Template literal types
 export type {CamelCase} from './source/camel-case';

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "type-fest",
-	"version": "4.4.0",
+	"version": "4.6.0",
 	"description": "A collection of essential TypeScript types",
 	"license": "(MIT OR CC0-1.0)",
 	"repository": "sindresorhus/type-fest",
@@ -15,7 +15,8 @@
 		"node": ">=16"
 	},
 	"scripts": {
-		"test": "xo && tsd && tsc && node script/test/source-files-extension.js"
+		"test": "xo && tsd && tsc && npm run test:undefined-on-partial-deep && node script/test/source-files-extension.js",
+		"test:undefined-on-partial-deep": "cd test-d/undefined-on-partial-deep && tsc --project tsconfig.json"
 	},
 	"files": [
 		"index.d.ts",

package/readme.md

@@ -129,6 +129,7 @@ Click the type names for complete docs.
 - [`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.
 - [`PartialOnUndefinedDeep`](source/partial-on-undefined-deep.d.ts) - Create a deep version of another type where all keys accepting `undefined` type are set to optional.
+- [`UndefinedOnPartialDeep`](source/undefined-on-partial-deep.d.ts) - Create a deep version of another type where all optional keys are set to also accept `undefined`.
 - [`ReadonlyDeep`](source/readonly-deep.d.ts) - Create a deeply immutable version of an `object`/`Map`/`Set`/`Array` type. Use [`Readonly<T>`](https://www.typescriptlang.org/docs/handbook/utility-types.html#readonlytype) if you only need one level deep.
 - [`LiteralUnion`](source/literal-union.d.ts) - Create a union type by combining primitive types and literal types without sacrificing auto-completion in IDEs for the literal type part of the union. Workaround for [Microsoft/TypeScript#29729](https://github.com/Microsoft/TypeScript/issues/29729).
 - [`Tagged`](source/opaque.d.ts) - Create a [tagged type](https://medium.com/@KevinBGreene/surviving-the-typescript-ecosystem-branding-and-type-tagging-6cf6e516523d) that can support [multiple tags](https://github.com/sindresorhus/type-fest/issues/665) if needed.
@@ -153,12 +154,14 @@ 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.
 - [`Schema`](source/schema.d.ts) - Create a deep version of another object type where property values are recursively replaced into a given value type.
 - [`Exact`](source/exact.d.ts) - Create a type that does not allow extra properties.
 - [`OptionalKeysOf`](source/optional-keys-of.d.ts) - Extract all optional keys from the given type.
+- [`KeysOfUnion`](source/keys-of-union.d.ts) - Create a union of all keys from a given type, even those exclusive to specific union members.
 - [`HasOptionalKeys`](source/has-optional-keys.d.ts) - Create a `true`/`false` type depending on whether the given type has any optional fields.
 - [`RequiredKeysOf`](source/required-keys-of.d.ts) - Extract all required keys from the given type.
 - [`HasRequiredKeys`](source/has-required-keys.d.ts) - Create a `true`/`false` type depending on whether the given type has any required fields.
@@ -169,6 +172,9 @@ Click the type names for complete docs.
 - [`Spread`](source/spread.d.ts) - Mimic the type inferred by TypeScript when merging two objects or two arrays/tuples using the spread syntax.
 - [`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.
 
 ### Type Guard
 
@@ -293,13 +299,14 @@ type ShouldBeNever = IfAny<'not any', 'not never', 'never'>;
 
 *If you know one of our types by a different name, add it here for discovery.*
 
-- `Prettify`- See [`Simplify`](https://github.com/sindresorhus/type-fest/blob/main/source/simplify.d.ts)
-- `Expand`- See [`Simplify`](https://github.com/sindresorhus/type-fest/blob/main/source/simplify.d.ts)
-- `PartialBy` - See [`SetOptional`](https://github.com/sindresorhus/type-fest/blob/main/source/set-optional.d.ts)
-- `RecordDeep`- See [`Schema`](https://github.com/sindresorhus/type-fest/blob/main/source/schema.d.ts)
-- `Mutable`- See [`Writable`](https://github.com/sindresorhus/type-fest/blob/main/source/writable.d.ts)
-- `RequireOnlyOne` - See [`RequireExactlyOne`](https://github.com/sindresorhus/type-fest/blob/main/source/require-exactly-one.d.ts)
-- `AtMostOne` - See [`RequireOneOrNone`](https://github.com/sindresorhus/type-fest/blob/main/source/require-one-or-none.d.ts)
+- `Prettify`- See [`Simplify`](source/simplify.d.ts)
+- `Expand`- See [`Simplify`](source/simplify.d.ts)
+- `PartialBy` - See [`SetOptional`](source/set-optional.d.ts)
+- `RecordDeep`- See [`Schema`](source/schema.d.ts)
+- `Mutable`- See [`Writable`](source/writable.d.ts)
+- `RequireOnlyOne` - See [`RequireExactlyOne`](source/require-exactly-one.d.ts)
+- `AtMostOne` - See [`RequireOneOrNone`](source/require-one-or-none.d.ts)
+- `AllKeys` - See [`KeysOfUnion`](source/keys-of-union.d.ts)
 
 ## Tips
 
@@ -933,6 +940,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/exact.d.ts

@@ -1,6 +1,7 @@
-import type {KeysOfUnion, ArrayElement, ObjectValue} from './internal';
+import type {ArrayElement, ObjectValue} from './internal';
 import type {Opaque, TagContainer} from './opaque';
 import type {IsEqual} from './is-equal';
+import type {KeysOfUnion} from './keys-of-union';
 
 /**
 Create a type from `ParameterType` and `InputType` and change keys exclusive to `InputType` to `never`.

package/source/int-range.d.ts

@@ -0,0 +1,52 @@
+import type {BuildTuple, Subtract} from './internal';
+
+/**
+Generate a union of numbers.
+
+The numbers are created from the given `Start` (inclusive) parameter to the given `End` (exclusive) parameter.
+
+You skip over numbers using the `Step` parameter (defaults to `1`). For example, `IntRange<0, 10, 2>` will create a union of `0 | 2 | 4 | 6 | 8`.
+
+Note: `Start` or `End` must smaller than `1000`.
+
+Use-cases:
+1. This can be used to define a set of valid input/output values. for example:
+	```
+	type Age = IntRange<0, 120>;
+	type FontSize = IntRange<10, 20>;
+	type EvenNumber = IntRange<0, 11, 2>; //=> 0 | 2 | 4 | 6 | 8 | 10
+	```
+2. This can be used to define random numbers in a range. For example, `type RandomNumber = IntRange<0, 100>;`
+
+@example
+```
+import type {IntRange} from 'type-fest';
+
+// Create union type `0 | 1 | ... | 9`
+type ZeroToNine = IntRange<0, 10>;
+
+// Create union type `100 | 200 | 300 | ... | 900`
+type Hundreds = IntRange<100, 901, 100>;
+```
+*/
+export type IntRange<Start extends number, End extends number, Step extends number = 1> = PrivateIntRange<Start, End, Step>;
+
+/**
+The actual implementation of `IntRange`. It's private because it has some arguments that don't need to be exposed.
+*/
+type PrivateIntRange<
+	Start extends number,
+	End extends number,
+	Step extends number,
+	Gap extends number = Subtract<Step, 1>, // The gap between each number, gap = step - 1
+	List extends unknown[] = BuildTuple<Start, never>, // The final `List` is `[...StartLengthTuple, ...[number, ...GapLengthTuple], ...[number, ...GapLengthTuple], ... ...]`, so can initialize the `List` with `[...StartLengthTuple]`
+	EndLengthTuple extends unknown[] = BuildTuple<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.
+		? Exclude<List[number], never>
+		: PrivateIntRange<Start, End, Step, Gap, [...List, List['length'], ...BuildTuple<Gap, never>]>;

package/source/internal.d.ts

@@ -14,13 +14,15 @@ Infer the length of the given array `<T>`.
 type TupleLength<T extends readonly unknown[]> = T extends {readonly length: infer L} ? L : never;
 
 /**
-Create a tuple type of the given length `<L>`.
+Create a tuple type of the given length `<L>` and fill it with the given type `<Fill>`.
+
+If `<Fill>` is not provided, it will default to `unknown`.
 
 @link https://itnext.io/implementing-arithmetic-within-typescripts-type-system-a1ef140a6f6f
 */
-type BuildTuple<L extends number, T extends readonly unknown[] = []> = T extends {readonly length: L}
+export type BuildTuple<L extends number, Fill = unknown, T extends readonly unknown[] = []> = T extends {readonly length: L}
 	? T
-	: BuildTuple<L, [...T, unknown]>;
+	: BuildTuple<L, Fill, [...T, Fill]>;
 
 /**
 Create a tuple of length `A` and a tuple composed of two other tuples,
@@ -37,15 +39,6 @@ Matches any primitive, `Date`, or `RegExp` value.
 */
 export type BuiltIns = Primitive | Date | RegExp;
 
-/**
-Gets keys from a type. Similar to `keyof` but this one also works for union types.
-
-The reason a simple `keyof Union` does not work is because `keyof` always returns the accessible keys of a type. In the case of a union, that will only be the common keys.
-
-@link https://stackoverflow.com/a/49402091
-*/
-export type KeysOfUnion<T> = T extends T ? keyof T : never;
-
 export type UpperCaseCharacters = 'A' | 'B' | 'C' | 'D' | 'E' | 'F' | 'G' | 'H' | 'I' | 'J' | 'K' | 'L' | 'M' | 'N' | 'O' | 'P' | 'Q' | 'R' | 'S' | 'T' | 'U' | 'V' | 'W' | 'X' | 'Y' | 'Z';
 
 export type StringDigit = '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9';

package/source/jsonify.d.ts

@@ -96,24 +96,24 @@ export type Jsonify<T> = IsAny<T> extends true
 		? null
 		: T extends JsonPrimitive
 			? T
-			: // Instanced primitives are objects
-			T extends Number
-				? number
-				: T extends String
-					? string
-					: T extends Boolean
-						? boolean
-						: T extends Map<any, any> | Set<any>
-							? EmptyObject
-							: T extends TypedArray
-								? Record<string, number>
-								: T extends NotJsonable
-									? never // Non-JSONable type union was found not empty
-									: // Any object with toJSON is special case
-									T extends {toJSON(): infer J}
-										? (() => J) extends () => JsonValue // Is J assignable to JsonValue?
-											? J // Then T is Jsonable and its Jsonable value is J
-											: Jsonify<J> // Maybe if we look a level deeper we'll find a JsonValue
+			: // Any object with toJSON is special case
+			T extends {toJSON(): infer J}
+				? (() => J) extends () => JsonValue // Is J assignable to JsonValue?
+					? J // Then T is Jsonable and its Jsonable value is J
+					: Jsonify<J> // Maybe if we look a level deeper we'll find a JsonValue
+				: // Instanced primitives are objects
+				T extends Number
+					? number
+					: T extends String
+						? string
+						: T extends Boolean
+							? boolean
+							: T extends Map<any, any> | Set<any>
+								? EmptyObject
+								: T extends TypedArray
+									? Record<string, number>
+									: T extends NotJsonable
+										? never // Non-JSONable type union was found not empty
 										: T extends []
 											? []
 											: T extends unknown[]

package/source/keys-of-union.d.ts

@@ -0,0 +1,40 @@
+/**
+Create a union of all keys from a given type, even those exclusive to specific union members.
+
+Unlike the native `keyof` keyword, which returns keys present in **all** union members, this type returns keys from **any** member.
+
+@link https://stackoverflow.com/a/49402091
+
+@example
+```
+import type {KeysOfUnion} from 'type-fest';
+
+type A = {
+	common: string;
+	a: number;
+};
+
+type B = {
+	common: string;
+	b: string;
+};
+
+type C = {
+	common: string;
+	c: boolean;
+};
+
+type Union = A | B | C;
+
+type CommonKeys = keyof Union;
+//=> 'common'
+
+type AllKeys = KeysOfUnion<Union>;
+//=> 'common' | 'a' | 'b' | 'c'
+```
+
+@category Object
+*/
+export type KeysOfUnion<ObjectType> = ObjectType extends unknown
+	? keyof ObjectType
+	: never;

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/override-properties.d.ts

@@ -25,5 +25,12 @@ type Fizz = OverrideProperties<Foo, {b: number; c: number}>
 */
 export type OverrideProperties<
 	TOriginal,
-	TOverride extends {[Key in keyof TOverride]: Key extends keyof TOriginal ? TOverride[Key] : never},
+	// This first bit where we use `Partial` is to enable autocomplete
+	// and the second bit with the mapped type is what enforces that we don't try
+	// to override properties that doesn't exist in the original type.
+	TOverride extends Partial<Record<keyof TOriginal, unknown>> & {
+		[Key in keyof TOverride]: Key extends keyof TOriginal
+			? TOverride[Key]
+			: never;
+	},
 > = Merge<TOriginal, TOverride>;

package/source/partial-deep.d.ts

@@ -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 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;
 
 /**
 Same as `PartialDeep`, but accepts only `Map`s and as inputs. Internal helper for `PartialDeep`.

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-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/undefined-on-partial-deep.d.ts

@@ -0,0 +1,81 @@
+import type {BuiltIns} from './internal';
+import type {Merge} from './merge';
+
+/**
+Create a deep version of another type where all optional keys are set to also accept `undefined`.
+
+Note: This is only needed when the [`exactOptionalPropertyTypes`](https://www.typescriptlang.org/tsconfig#exactOptionalPropertyTypes) TSConfig setting is enabled.
+
+Use-cases:
+- When `exactOptionalPropertyTypes` is enabled, an object like `{a: undefined}` is not assignable to the type `{a?: number}`. You can use `UndefinedOnPartialDeep<{a?: number}>` to make it assignable.
+
+@example
+```
+import type {UndefinedOnPartialDeep} from 'type-fest';
+
+interface Settings {
+	optionA: string;
+	optionB?: number;
+	subOption: {
+		subOptionA: boolean;
+		subOptionB?: boolean;
+	}
+};
+
+const testSettingsA: Settings = {
+	optionA: 'foo',
+	optionB: undefined, // TypeScript error if `exactOptionalPropertyTypes` is true.
+	subOption: {
+		subOptionA: true,
+		subOptionB: undefined, // TypeScript error if `exactOptionalPropertyTypes` is true
+	},
+};
+
+const testSettingsB: UndefinedOnPartialDeep<Settings> = {
+	optionA: 'foo',
+	optionB: undefined, // 👉 `optionB` can be set to undefined now.
+	subOption: {
+		subOptionA: true,
+		subOptionB: undefined, // 👉 `subOptionB` can be set to undefined now.
+	},
+};
+```
+*/
+export type UndefinedOnPartialDeep<T> =
+	// Handle built-in type and function
+	T extends BuiltIns | Function
+		? T
+		// Handle tuple and array
+		: T extends readonly unknown[]
+			? UndefinedOnPartialList<T>
+			// Handle map and readonly map
+			: T extends Map<infer K, infer V>
+				? Map<K, UndefinedOnPartialDeep<V>>
+				: T extends ReadonlyMap<infer K, infer V>
+					? ReadonlyMap<K, UndefinedOnPartialDeep<V>>
+					// Handle set and readonly set
+					: T extends Set<infer K>
+						? Set<UndefinedOnPartialDeep<K>>
+						: T extends ReadonlySet<infer K>
+							? ReadonlySet<UndefinedOnPartialDeep<K>>
+							// Handle object
+							: T extends Record<any, any>
+								? {
+									[KeyType in keyof T]: undefined extends T[KeyType]
+										? UndefinedOnPartialDeep<T[KeyType]> | undefined
+										: UndefinedOnPartialDeep<T[KeyType]>
+								}
+								: T; // If T is not builtins / function / array / map / set / object, return T
+
+// Handle tuples and arrays
+type UndefinedOnPartialList<T extends readonly unknown[]> = T extends []
+	? []
+	: T extends [infer F, ...infer R]
+		? [UndefinedOnPartialDeep<F>, ...UndefinedOnPartialDeep<R>]
+		: T extends readonly [infer F, ...infer R]
+			? readonly [UndefinedOnPartialDeep<F>, ...UndefinedOnPartialDeep<R>]
+			: T extends Array<infer F>
+				? Array<UndefinedOnPartialDeep<F>>
+				: T extends ReadonlyArray<infer F>
+					? ReadonlyArray<UndefinedOnPartialDeep<F>>
+					: never;

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;
+