@depup/type-fest 5.4.4-depup.0 → 5.9.0-depup.0

package/source/remove-suffix.d.ts

@@ -0,0 +1,114 @@
+import type {ApplyDefaultOptions} from './internal/object.d.ts';
+import type {IfNotAnyOrNever, Not} from './internal/type.d.ts';
+import type {IsStringLiteral} from './is-string-literal.d.ts';
+import type {IsNever} from './is-never.d.ts';
+import type {Or} from './or.d.ts';
+import type {If} from './if.d.ts';
+
+/**
+@see {@link RemoveSuffix}
+*/
+export type RemoveSuffixOptions = {
+	/**
+	When enabled, instantiations with non-literal suffixes (e.g., `string`, `Uppercase<string>`, `` `.${string}` ``) simply return `string`, since their precise structure cannot be statically determined.
+
+	Note: Disabling this option can produce misleading results that might not reflect the actual runtime behavior.
+	For example, ``RemoveSuffix<'report.pdf', `.${string}`, {strict: false}>`` returns `'report'`, but at runtime, suffix could be `'.txt'` (which satisfies `` `.${string}` ``) and removing `'.txt'` from `'report.pdf'` would not result in `'report'`.
+
+	So, it is recommended to not disable this option unless you are aware of the implications.
+
+	@default true
+
+	@example
+	```
+	import type {RemoveSuffix} from 'type-fest';
+
+	type A = RemoveSuffix<'report.pdf', `.${string}`, {strict: true}>;
+	//=> string
+
+	type B = RemoveSuffix<'report.pdf', `.${string}`, {strict: false}>;
+	//=> 'report'
+
+	type C = RemoveSuffix<'on-change', string, {strict: true}>;
+	//=> string
+
+	type D = RemoveSuffix<'on-change', string, {strict: false}>;
+	//=> 'o'
+
+	type E = RemoveSuffix<`${number}/${string}`, `/${string}`, {strict: true}>;
+	//=> string
+
+	type F = RemoveSuffix<`${number}/${string}`, `/${string}`, {strict: false}>;
+	//=> `${number}`
+	```
+
+	Note: This option has no effect when only the input string type is non-literal. For example, ``RemoveSuffix<`${string}.pdf`, '.pdf'>`` will always return `string`.
+
+	@example
+	```
+	import type {RemoveSuffix} from 'type-fest';
+
+	type A = RemoveSuffix<`${string}.pdf`, '.pdf', {strict: true}>;
+	//=> string
+
+	type B = RemoveSuffix<`${string}.pdf`, '.pdf', {strict: false}>;
+	//=> string
+
+	type C = RemoveSuffix<`${number}px`, 'px', {strict: true}>;
+	//=> `${number}`
+
+	type D = RemoveSuffix<`${number}px`, 'px', {strict: false}>;
+	//=> `${number}`
+	```
+	*/
+	strict?: boolean;
+};
+
+type DefaultRemoveSuffixOptions = {
+	strict: true;
+};
+
+/**
+Remove the specified suffix from the end of a string.
+
+@example
+```
+import type {RemoveSuffix} from 'type-fest';
+
+type A = RemoveSuffix<'report.pdf', '.pdf'>;
+//=> 'report'
+
+type B = RemoveSuffix<'bg-blue-500' | 'text-green-500' | 'border-slate-500', '-500'>;
+//=> 'bg-blue' | 'border-slate' | 'text-green'
+
+type C = RemoveSuffix<'report.pdf', '.txt'>;
+//=> 'report.pdf'
+
+type D = RemoveSuffix<`api/${string}/analytics`, '/analytics'>;
+//=> `api/${string}`
+```
+
+@see {@link RemoveSuffixOptions}
+
+@category String
+@category Template literal
+*/
+export type RemoveSuffix<S extends string, Suffix extends string, Options extends RemoveSuffixOptions = {}> =
+	IfNotAnyOrNever<S, {
+		ifNot: If<
+			IsNever<Suffix>,
+			S,
+			_RemoveSuffix<S, Suffix, ApplyDefaultOptions<RemoveSuffixOptions, DefaultRemoveSuffixOptions, Options>>
+		>;
+	}>;
+
+type _RemoveSuffix<S extends string, Suffix extends string, Options extends Required<RemoveSuffixOptions>> =
+	Suffix extends string // For distributing `Suffix`
+		? Or<IsStringLiteral<Suffix>, Not<Options['strict']>> extends true
+			? S extends `${infer Rest}${Suffix}`
+				? Rest
+				: S // Return back `S` when `Suffix` is not present at the end of `S`
+			: string // Fallback to `string` when `Suffix` is non-literal and `strict` is enabled
+		: never;
+
+export {};

package/source/rename-keys.d.ts

@@ -0,0 +1,163 @@
+import type {IsLiteral} from './is-literal.d.ts';
+import type {ReadonlyKeysOf} from './readonly-keys-of.d.ts';
+import type {RequiredKeysOf} from './required-keys-of.d.ts';
+import type {OptionalKeysOf} from './optional-keys-of.d.ts';
+import type {OmitIndexSignature} from './omit-index-signature.d.ts';
+import type {SetRequired} from './set-required.d.ts';
+import type {SetReadonly} from './set-readonly.d.ts';
+import type {IfNotAnyOrNever, IsExactOptionalPropertyTypesEnabled} from './internal/type.d.ts';
+
+/**
+Rename keys in an object type according to a map of old-to-new names.
+
+@example
+```
+import type {RenameKeys} from 'type-fest';
+
+type User = {
+	id: string;
+	firstName: string;
+	createdAt: Date;
+};
+
+type Renamed = RenameKeys<User, {firstName: 'first_name'; createdAt: 'created_at'}>;
+//=> {id: string; first_name: string; created_at: Date}
+```
+
+@example
+```
+import type {RenameKeys} from 'type-fest';
+
+type SearchInput = {
+	textQuery: string;
+	voiceQuery: Blob;
+	imageQuery: File;
+};
+
+type Normalized = RenameKeys<SearchInput, {textQuery: 'query'; voiceQuery: 'query'; imageQuery: 'query'}>;
+//=> {query: string | Blob | File}
+```
+
+Note: When multiple source keys map to the same target, the target's value type is the union of the contributors' value types. The target is optional only when every contributor is optional, and is `readonly` when any contributor is `readonly`. With `exactOptionalPropertyTypes` disabled, the value type of a mixed-optionality merge also includes `undefined`.
+
+@example
+```
+import type {RenameKeys} from 'type-fest';
+
+// All colliding keys are required, so the target is required.
+type A = RenameKeys<{a: 1; b: 2}, {a: 'x'; b: 'x'}>;
+//=> {x: 1 | 2}
+
+// All colliding keys are optional, so the target is optional.
+type B = RenameKeys<{a?: 1; b?: 2}, {a: 'x'; b: 'x'}>;
+//=> {x?: 1 | 2}
+
+// One of the colliding keys is required, so the target is required.
+type C = RenameKeys<{a: 1; b?: 2}, {a: 'x'; b: 'x'}>;
+//=> {x: 1 | 2}
+
+// One of the colliding keys is `readonly`, so the target is `readonly`.
+type D = RenameKeys<{readonly a: 1; b: 2}, {a: 'x'; b: 'x'}>;
+//=> {readonly x: 1 | 2}
+```
+
+@example
+```
+// @exactOptionalPropertyTypes: false
+import type {RenameKeys} from 'type-fest';
+
+// With `exactOptionalPropertyTypes` disabled, a mixed-optionality merge includes `undefined`.
+type E = RenameKeys<{a?: 1; b: 2}, {a: 'x'; b: 'x'}>;
+//=> {x: 1 | 2 | undefined}
+```
+
+Note: A union target distributes, producing one output key per member.
+
+@example
+```
+import type {RenameKeys} from 'type-fest';
+
+type A = RenameKeys<{a: string}, {a: 'b' | 'c'}>;
+//=> {b: string; c: string}
+```
+
+Note: An entry whose value is not a literal `PropertyKey` (such as `string`) is also ignored, leaving that key's name unchanged.
+
+@example
+```
+import type {RenameKeys} from 'type-fest';
+
+type A = RenameKeys<{a: 1}, {a: string}>;
+//=> {a: 1}
+
+type B = RenameKeys<{a: 1; b: 2}, {a: 'x'; b: symbol}>;
+//=> {x: 1; b: 2}
+```
+
+Note: A rename map entry whose key is not a property of the source type is ignored.
+
+@example
+```
+import type {RenameKeys} from 'type-fest';
+
+type A = RenameKeys<{a: 1; b: 2}, {a: 'x'; c: 'y'}>;
+//=> {x: 1; b: 2}
+```
+
+@category Object
+*/
+export type RenameKeys<
+	BaseType extends object,
+	RenameMap extends Record<PropertyKey, PropertyKey>,
+> = IfNotAnyOrNever<BaseType, {
+	ifNot: BaseType extends unknown // For distributing `BaseType`
+		? RenameMap extends unknown // For distributing `RenameMap`
+			? RenameOnce<BaseType, NormalizeMap<RenameMap>>
+			: never
+		: never;
+}>;
+
+type RenameOnce<BaseType extends object, RenameMap extends Record<PropertyKey, PropertyKey>> =
+	RestoreMergedUndefined<BaseType, RenameMap,
+		ApplyReadonly<BaseType, RenameMap,
+			ApplyRequired<BaseType, RenameMap,
+				RenameNaive<BaseType, RenameMap>>>>;
+
+type RenameNaive<BaseType extends object, RenameMap extends Record<PropertyKey, PropertyKey>> = {
+	// Two keys mapping to one target produce a union value and keep only the first key's modifiers.
+	// Like for example, `{a?: 1; b: 2}` with `{a: 'x'; b: 'x'}` produces `{x?: 1 | 2}`, taking `a`'s optional.
+	[Key in keyof BaseType as TargetOf<Key, RenameMap>]: Required<BaseType>[Key];
+};
+
+// A merged target kept only one modifier in `RenameNaive`, so re-force these from every contributor.
+type ApplyRequired<BaseType extends object, RenameMap extends Record<PropertyKey, PropertyKey>, Renamed> =
+	SetRequired<Renamed, TargetOf<RequiredKeysOf<OmitIndexSignature<BaseType>>, RenameMap> & keyof Renamed>;
+
+type ApplyReadonly<BaseType extends object, RenameMap extends Record<PropertyKey, PropertyKey>, Renamed> =
+	SetReadonly<Renamed, TargetOf<ReadonlyKeysOf<OmitIndexSignature<BaseType>>, RenameMap> & keyof Renamed>;
+
+// `exactOptionalPropertyTypes` off keeps `undefined` on a target that merged a required and an optional source.
+// Source `{a?: 1; x: 2}` with `{a: 'x'}` gives `{x: 1 | 2 | undefined}`.
+type RestoreMergedUndefined<BaseType extends object, RenameMap extends Record<PropertyKey, PropertyKey>, Result> =
+	IsExactOptionalPropertyTypesEnabled extends true
+		? Result
+		: {
+			[Key in keyof Result]: Key extends MergedTargets<BaseType, RenameMap>
+				? Result[Key] | undefined
+				: Result[Key];
+		};
+
+type MergedTargets<BaseType extends object, RenameMap extends Record<PropertyKey, PropertyKey>> =
+	// Targets renamed from both a required and an optional key prefer the required modifier.
+	// Required `b` and optional `a` both rename to `x` in `{a?: 1; b: 2}` with `{a: 'x'; b: 'x'}`.
+	TargetOf<RequiredKeysOf<OmitIndexSignature<BaseType>>, RenameMap>
+	& TargetOf<OptionalKeysOf<OmitIndexSignature<BaseType>>, RenameMap>;
+
+type NormalizeMap<RenameMap extends Record<PropertyKey, PropertyKey>> = {
+	-readonly [Key in keyof RenameMap as true extends IsLiteral<RenameMap[Key]> ? Key : never]-?: RenameMap[Key];
+};
+
+type TargetOf<SourceKey extends PropertyKey, RenameMap extends Record<PropertyKey, PropertyKey>> =
+	SourceKey extends keyof RenameMap ? RenameMap[SourceKey] : SourceKey;
+
+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.
@@ -40,11 +40,11 @@ const responder2: RequireAllOrNone<Responder, 'text' | 'json'> = {
 @category Object
 */
 export type RequireAllOrNone<ObjectType, KeysType extends keyof ObjectType = keyof ObjectType> =
-	IfNotAnyOrNever<ObjectType,
-		If<IsNever<KeysType>,
+	IfNotAnyOrNever<ObjectType, {
+		ifNot: If<IsNever<KeysType>,
 			ObjectType,
-			_RequireAllOrNone<ObjectType, If<IsAny<KeysType>, keyof ObjectType, KeysType>>
-		>>;
+			_RequireAllOrNone<ObjectType, If<IsAny<KeysType>, keyof ObjectType, KeysType>>>;
+	}>;
 
 type _RequireAllOrNone<ObjectType, KeysType extends keyof ObjectType> = (
 	| RequireAll<ObjectType, KeysType>

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
 ```
@@ -29,22 +29,20 @@ export type RequireAtLeastOne<
 	ObjectType,
 	KeysType extends keyof ObjectType = keyof ObjectType,
 > =
-	IfNotAnyOrNever<ObjectType,
-		If<IsNever<KeysType>,
+	IfNotAnyOrNever<ObjectType, {
+		ifNot: If<IsNever<KeysType>,
 			never,
-			_RequireAtLeastOne<ObjectType, If<IsAny<KeysType>, keyof ObjectType, KeysType>>
-		>>;
+			_RequireAtLeastOne<ObjectType, If<IsAny<KeysType>, keyof ObjectType, KeysType>>>;
+	}>;
 
 type _RequireAtLeastOne<
 	ObjectType,
 	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.
@@ -33,16 +33,16 @@ const responder: RequireExactlyOne<Responder, 'text' | 'json'> = {
 @category Object
 */
 export type RequireExactlyOne<ObjectType, KeysType extends keyof ObjectType = keyof ObjectType> =
-	IfNotAnyOrNever<ObjectType,
-		If<IsNever<KeysType>,
+	IfNotAnyOrNever<ObjectType, {
+		ifNot: If<IsNever<KeysType>,
 			never,
-			_RequireExactlyOne<ObjectType, If<IsAny<KeysType>, keyof ObjectType, KeysType>>
-		>>;
+			_RequireExactlyOne<ObjectType, If<IsAny<KeysType>, keyof ObjectType, KeysType>>>;
+	}>;
 
 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
 ```
@@ -35,11 +35,11 @@ const responder3: Responder = {
 @category Object
 */
 export type RequireOneOrNone<ObjectType, KeysType extends keyof ObjectType = keyof ObjectType> =
-	IfNotAnyOrNever<ObjectType,
-		If<IsNever<KeysType>,
+	IfNotAnyOrNever<ObjectType, {
+		ifNot: If<IsNever<KeysType>,
 			ObjectType,
-			_RequireOneOrNone<ObjectType, If<IsAny<KeysType>, keyof ObjectType, KeysType>>
-		>>;
+			_RequireOneOrNone<ObjectType, If<IsAny<KeysType>, keyof ObjectType, KeysType>>>;
+	}>;
 
 type _RequireOneOrNone<ObjectType, KeysType extends keyof ObjectType> = (
 	| RequireExactlyOne<ObjectType, KeysType>

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

@@ -1,5 +1,7 @@
 import type {ApplyDefaultOptions} from './internal/object.d.ts';
 import type {IfNotAnyOrNever, NonRecursiveType} from './internal/type.d.ts';
+import type {IsAny} from './is-any.d.ts';
+import type {IsUnknown} from './is-unknown.d.ts';
 import type {OptionalKeysOf} from './optional-keys-of.d.ts';
 import type {Simplify} from './simplify.d.ts';
 import type {UnknownArray} from './unknown-array.d.ts';
@@ -91,18 +93,24 @@ const userMaskSettings: UserMask = {
 @category Object
 */
 export type Schema<Type, Value, Options extends SchemaOptions = {}> =
-	IfNotAnyOrNever<Type,
-		_Schema<Type, Value, ApplyDefaultOptions<SchemaOptions, DefaultSchemaOptions, Options>>,
-		Value, Value>;
+	IfNotAnyOrNever<Type, {
+		ifNot: _Schema<Type, Value, ApplyDefaultOptions<SchemaOptions, DefaultSchemaOptions, Options>>;
+		ifAny: Value;
+		ifNever: Value;
+	}>;
 
 type _Schema<Type, Value, Options extends Required<SchemaOptions>> =
-	Type extends NonRecursiveType | Map<unknown, unknown> | Set<unknown> | ReadonlyMap<unknown, unknown> | ReadonlySet<unknown>
+	IsAny<Type> extends true
 		? Value
-		: Type extends UnknownArray
-			? Options['recurseIntoArrays'] extends false
+		: IsUnknown<Type> extends true
+			? Value
+			: Type extends NonRecursiveType | Map<unknown, unknown> | Set<unknown> | ReadonlyMap<unknown, unknown> | ReadonlySet<unknown>
 				? Value
-				: SchemaHelper<Type, Value, Options>
-			: SchemaHelper<Type, Value, Options>;
+				: Type extends UnknownArray
+					? Options['recurseIntoArrays'] extends false
+						? Value
+						: SchemaHelper<Type, Value, Options>
+					: SchemaHelper<Type, Value, Options>;
 
 /**
 Internal helper for {@link _Schema}.

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,14 +1,17 @@
-import type {NonRecursiveType, StringToNumber} from './internal/index.d.ts';
+import type {NonRecursiveType} 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';
+import type {StringToNumber} from './string-to-number.d.ts';
 import type {UnionToTuple} from './union-to-tuple.d.ts';
 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 +58,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]

package/source/set-readonly.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 readonly. The remaining keys are kept as is.
+Create a type that makes the given keys readonly, 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 readonly.
 
@@ -18,11 +18,7 @@ type Foo = {
 };
 
 type SomeReadonly = SetReadonly<Foo, 'b' | 'c'>;
-// type SomeReadonly = {
-// 	a: number;
-// 	readonly b: string; // Was already readonly and still is.
-// 	readonly c: boolean; // Is now readonly.
-// }
+//=> {a: number; readonly b: string; readonly c: boolean}
 ```
 
 @category Object
@@ -36,8 +32,8 @@ export type SetReadonly<BaseType, Keys extends keyof BaseType> =
 export type _SetReadonly<BaseType, Keys extends keyof BaseType> =
 	BaseType extends unknown // To distribute `BaseType` when it's a union type.
 		? Simplify<
-			Except<BaseType, Keys> &
-			Readonly<HomomorphicPick<BaseType, Keys>>
+			Except<BaseType, Keys>
+			& Readonly<HomomorphicPick<BaseType, Keys>>
 		>
 		: never;
 

package/source/set-required-deep.d.ts

@@ -1,14 +1,15 @@
 import type {IsAny} from './is-any.d.ts';
-import type {NonRecursiveType, StringToNumber} from './internal/index.d.ts';
+import type {NonRecursiveType} from './internal/index.d.ts';
 import type {Paths} from './paths.d.ts';
 import type {SetRequired} from './set-required.d.ts';
 import type {SimplifyDeep} from './simplify-deep.d.ts';
 import type {UnionToTuple} from './union-to-tuple.d.ts';
 import type {RequiredDeep} from './required-deep.d.ts';
 import type {UnknownArray} from './unknown-array.d.ts';
+import type {StringToNumber} from './string-to-number.d.ts';
 
 /**
-Create a type that makes the given keys required. You can specify deeply nested key paths. The remaining keys are kept as is.
+Create a type that makes the given keys required, with support for deeply nested key paths, while keeping the remaining keys as is.
 
 Use-case: Selectively make nested properties required in complex types like models.