type-fest 5.4.4 → 5.6.0

package/source/omit-deep.d.ts

@@ -5,7 +5,6 @@ import type {IsNever} from './is-never.d.ts';
 import type {LiteralUnion} from './literal-union.d.ts';
 import type {Paths} from './paths.d.ts';
 import type {SimplifyDeep} from './simplify-deep.d.ts';
-import type {Simplify} from './simplify.d.ts';
 import type {UnionToTuple} from './union-to-tuple.d.ts';
 import type {UnknownArray} from './unknown-array.d.ts';
 
@@ -18,7 +17,7 @@ It supports removing specific items from an array, replacing each removed item w
 
 Use-case: Remove unneeded parts of complex objects.
 
-Use [`Omit`](https://www.typescriptlang.org/docs/handbook/utility-types.html#omittype-keys) if you only need one level deep.
+Use [`Omit<T>`](https://www.typescriptlang.org/docs/handbook/utility-types.html#omittype-keys) if you only need one level deep.
 
 @example
 ```
@@ -94,34 +93,34 @@ type OmitDeepHelper<T, PathTuple extends UnknownArray> =
 Omit one path from the given object/array.
 */
 type OmitDeepWithOnePath<T, Path extends string | number> =
-T extends NonRecursiveType
-	? T
-	: T extends UnknownArray ? SetArrayAccess<OmitDeepArrayWithOnePath<T, Path>, IsArrayReadonly<T>>
-		: T extends object ? OmitDeepObjectWithOnePath<T, Path>
-			: T;
+	T extends NonRecursiveType
+		? T
+		: T extends UnknownArray ? SetArrayAccess<OmitDeepArrayWithOnePath<T, Path>, IsArrayReadonly<T>>
+			: T extends object ? OmitDeepObjectWithOnePath<T, Path>
+				: T;
 
 /**
 Omit one path from the given object.
 */
 type OmitDeepObjectWithOnePath<ObjectT extends object, P extends string | number> =
-P extends `${infer RecordKeyInPath}.${infer SubPath}`
-	? {
-		[Key in keyof ObjectT]:
-		IsEqual<RecordKeyInPath, ToString<Key>> extends true
-			? ExactKey<ObjectT, Key> extends infer RealKey
-				? RealKey extends keyof ObjectT
-					? OmitDeepWithOnePath<ObjectT[RealKey], SubPath>
+	P extends `${infer RecordKeyInPath}.${infer SubPath}`
+		? {
+			[Key in keyof ObjectT]:
+			IsEqual<RecordKeyInPath, ToString<Key>> extends true
+				? ExactKey<ObjectT, Key> extends infer RealKey
+					? RealKey extends keyof ObjectT
+						? OmitDeepWithOnePath<ObjectT[RealKey], SubPath>
+						: ObjectT[Key]
 					: ObjectT[Key]
 				: ObjectT[Key]
-			: ObjectT[Key]
-	}
-	: ExactKey<ObjectT, P> extends infer Key
-		? IsNever<Key> extends true
-			? ObjectT
-			: Key extends PropertyKey
-				? Simplify<Omit<ObjectT, Key>> // `Simplify` to prevent `Omit` from appearing in the resulting type
-				: ObjectT
-		: ObjectT;
+		}
+		: ExactKey<ObjectT, P> extends infer Key
+			? IsNever<Key> extends true
+				? ObjectT
+				: Key extends PropertyKey
+					? Omit<ObjectT, Key>
+					: ObjectT
+			: ObjectT;
 
 /**
 Omit one path from from the given array.

package/source/optional.d.ts

@@ -0,0 +1,31 @@
+/**
+Create a type that represents either the value or `undefined`, while stripping `null` from the type.
+
+Use-cases:
+- Enforcing the practice of using `undefined` instead of `null` as the "absence of value" marker.
+- Converting APIs that return `null` (DOM, JSON, legacy libraries) to use `undefined` consistently.
+
+@example
+```
+import type {Optional} from 'type-fest';
+
+// Adds `undefined` to the type
+type MaybeNumber = Optional<number>;
+//=> number | undefined
+
+// Strips `null` from the type
+type NullableString = Optional<string | null>;
+//=> string | undefined
+
+type Config = {
+	name: string;
+	description: Optional<string>;
+	//=> string | undefined
+};
+```
+
+@category Utilities
+*/
+export type Optional<Value> = Exclude<Value, null> | undefined;
+
+export {};

package/source/or-all.d.ts

@@ -0,0 +1,73 @@
+import type {SomeExtend} from './some-extend.d.ts';
+
+/**
+Returns a boolean for whether any of the given elements is `true`.
+
+Use-cases:
+- Check if at least one condition in a list of booleans is met.
+
+@example
+```
+import type {OrAll} from 'type-fest';
+
+type FFT = OrAll<[false, false, true]>;
+//=> true
+
+type FFF = OrAll<[false, false, false]>;
+//=> false
+```
+
+Note: When `boolean` is passed as an element, it is distributed into separate cases, and the final result is a union of those cases.
+For example, `OrAll<[false, boolean]>` expands to `OrAll<[false, true]> | OrAll<[false, false]>`, which simplifies to `true | false` (i.e., `boolean`).
+
+@example
+```
+import type {OrAll} from 'type-fest';
+
+type A = OrAll<[false, boolean]>;
+//=> boolean
+
+type B = OrAll<[true, boolean]>;
+//=> true
+```
+
+Note: If `never` is passed as an element, it is treated as `false` and the result is computed accordingly.
+
+@example
+```
+import type {OrAll} from 'type-fest';
+
+type A = OrAll<[never, never, true]>;
+//=> true
+
+type B = OrAll<[never, never, false]>;
+//=> false
+
+type C = OrAll<[never, never, never]>;
+//=> false
+
+type D = OrAll<[never, never, boolean]>;
+//=> boolean
+```
+
+Note: If `any` is passed as an element, it is treated as `boolean` and the result is computed accordingly.
+
+@example
+```
+import type {OrAll} from 'type-fest';
+
+type A = OrAll<[false, any]>;
+//=> boolean
+
+type B = OrAll<[true, any]>;
+//=> true
+```
+
+Note: `OrAll<[]>` evaluates to `false` because there are no `true` elements in an empty tuple. See [Wikipedia: Clause (logic) > Empty clauses](https://en.wikipedia.org/wiki/Clause_(logic)#Empty_clauses:~:text=The%20truth%20evaluation%20of%20an%20empty%20disjunctive%20clause%20is%20always%20false.).
+
+@see {@link Or}
+@see {@link AndAll}
+*/
+export type OrAll<T extends readonly boolean[]> = SomeExtend<T, true>;
+
+export {};

package/source/or.d.ts

@@ -1,8 +1,7 @@
-import type {If} from './if.d.ts';
-import type {IsNever} from './is-never.d.ts';
+import type {OrAll} from './or-all.d.ts';
 
 /**
-Returns a boolean for whether either of two given types is true.
+Returns a boolean for whether either of two given types is `true`.
 
 Use-case: Constructing complex conditional types where at least one condition must be satisfied.
 
@@ -74,16 +73,10 @@ type G = Or<never, never>;
 //=> false
 ```
 
+@see {@link OrAll}
 @see {@link And}
 @see {@link Xor}
 */
-export type Or<A extends boolean, B extends boolean> =
-	_Or<If<IsNever<A>, false, A>, If<IsNever<B>, false, B>>; // `never` is treated as `false`
-
-export type _Or<A extends boolean, B extends boolean> = A extends true
-	? true
-	: B extends true
-		? true
-		: false;
+export type Or<A extends boolean, B extends boolean> = OrAll<[A, B]>;
 
 export {};

package/source/package-json.d.ts

@@ -699,12 +699,12 @@ Type for [npm's `package.json` file](https://docs.npmjs.com/creating-a-package-j
 @category File
 */
 export type PackageJson =
-	JsonObject &
-	PackageJson.NodeJsStandard &
-	PackageJson.PackageJsonStandard &
-	PackageJson.NonStandardEntryPoints &
-	PackageJson.TypeScriptConfiguration &
-	PackageJson.YarnConfiguration &
-	PackageJson.JSPMConfiguration;
+	JsonObject
+	& PackageJson.NodeJsStandard
+	& PackageJson.PackageJsonStandard
+	& PackageJson.NonStandardEntryPoints
+	& PackageJson.TypeScriptConfiguration
+	& PackageJson.YarnConfiguration
+	& PackageJson.JSPMConfiguration;
 
 export {};

package/source/partial-deep.d.ts

@@ -44,12 +44,14 @@ type DefaultPartialDeepOptions = {
 };
 
 /**
-Create a type from another type with all keys and nested keys set to optional.
+Create a deeply optional version of another type.
 
 Use-cases:
 - Merging a default settings/config object with another object, the second object would be a deep partial of the default object.
 - Mocking and testing complex entities, where populating an entire object with its keys would be redundant in terms of the mock or test.
 
+Use [`Partial<T>`](https://www.typescriptlang.org/docs/handbook/utility-types.html#partialtype) if you only need one level deep.
+
 @example
 ```
 import type {PartialDeep} from 'type-fest';

package/source/pascal-case.d.ts

@@ -12,6 +12,7 @@ import type {PascalCase} from 'type-fest';
 
 const someVariable: PascalCase<'foo-bar'> = 'FooBar';
 const preserveConsecutiveUppercase: PascalCase<'foo-BAR-baz', {preserveConsecutiveUppercase: true}> = 'FooBARBaz';
+const splitOnPunctuation: PascalCase<'foo-bar>>baz', {splitOnPunctuation: true}> = 'FooBarBaz';
 
 // Advanced
 

package/source/pascal-cased-properties-deep.d.ts

@@ -48,6 +48,13 @@ const preserveConsecutiveUppercase: PascalCasedPropertiesDeep<{fooBAR: {fooBARBi
 		}],
 	},
 };
+
+const splitOnPunctuation: PascalCasedPropertiesDeep<{'user@info': {'user::id': number; 'user::name': string}}, {splitOnPunctuation: true}> = {
+	UserInfo: {
+		UserId: 1,
+		UserName: 'Tom',
+	},
+};
 ```
 
 @category Change case

package/source/pascal-cased-properties.d.ts

@@ -3,7 +3,7 @@ import type {ApplyDefaultOptions} from './internal/index.d.ts';
 import type {PascalCase} from './pascal-case.d.ts';
 
 /**
-Convert object properties to pascal case but not recursively.
+Convert top-level object properties to pascal case.
 
 This can be useful when, for example, converting some API types from a different style.
 
@@ -27,6 +27,10 @@ const result: PascalCasedProperties<User> = {
 const preserveConsecutiveUppercase: PascalCasedProperties<{fooBAR: string}, {preserveConsecutiveUppercase: true}> = {
 	FooBAR: 'string',
 };
+
+const splitOnPunctuation: PascalCasedProperties<{'foo::bar': string}, {splitOnPunctuation: true}> = {
+	FooBar: 'string',
+};
 ```
 
 @category Change case

package/source/pick-deep.d.ts

@@ -5,6 +5,7 @@ import type {Paths} from './paths.d.ts';
 import type {Simplify} from './simplify.d.ts';
 import type {UnionToIntersection} from './union-to-intersection.d.ts';
 import type {UnknownArray} from './unknown-array.d.ts';
+import type {SimplifyDeep} from './simplify-deep.d.ts';
 
 /**
 Pick properties from a deeply-nested object.
@@ -13,6 +14,8 @@ It supports recursing into arrays.
 
 Use-case: Distill complex objects down to the components you need to target.
 
+Use [`Pick<T>`](https://www.typescriptlang.org/docs/handbook/utility-types.html#picktype-keys) if you only need one level deep.
+
 @example
 ```
 import type {PickDeep, PartialDeep} from 'type-fest';
@@ -36,24 +39,15 @@ type Configuration = {
 };
 
 type NameConfig = PickDeep<Configuration, 'userConfig.name'>;
-// type NameConfig = {
-// 	userConfig: {
-// 		name: string;
-// 	}
-// };
+//=> {userConfig: {name: string}}
 
 // Supports optional properties
 type User = PickDeep<PartialDeep<Configuration>, 'userConfig.name' | 'userConfig.age'>;
-// type User = {
-// 	userConfig?: {
-// 		name?: string;
-// 		age?: number;
-// 	};
-// };
+//=> {userConfig?: {name?: string; age?: number}}
 
 // Supports array
 type AddressConfig = PickDeep<Configuration, 'userConfig.address.0'>;
-// type AddressConfig = {
+//=> {
 // 	userConfig: {
 // 		address: [{
 // 			city1: string;
@@ -64,14 +58,7 @@ type AddressConfig = PickDeep<Configuration, 'userConfig.address.0'>;
 
 // Supports recurse into array
 type Street = PickDeep<Configuration, 'userConfig.address.1.street2'>;
-// type Street = {
-// 	userConfig: {
-// 		address: [
-// 			unknown,
-// 			{street2: string}
-// 		];
-// 	};
-// }
+//=> {userConfig: {address: [unknown, {street2: string}]}}
 ```
 
 @category Object
@@ -86,7 +73,7 @@ export type PickDeep<T, PathUnion extends Paths<T>> =
 			}[PathUnion]
 			>
 			: T extends object
-				? Simplify<UnionToIntersection<{
+				? SimplifyDeep<UnionToIntersection<{
 					[P in PathUnion]: InternalPickDeep<T, P>;
 				}[PathUnion]>>
 				: never;

package/source/readonly-deep.d.ts

@@ -1,12 +1,14 @@
 import type {BuiltIns, HasMultipleCallSignatures} from './internal/index.d.ts';
 
 /**
-Convert `object`s, `Map`s, `Set`s, and `Array`s and all of their keys/elements into immutable structures recursively.
+Create a deeply immutable version of another type.
 
 This is useful when a deeply nested structure needs to be exposed as completely immutable, for example, an imported JSON module or when receiving an API response that is passed around.
 
 Please upvote [this issue](https://github.com/microsoft/TypeScript/issues/13923) if you want to have this type as a built-in in TypeScript.
 
+Use [`Readonly<T>`](https://www.typescriptlang.org/docs/handbook/utility-types.html#readonlytype) if you only need one level deep.
+
 @example
 ```
 import type {ReadonlyDeep} from 'type-fest';
@@ -83,8 +85,8 @@ export type ReadonlyDeep<T> = T extends BuiltIns
 				? 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[]]
+					// 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>]

package/source/remove-prefix.d.ts

@@ -110,23 +110,23 @@ type D = RemovePrefix<`handle${Capitalize<string>}`, 'handle'>;
 @category Template literal
 */
 export type RemovePrefix<S extends string, Prefix extends string, Options extends RemovePrefixOptions = {}> =
-IfNotAnyOrNever<
-	S,
 	IfNotAnyOrNever<
-		Prefix,
-		_RemovePrefix<S, Prefix, ApplyDefaultOptions<RemovePrefixOptions, DefaultRemovePrefixOptions, Options>>,
-		string,
-		S
-	>
->;
+		S,
+		IfNotAnyOrNever<
+			Prefix,
+			_RemovePrefix<S, Prefix, ApplyDefaultOptions<RemovePrefixOptions, DefaultRemovePrefixOptions, Options>>,
+			string,
+			S
+		>
+	>;
 
 type _RemovePrefix<S extends string, Prefix extends string, Options extends Required<RemovePrefixOptions>> =
-Prefix extends string // For distributing `Prefix`
-	? S extends `${Prefix}${infer Rest}`
-		? Or<IsStringLiteral<Prefix>, Not<Options['strict']>> extends true
-			? Rest
-			: string // Fallback to `string` when `Prefix` is non-literal and `strict` is disabled
-		: S // Return back `S` when `Prefix` is not present at the start of `S`
-	: never;
+	Prefix extends string // For distributing `Prefix`
+		? S extends `${Prefix}${infer Rest}`
+			? Or<IsStringLiteral<Prefix>, Not<Options['strict']>> extends true
+				? Rest
+				: string // Fallback to `string` when `Prefix` is non-literal and `strict` is disabled
+			: S // Return back `S` when `Prefix` is not present at the start of `S`
+		: never;
 
 export {};

package/source/replace.d.ts

@@ -27,7 +27,7 @@ declare function replace<
 >(
 	input: Input,
 	search: Search,
-	replacement: Replacement
+	replacement: Replacement,
 ): Replace<Input, Search, Replacement>;
 
 declare function replaceAll<
@@ -37,7 +37,7 @@ declare function replaceAll<
 >(
 	input: Input,
 	search: Search,
-	replacement: Replacement
+	replacement: Replacement,
 ): Replace<Input, Search, Replacement, {all: true}>;
 
 // The return type is the exact string literal, not just `string`.

package/source/require-all-or-none.d.ts

@@ -9,7 +9,7 @@ Requires all of the keys in the given object.
 type RequireAll<ObjectType, KeysType extends keyof ObjectType> = Required<Pick<ObjectType, KeysType>>;
 
 /**
-Create a type that requires all of the given keys or none of the given keys. The remaining keys are kept as is.
+Create a type that requires all of the given keys or none of the given keys, while keeping the remaining keys as is.
 
 Use-cases:
 - Creating interfaces for components with mutually-inclusive keys.

package/source/require-at-least-one.d.ts

@@ -5,7 +5,7 @@ import type {IsAny} from './is-any.d.ts';
 import type {IsNever} from './is-never.d.ts';
 
 /**
-Create a type that requires at least one of the given keys. The remaining keys are kept as is.
+Create a type that requires at least one of the given keys, while keeping the remaining keys as is.
 
 @example
 ```
@@ -40,11 +40,9 @@ type _RequireAtLeastOne<
 	KeysType extends keyof ObjectType,
 > = {
 	// For each `Key` in `KeysType` make a mapped type:
-	[Key in KeysType]-?: Required<Pick<ObjectType, Key>> & // 1. Make `Key`'s type required
-	// 2. Make all other keys in `KeysType` optional
-		Partial<Pick<ObjectType, Exclude<KeysType, Key>>>;
-}[KeysType] &
-// 3. Add the remaining keys not in `KeysType`
-Except<ObjectType, KeysType>;
+	[Key in KeysType]-?: Required<Pick<ObjectType, Key>> // 1. Make `Key`'s type required
+		& Partial<Pick<ObjectType, Exclude<KeysType, Key>>>; // 2. Make all other keys in `KeysType` optional
+}[KeysType]
+& Except<ObjectType, KeysType>; // 3. Add the remaining keys not in `KeysType`
 
 export {};

package/source/require-exactly-one.d.ts

@@ -4,7 +4,7 @@ import type {IsAny} from './is-any.d.ts';
 import type {IsNever} from './is-never.d.ts';
 
 /**
-Create a type that requires exactly one of the given keys and disallows more. The remaining keys are kept as is.
+Create a type that requires exactly one of the given keys and disallows more, while keeping the remaining keys as is.
 
 Use-cases:
 - Creating interfaces for components that only need one of the keys to display properly.
@@ -41,8 +41,8 @@ export type RequireExactlyOne<ObjectType, KeysType extends keyof ObjectType = ke
 
 type _RequireExactlyOne<ObjectType, KeysType extends keyof ObjectType> =
 	{[Key in KeysType]: (
-		Required<Pick<ObjectType, Key>> &
-		Partial<Record<Exclude<KeysType, Key>, never>>
+		Required<Pick<ObjectType, Key>>
+		& Partial<Record<Exclude<KeysType, Key>, never>>
 	)}[KeysType] & Omit<ObjectType, KeysType>;
 
 export {};

package/source/require-one-or-none.d.ts

@@ -5,7 +5,7 @@ import type {IsAny} from './is-any.d.ts';
 import type {IsNever} from './is-never.d.ts';
 
 /**
-Create a type that requires exactly one of the given keys and disallows more, or none of the given keys. The remaining keys are kept as is.
+Create a type that requires exactly one of the given keys or none of the given keys, while keeping the remaining keys as is.
 
 @example
 ```

package/source/required-deep.d.ts

@@ -3,12 +3,14 @@ import type {IsNever} from './is-never.d.ts';
 import type {Simplify} from './simplify.d.ts';
 
 /**
-Create a type from another type with all keys and nested keys set to required.
+Create a deeply required version of another type.
 
 Use-cases:
 - Creating optional configuration interfaces where the underlying implementation still requires all options to be fully specified.
 - Modeling the resulting type after a deep merge with a set of defaults.
 
+Use [`Required<T>`](https://www.typescriptlang.org/docs/handbook/utility-types.html#requiredtype) if you only need one level deep.
+
 @example
 ```
 import type {RequiredDeep} from 'type-fest';

package/source/screaming-snake-case.d.ts

@@ -14,6 +14,7 @@ import type {ScreamingSnakeCase} from 'type-fest';
 
 const someVariable: ScreamingSnakeCase<'fooBar'> = 'FOO_BAR';
 const someVariableNoSplitOnNumbers: ScreamingSnakeCase<'p2pNetwork', {splitOnNumbers: false}> = 'P2P_NETWORK';
+const someVariableWithPunctuation: ScreamingSnakeCase<'div.card::after', {splitOnPunctuation: true}> = 'DIV_CARD_AFTER';
 
 ```
 

package/source/set-non-nullable-deep.d.ts

@@ -1,4 +1,6 @@
 import type {NonRecursiveType, StringToNumber} from './internal/index.d.ts';
+import type {IsAny} from './is-any.d.ts';
+import type {NonNullableDeep} from './non-nullable-deep.d.ts';
 import type {Paths} from './paths.d.ts';
 import type {SetNonNullable} from './set-non-nullable.d.ts';
 import type {Simplify} from './simplify.d.ts';
@@ -8,7 +10,7 @@ import type {UnknownArray} from './unknown-array.d.ts';
 /**
 Create a type that makes the specified keys non-nullable (removes `null` and `undefined`), supports deeply nested key paths, and leaves all other keys unchanged.
 
-NOTE: Optional modifiers (`?`) are not removed from properties. For example, `SetNonNullableDeep<{foo?: string | null | undefined}, 'foo'>` will result in `{foo?: string}`.
+NOTE: Optional modifiers (`?`) are not removed from properties. For example, `SetNonNullableDeep<{foo?: string | null | undefined}, 'foo'>` will result in `{foo?: string}`. To remove both optional modifiers and nullables, use {@link SetRequiredDeep} in conjunction with this type.
 
 @example
 ```
@@ -55,8 +57,9 @@ type ArrayExample2 = SetNonNullableDeep<{a: [(number | null)?, (number | null)?]
 
 @category Object
 */
-export type SetNonNullableDeep<BaseType, KeyPaths extends Paths<BaseType>> =
-	SetNonNullableDeepHelper<BaseType, UnionToTuple<KeyPaths>>;
+export type SetNonNullableDeep<BaseType, KeyPaths extends Paths<BaseType>> = IsAny<KeyPaths> extends true
+	? NonNullableDeep<BaseType>
+	: SetNonNullableDeepHelper<BaseType, UnionToTuple<KeyPaths>>;
 
 /**
 Internal helper for {@link SetNonNullableDeep}.

package/source/set-non-nullable.d.ts

@@ -1,5 +1,5 @@
 /**
-Create a type that makes the given keys non-nullable, where the remaining keys are kept as is.
+Create a type that makes the given keys non-nullable, while keeping the remaining keys as is.
 
 If no keys are given, all keys will be made non-nullable.
 
@@ -15,19 +15,12 @@ type Foo = {
 	c?: boolean | null;
 };
 
+// Note: In the following example, `c` can no longer be `null`, but it's still optional.
 type SomeNonNullable = SetNonNullable<Foo, 'b' | 'c'>;
-// type SomeNonNullable = {
-// 	a: number | null;
-// 	b: string; // Can no longer be undefined.
-// 	c?: boolean; // Can no longer be null, but is still optional.
-// }
+//=> {a: null | number; b: string; c?: boolean}
 
 type AllNonNullable = SetNonNullable<Foo>;
-// type AllNonNullable = {
-// 	a: number; // Can no longer be null.
-// 	b: string; // Can no longer be undefined.
-// 	c?: boolean; // Can no longer be null, but is still optional.
-// }
+//=> {a: number; b: string; c?: boolean}
 ```
 
 @category Object

package/source/set-optional.d.ts

@@ -3,7 +3,7 @@ import type {HomomorphicPick} from './internal/index.d.ts';
 import type {Simplify} from './simplify.d.ts';
 
 /**
-Create a type that makes the given keys optional. The remaining keys are kept as is. The sister of the `SetRequired` type.
+Create a type that makes the given keys optional, while keeping the remaining keys as is.
 
 Use-case: You want to define a single model where the only thing that changes is whether or not some of the keys are optional.
 
@@ -18,11 +18,7 @@ type Foo = {
 };
 
 type SomeOptional = SetOptional<Foo, 'b' | 'c'>;
-// type SomeOptional = {
-// 	a: number;
-// 	b?: string; // Was already optional and still is.
-// 	c?: boolean; // Is now optional.
-// }
+//=> {a: number; b?: string; c?: boolean}
 ```
 
 @category Object
@@ -36,10 +32,10 @@ export type SetOptional<BaseType, Keys extends keyof BaseType> =
 type _SetOptional<BaseType, Keys extends keyof BaseType> =
 	BaseType extends unknown // To distribute `BaseType` when it's a union type.
 		? Simplify<
-		// Pick just the keys that are readonly from the base type.
-			Except<BaseType, Keys> &
-		// Pick the keys that should be mutable from the base type and make them mutable.
-			Partial<HomomorphicPick<BaseType, Keys>>
+			// Pick just the keys that are readonly from the base type.
+			Except<BaseType, Keys>
+			// Pick the keys that should be mutable from the base type and make them mutable.
+			& Partial<HomomorphicPick<BaseType, Keys>>
 		>
 		: never;
 

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

@@ -38,14 +38,14 @@ type MergeObjectToArray<TArray extends UnknownArray, TObject, TArrayCopy extends
 					: K extends keyof TObject ? TObject[K] : TArray[K]
 			}
 		: TObject extends object
-			// If `TObject` is a object witch key is number like `{0: string, 1: number}`
+			// If `TObject` is an object with number keys like `{0: string, 1: number}`
 			? {
 				[K in keyof TArray]:
 				K extends `${infer NumberK extends number}`
 					? NumberK extends keyof TObject ? TObject[NumberK] : TArray[K]
 					: number extends K
 					// If array key `K` is `number`, means it's a rest parameter, we should set the rest parameter type to corresponding type in `TObject`.
-					// example: `MergeObjectToParamterArray<[string, ...boolean[]], {1: number}>` => `[string, ...number[]]`
+					// example: `MergeObjectToArray<[string, ...boolean[]], {1: number}>` => `[string, ...number[]]`
 						? StaticPartOfArray<TArrayCopy>['length'] extends keyof TObject
 							? TObject[StaticPartOfArray<TArrayCopy>['length']]
 							: TArray[K]