type-fest 5.3.1 → 5.4.1

package/source/merge-deep.d.ts

@@ -33,7 +33,7 @@ type MergeDeepRecordProperty<
 	Source,
 	Options extends MergeDeepInternalOptions,
 > = undefined extends Source
-	? MergeDeepOrReturn<Source, Exclude<Destination, undefined>, Exclude<Source, undefined>, Options> | undefined
+	? MergeDeepOrReturn<Source, Exclude<Destination, undefined>, Exclude<Source, undefined>, Options> | (undefined extends Destination ? undefined : never)
 	: MergeDeepOrReturn<Source, Destination, Source, Options>;
 
 /**
@@ -58,7 +58,7 @@ type DoMergeDeepRecord<
 	}
 // Case in rule 3: Both the source and the destination contain the key.
 	& {
-		[Key in keyof Source as Key extends keyof Destination ? Key : never]: MergeDeepRecordProperty<Destination[Key], Source[Key], Options>;
+		[Key in keyof Source as Key extends keyof Destination ? Key : never]: MergeDeepRecordProperty<Required<Destination>[Key], Required<Source>[Key], Options>;
 	};
 
 /**
@@ -446,25 +446,25 @@ type Foo = {foo: 'foo'; fooBar: string[]};
 type Bar = {bar: 'bar'; fooBar: number[]};
 
 type FooBar = MergeDeep<Foo, Bar>;
-// { foo: "foo"; bar: "bar"; fooBar: number[]}
+//=> {foo: 'foo'; bar: 'bar'; fooBar: number[]}
 
 type FooBarSpread = MergeDeep<Foo, Bar, {arrayMergeMode: 'spread'}>;
-// { foo: "foo"; bar: "bar"; fooBar: (string | number)[]}
+//=> {foo: 'foo'; bar: 'bar'; fooBar: (string | number)[]}
 
 type FooBarArray = MergeDeep<Foo[], Bar[]>;
-// (Foo | Bar)[]
+//=> (Foo | Bar)[]
 
 type FooBarArrayDeep = MergeDeep<Foo[], Bar[], {recurseIntoArrays: true}>;
-// FooBar[]
+//=> {foo: 'foo'; bar: 'bar'; fooBar: number[]}[]
 
 type FooBarArraySpreadDeep = MergeDeep<Foo[], Bar[], {recurseIntoArrays: true; arrayMergeMode: 'spread'}>;
-// FooBarSpread[]
+//=> {foo: 'foo'; bar: 'bar'; fooBar: (string | number)[]}[]
 
 type FooBarTupleDeep = MergeDeep<[Foo, true, 42], [Bar, 'life'], {recurseIntoArrays: true}>;
-// [FooBar, 'life', 42]
+//=> [{foo: 'foo'; bar: 'bar'; fooBar: number[]}, 'life', 42]
 
 type FooBarTupleWithArrayDeep = MergeDeep<[Foo[], true], [Bar[], 'life', 42], {recurseIntoArrays: true}>;
-// [FooBar[], 'life', 42]
+//=> [{foo: 'foo'; bar: 'bar'; fooBar: number[]}[], 'life', 42]
 ```
 
 @example

package/source/merge-exclusive.d.ts

@@ -25,14 +25,14 @@ type ExclusiveOptions = MergeExclusive<ExclusiveVariation1, ExclusiveVariation2>
 let exclusiveOptions: ExclusiveOptions;
 
 exclusiveOptions = {exclusive1: true};
-//=> Works
+// Works
 
 exclusiveOptions = {exclusive2: 'hi'};
-//=> Works
+// Works
 
 // @ts-expect-error
 exclusiveOptions = {exclusive1: true, exclusive2: 'hi'};
-//=> Error
+// Error
 ```
 
 @category Object

package/source/merge.d.ts

@@ -29,7 +29,7 @@ type Bar = {
 };
 
 export type FooBar = Merge<Foo, Bar>;
-// => {
+//=> {
 // 	[x: string]: unknown;
 // 	[x: number]: number;
 // 	[x: symbol]: unknown;
@@ -39,6 +39,9 @@ export type FooBar = Merge<Foo, Bar>;
 // }
 ```
 
+Note: If you want a merge type that more accurately reflects the runtime behavior of object spread or `Object.assign`, refer to the {@link ObjectMerge} type.
+
+@see {@link ObjectMerge}
 @category Object
 */
 export type Merge<Destination, Source> =

package/source/non-empty-string.d.ts

@@ -13,16 +13,16 @@ import type {NonEmptyString} from 'type-fest';
 declare function foo<T extends string>(string: NonEmptyString<T>): void;
 
 foo('a');
-//=> OK
+// OK
 
 // @ts-expect-error
 foo('');
-//=> Error: Argument of type '""' is not assignable to parameter of type 'never'.
+// Error: Argument of type '""' is not assignable to parameter of type 'never'.
 
 declare const someString: string;
 // @ts-expect-error
 foo(someString);
-//=> Error: Argument of type 'string' is not assignable to parameter of type 'never'.
+// Error: Argument of type 'string' is not assignable to parameter of type 'never'.
 ```
 
 @category String

package/source/non-empty-tuple.d.ts

@@ -8,11 +8,11 @@ import type {NonEmptyTuple} from 'type-fest';
 const sum = (...numbers: NonEmptyTuple<number>) => numbers.reduce((total, value) => total + value, 0);
 
 sum(1, 2, 3);
-//=> 6
+// Ok
 
 // @ts-expect-error
 sum();
-//=> Error: Expected at least 1 arguments, but got 0.
+// Error: Expected at least 1 arguments, but got 0.
 ```
 
 @see {@link RequireAtLeastOne} for objects

package/source/numeric.d.ts

@@ -74,13 +74,13 @@ type Float = Integer<1.5>;
 // Supports non-decimal numbers
 
 type OctalInteger = Integer<0o10>;
-//=> 0o10
+//=> 8
 
 type BinaryInteger = Integer<0b10>;
-//=> 0b10
+//=> 2
 
 type HexadecimalInteger = Integer<0x10>;
-//=> 0x10
+//=> 16
 ```
 
 @example

package/source/object-merge.d.ts

@@ -0,0 +1,194 @@
+import type {If} from './if.d.ts';
+import type {NormalizedKeys} from './internal/object.d.ts';
+import type {IfNotAnyOrNever, IsExactOptionalPropertyTypesEnabled, MapsSetsOrArrays} from './internal/type.d.ts';
+import type {IsNever} from './is-never.d.ts';
+import type {IsOptionalKeyOf} from './is-optional-key-of.d.ts';
+import type {OmitIndexSignature} from './omit-index-signature.d.ts';
+import type {PickIndexSignature} from './pick-index-signature.d.ts';
+import type {RequiredKeysOf} from './required-keys-of.d.ts';
+import type {Simplify} from './simplify.d.ts';
+
+/**
+Merge two object types into a new object type, where keys from the second override keys from the first.
+
+@example
+```ts
+import type {ObjectMerge} from 'type-fest';
+
+type PartialOverride = ObjectMerge<{foo: string; bar: string}, {foo: number; baz: number}>;
+//=> {foo: number; baz: number; bar: string}
+
+type CompleteOverride = ObjectMerge<{foo: string; bar: number}, {foo: number; bar: string; baz: boolean}>;
+//=> {foo: number; bar: string; baz: boolean}
+
+type NoOverride = ObjectMerge<{foo: string; bar: number}, {baz: boolean; qux: bigint}>;
+//=> {baz: boolean; qux: bigint; foo: string; bar: number}
+```
+
+Use-cases:
+
+Can be used to accurately type object spread and `Object.assign`. The built-in inference for these operations can sometimes be unsound, especially when index signatures are involved.
+
+In the following example, both object spread and `Object.assign` produce a type that allows unsafe usage, whereas `ObjectMerge` produces a type that prevents this unsafe access.
+
+@example
+```ts
+import type {ObjectMerge} from 'type-fest';
+
+const left: {a: string} = {a: '1'};
+const right: {[x: string]: number} = {a: 1};
+
+const inferred = {...left, ...right};
+//=> {a: string}
+
+inferred.a.toUpperCase(); // No compile time error, but fails at runtime.
+
+const objectAssign = Object.assign(left, right);
+//=> {a: string} & {[x: string]: number}
+
+objectAssign.a.toUpperCase(); // No compile time error, but fails at runtime.
+
+declare const objectMerge: ObjectMerge<typeof left, typeof right>;
+//=> {[x: string]: string | number; a: string | number}
+
+// @ts-expect-error
+objectMerge.a.toUpperCase(); // Correctly errors at compile time.
+```
+
+Can be used to merge generic type arguments.
+
+In the following example, object spread without `ObjectMerge` produces an intersection type that is not particularly usable, whereas `ObjectMerge` produces a correctly merged and usable result.
+
+@example
+```ts
+import type {ObjectMerge} from 'type-fest';
+
+function withoutObjectMerge<T extends object, U extends object>(left: T, right: U) {
+	return {...left, ...right};
+}
+
+const result1 = withoutObjectMerge({a: 1}, {a: 'one'});
+//=> {a: number} & {a: string}
+
+const {a} = result1;
+//=> never
+
+function withObjectMerge<T extends object, U extends object>(left: T, right: U) {
+	return {...left, ...right} as unknown as ObjectMerge<T, U>;
+}
+
+const result2 = withObjectMerge({b: 1}, {b: 'one'});
+//=> {b: string}
+
+const {b} = result2;
+//=> string
+```
+
+Note: If you want a simple merge where properties from the second object always override properties from the first object without considering runtime implications, refer to the {@link Merge} type.
+
+@see {@link Merge}
+@category Object
+*/
+export type ObjectMerge<First extends object, Second extends object> =
+	IfNotAnyOrNever<First, IfNotAnyOrNever<Second, First extends unknown // For distributing `First`
+		? Second extends unknown // For distributing `Second`
+			? First extends MapsSetsOrArrays
+				? unknown
+				: Second extends MapsSetsOrArrays
+					? unknown
+					: _ObjectMerge<
+						First,
+						Second,
+						NormalizedLiteralKeys<First>,
+						NormalizedLiteralKeys<Second>,
+						IsExactOptionalPropertyTypesEnabled extends true ? Required<First> : First,
+						IsExactOptionalPropertyTypesEnabled extends true ? Required<Second> : Second
+					>
+			: never // Should never happen
+		: never>, First & Second>; // Should never happen
+
+type _ObjectMerge<
+	First extends object,
+	Second extends object,
+	NormalizedFirstLiteralKeys extends PropertyKey,
+	NormalizedSecondLiteralKeys extends PropertyKey,
+	NormalizedFirst extends object,
+	NormalizedSecond extends object,
+> = Simplify<{
+	// Map over literal keys of `Second`, except those that are optional and also present in `First`.
+	-readonly [P in keyof Second as P extends NormalizedSecondLiteralKeys
+		? P extends NormalizedFirstLiteralKeys
+			? If<IsOptionalKeyOf<Second, P>, never, P>
+			: P
+		: never]:
+			| Second[P]
+			| (P extends NormalizedKeys<keyof PickIndexSignature<First>>
+				? If<IsOptionalKeyOf<Second, P>, First[NormalizedKeys<P> & keyof First], never>
+				: never)
+} & {
+	// Map over literal keys of `First`, except those that are not present in `Second`.
+	-readonly [P in keyof First as P extends NormalizedFirstLiteralKeys
+		? P extends NormalizedSecondLiteralKeys
+			? never
+			: P
+		: never]:
+			| First[P]
+				// If there's a matching index signature in `Second`, then add the type for it as well,
+				// for example, in `ObjectMerge<{a: string}, {[x: string]: number}>`, `a` is of type `string | number`.
+			| (P extends NormalizedKeys<keyof Second>
+				? Second[NormalizedKeys<P> & keyof Second]
+				: never);
+} & {
+	// Map over non-literal keys of `Second`.
+	-readonly [P in keyof Second as P extends NormalizedSecondLiteralKeys ? never : P]:
+		| Second[P]
+			// If there's a matching key in `First`, then add the type for it as well,
+			// for example, in `ObjectMerge<{a: number}, {[x: string]: string}>`,
+			// the resulting type is `{[x: string]: number | string; a: number | string}`.
+			// But, exclude keys from `First` that would surely get overwritten,
+			// for example, in `ObjectMerge<{a: number}, {[x: string]: string; a: string}>`,
+			// `a` from `First` would get overwritten by `a` from `Second`, so don't add type for it.
+		| (NormalizedKeys<P> & Exclude<keyof First, NormalizedKeys<RequiredKeysOf<OmitIndexSignature<Second>>>> extends infer NonOverwrittenKeysOfFirst
+			? If<IsNever<NonOverwrittenKeysOfFirst>, // This check is required because indexing with `never` doesn't always yield `never`, for example, `{[x: string]: number}[never]` results in `number`.
+				never,
+				NormalizedFirst[NonOverwrittenKeysOfFirst & keyof NormalizedFirst]>
+			: never); // Should never happen
+} & {
+	// Map over non-literal keys of `First`.
+	-readonly [P in keyof First as P extends NormalizedFirstLiteralKeys ? never : P]:
+		| First[P]
+		| If<IsNever<NormalizedKeys<P> & keyof Second>, // This check is required because indexing with `never` doesn't always yield `never`, for example, `{[x: string]: number}[never]` results in `number`.
+			never,
+			NormalizedSecond[NormalizedKeys<P> & keyof NormalizedSecond]>;
+} & {
+	// Handle optional keys of `Second` that are also present in `First`.
+	// Map over `First` instead of `Second` because the modifier is in accordance with `First`.
+	-readonly [P in keyof First as P extends NormalizedFirstLiteralKeys
+		? P extends NormalizedSecondLiteralKeys
+			? If<IsOptionalKeyOf<Second, NormalizedKeys<P> & keyof Second>, P, never>
+			: never
+		: never]:
+			| First[P]
+			| NormalizedSecond[NormalizedKeys<P> & keyof NormalizedSecond]
+}>;
+
+/**
+Get literal keys of a type, including both string and number representations wherever applicable.
+
+@example
+```ts
+type A = NormalizedLiteralKeys<{0: string; '1'?: number; foo: boolean}>;
+//=> 0 | '0' | 1 | '1' | 'foo'
+
+type B = NormalizedLiteralKeys<{[x: string]: string | number; 0: string; '1'?: number}>;
+//=> 0 | '0' | 1 | '1'
+
+type C = NormalizedLiteralKeys<{[x: string]: unknown}>;
+//=> never
+```
+*/
+type NormalizedLiteralKeys<Type> = Type extends unknown // For distributing `Type`
+	? NormalizedKeys<keyof OmitIndexSignature<Type>>
+	: never; // Should never happen
+
+export {};

package/source/omit-deep.d.ts

@@ -5,6 +5,7 @@ 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';
 
@@ -33,11 +34,7 @@ type Info = {
 };
 
 type UsefulInfo = OmitDeep<Info, 'userInfo.uselessInfo'>;
-//=> {
-// 	userInfo: {
-// 		name: string;
-// 	};
-// };
+//=> {userInfo: {name: string}}
 
 // Supports removing multiple paths
 type Info1 = {
@@ -51,15 +48,11 @@ type Info1 = {
 };
 
 type UsefulInfo1 = OmitDeep<Info1, 'userInfo.uselessInfo' | 'userInfo.uselessField'>;
-//=> {
-// 	userInfo: {
-// 		name: string;
-// 	};
-// };
+//=> {userInfo: {name: string}}
 
 // Supports array
 type A = OmitDeep<[1, 'foo', 2], '1'>;
-//=> [1, unknown, 2];
+//=> [1, unknown, 2]
 
 // Supports recursing into array
 
@@ -76,16 +69,7 @@ type Info2 = {
 };
 
 type AddressInfo = OmitDeep<Info2, 'address.1.foo'>;
-//=> {
-// 	address: [
-// 		{
-// 			street: string;
-// 		},
-// 		{
-// 			street2: string;
-// 		};
-// 	];
-// };
+//=> {address: [{street: string}, {street2: string}]}
 ```
 
 @category Object
@@ -135,7 +119,7 @@ P extends `${infer RecordKeyInPath}.${infer SubPath}`
 		? IsNever<Key> extends true
 			? ObjectT
 			: Key extends PropertyKey
-				? Omit<ObjectT, Key>
+				? Simplify<Omit<ObjectT, Key>> // `Simplify` to prevent `Omit` from appearing in the resulting type
 				: ObjectT
 		: ObjectT;
 

package/source/omit-index-signature.d.ts

@@ -17,7 +17,7 @@ const indexed: Record<string, unknown> = {}; // Allowed
 
 // @ts-expect-error
 const keyed: Record<'foo', unknown> = {}; // Error
-// => TS2739: Type '{}' is missing the following properties from type 'Record<"foo" | "bar", unknown>': foo, bar
+// TS2739: Type '{}' is missing the following properties from type 'Record<"foo" | "bar", unknown>': foo, bar
 ```
 
 Instead of causing a type error like the above, you can also use a [conditional type](https://www.typescriptlang.org/docs/handbook/2/conditional-types.html) to test whether a type is assignable to another:
@@ -26,12 +26,16 @@ Instead of causing a type error like the above, you can also use a [conditional
 type Indexed = {} extends Record<string, unknown>
 	? '✅ `{}` is assignable to `Record<string, unknown>`'
 	: '❌ `{}` is NOT assignable to `Record<string, unknown>`';
-// => '✅ `{}` is assignable to `Record<string, unknown>`'
+
+type IndexedResult = Indexed;
+//=> '✅ `{}` is assignable to `Record<string, unknown>`'
 
 type Keyed = {} extends Record<'foo' | 'bar', unknown>
 	? '✅ `{}` is assignable to `Record<\'foo\' | \'bar\', unknown>`'
 	: '❌ `{}` is NOT assignable to `Record<\'foo\' | \'bar\', unknown>`';
-// => "❌ `{}` is NOT assignable to `Record<'foo' | 'bar', unknown>`"
+
+type KeyedResult = Keyed;
+//=> '❌ `{}` is NOT assignable to `Record<\'foo\' | \'bar\', unknown>`'
 ```
 
 Using a [mapped type](https://www.typescriptlang.org/docs/handbook/2/mapped-types.html#further-exploration), you can then check for each `KeyType` of `ObjectType`...
@@ -79,7 +83,7 @@ type Example = {
 };
 
 type ExampleWithoutIndexSignatures = OmitIndexSignature<Example>;
-// => { foo: 'bar'; qux?: 'baz' | undefined; }
+//=> {foo: 'bar'; qux?: 'baz'}
 ```
 
 @see {@link PickIndexSignature}

package/source/override-properties.d.ts

@@ -15,7 +15,7 @@ type Foo = {
 };
 
 type Bar = OverrideProperties<Foo, {b: number}>;
-//=> {a: string, b: number}
+//=> {a: string; b: number}
 
 // @ts-expect-error
 type Baz = OverrideProperties<Foo, {c: number}>;

package/source/paths.d.ts

@@ -92,7 +92,7 @@ export type PathsOptions = {
 	};
 
 	type AllPaths = Paths<ArrayExample, {leavesOnly: false}>;
-	//=> 'array' | `array.${number}` | `array.${number}.foo` | 'tuple' | 'tuple.0' | 'tuple.1' | 'tuple.1.bar'
+	//=> 'array' | 'tuple' | `array.${number}` | `array.${number}.foo` | 'tuple.0' | 'tuple.1' | 'tuple.1.bar'
 
 	type LeafPaths = Paths<ArrayExample, {leavesOnly: true}>;
 	//=> `array.${number}.foo` | 'tuple.0' | 'tuple.1.bar'

package/source/readonly-tuple.d.ts

@@ -18,11 +18,11 @@ const guestFencingTeam: FencingTeam = ['Josh', 'Michael', 'Robert'];
 
 // @ts-expect-error
 const homeFencingTeam: FencingTeam = ['George', 'John'];
-//=> Error: Type '[string, string]' is not assignable to type 'readonly [string, string, string]'.
+// Error: Type '[string, string]' is not assignable to type 'readonly [string, string, string]'.
 
 // @ts-expect-error
 guestFencingTeam.push('Sam');
-//=> Error: Property 'push' does not exist on type 'readonly [string, string, string]'.
+// Error: Property 'push' does not exist on type 'readonly [string, string, string]'.
 ```
 
 @deprecated This type will be removed in the next major version. Use the built-in `Readonly` type in combination with the {@link TupleOf} type instead, like `Readonly<TupleOf<Length, Element>>`.

package/source/required-deep.d.ts

@@ -1,5 +1,6 @@
 import type {BuiltIns, HasMultipleCallSignatures} from './internal/index.d.ts';
 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.
@@ -65,7 +66,7 @@ export type RequiredDeep<T> = T extends BuiltIns
 											? T
 											: ((...arguments_: Parameters<T>) => ReturnType<T>) & RequiredObjectDeep<T>
 									: T extends object
-										? RequiredObjectDeep<T>
+										? Simplify<RequiredObjectDeep<T>> // `Simplify` to prevent `RequiredObjectDeep` from appearing in the resulting type
 										: unknown;
 
 type RequiredObjectDeep<ObjectType extends object> = {

package/source/schema.d.ts

@@ -24,15 +24,18 @@ export type SchemaOptions = {
 
 	type ParticipantsWithMetadata = Schema<Participants, {id: number; name: string}, {recurseIntoArrays: true}>;
 	//=> {
-	// 	attendees: Array<{id: number; name: string}>;
-	// 	speakers: Array<{id: number; name: string}>;
-	// };
+	// 	attendees: {
+	// 		id: number;
+	// 		name: string;
+	// 	}[];
+	// 	speakers: {
+	// 		id: number;
+	// 		name: string;
+	// 	}[];
+	// }
 
 	type ParticipantsCount = Schema<Participants, number, {recurseIntoArrays: false}>;
-	//=> {
-	// 	attendees: number;
-	// 	speakers: number;
-	// };
+	//=> {attendees: number; speakers: number}
 	```
 
 	@default true

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

@@ -37,7 +37,7 @@ type UpdatedUser = SetNonNullableDeep<User, 'address.street' | 'contact.email' |
 // 		email?: string;
 // 		phone: string;
 // 	};
-// };
+// }
 ```
 
 @example

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

@@ -64,11 +64,11 @@ Note:
 	import type {SetParameterType} from 'type-fest';
 
 	const fn = (a: number) => a;
-	//=> fn: (a: number) => number;
+	//=> (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;
+ 	//=> (a: string) => number
 	```
 
 Use-case:
@@ -87,25 +87,25 @@ type Data = SuccessData | ErrorData;
 type HandleMessage = (data: Data, message: string, ...arguments_: any[]) => void;
 
 type HandleOk = SetParameterType<HandleMessage, {0: SuccessData; 1: 'ok'}>;
-//=> (data: SuccessData, message: 'ok', ...arguments_: any[]) => void;
+//=> (data: SuccessData, message: 'ok', ...arguments_: any[]) => void
 
 // Another way to define the parameters to replace.
 type HandleError = SetParameterType<HandleMessage, [data: ErrorData, message: 'error']>;
-//=> (data: ErrorData, message: 'error', ...arguments_: any[]) => void;
+//=> (data: ErrorData, message: 'error', ...arguments_: any[]) => void
 
 // Change single parameter type.
 type HandleWarn = SetParameterType<HandleMessage, {1: 'warn'}>;
-//=> (data: Data, message: 'warn', ...arguments_: any[]) => void;
+//=> (data: Data, message: 'warn', ...arguments_: any[]) => void
 
 // Change rest parameter type.
 
 // Way 1: Input full parameter type.
 type HandleLog = SetParameterType<HandleMessage, [data: Data, message: 'log', ...arguments_: string[]]>;
-//=> (data: Data, message: 'log', ...arguments_: string[]) => void;
+//=> (data: Data, message: 'log', ...arguments_: string[]) => void
 
 // Way 2: Input rest parameter type by Object index.
 type HandleLog2 = SetParameterType<HandleMessage, {2: string}>;
-//=> (data: Data, message: string, ...arguments_: string[]) => void;
+//=> (data: Data, message: string, ...arguments_: string[]) => void
 ```
 
 @category Function

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

@@ -25,13 +25,7 @@ type Foo = {
 };
 
 type SomeRequiredDeep = SetRequiredDeep<Foo, 'a' | `c.${number}.d`>;
-//=> {
-// 	a: number; // Is now required
-// 	b?: string;
-// 	c?: {
-// 		d: number; // Is now required
-// 	}[];
-// }
+//=> {b?: string; c?: {d: number}[]; a: number}
 
 // Set specific indices in an array to be required.
 type ArrayExample = SetRequiredDeep<{a: [number?, number?, number?]}, 'a.0' | 'a.1'>;

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

@@ -12,7 +12,7 @@ import type {SetReturnType} from 'type-fest';
 type MyFunctionThatCanThrow = (foo: string, bar: number) => boolean;
 
 type MyWrappedFunction = SetReturnType<MyFunctionThatCanThrow, ReturnType<MyFunctionThatCanThrow> | undefined>;
-//=> (foo: string, bar: number) => boolean | undefined;
+//=> (foo: string, bar: number) => boolean | undefined
 ```
 
 @category Function

package/source/split-on-rest-element.d.ts

@@ -50,10 +50,10 @@ type T3 = SplitOnRestElement<[number, string?]>;
 //=> [[number, string?], [], []]
 
 type T4 = SplitOnRestElement<[number, string?], {preserveOptionalModifier: false}>;
-//=> [[number, string], [], []] or [[number, string | undefined], [], []]
+//=> [[number, string], [], []]
 
 type T5 = SplitOnRestElement<readonly [string?, ...number[]], {preserveOptionalModifier: false}>;
-//=> readonly [[string], number[], []] or readonly [[string | undefined], number[], []]
+//=> readonly [[string], number[], []]
 ```
 
 @see {@link ExtractRestElement}

package/source/subtract.d.ts

@@ -26,7 +26,7 @@ type D = Subtract<18, 96>;
 //=> -78
 
 type E = Subtract<PositiveInfinity, 9999>;
-//=> PositiveInfinity
+//=> Infinity
 
 type F = Subtract<PositiveInfinity, PositiveInfinity>;
 //=> number

package/source/sum.d.ts

@@ -23,7 +23,7 @@ type C = Sum<111, -222>;
 //=> -111
 
 type D = Sum<PositiveInfinity, -9999>;
-//=> PositiveInfinity
+//=> Infinity
 
 type E = Sum<PositiveInfinity, NegativeInfinity>;
 //=> number

package/source/tuple-of.d.ts

@@ -30,7 +30,7 @@ type ZeroToFour = Range<0, 5>;
 //=> '0' | '1' | '2' | '3' | '4'
 
 type ThreeToEight = Range<3, 9>;
-//=> '3' | '4' | '5' | '6' | '7' | '8'
+//=> '5' | '3' | '4' | '6' | '7' | '8'
 ```
 
 Note: If the specified length is the non-literal `number` type, the result will not be a tuple but a regular array.