type-fest 5.4.2 → 5.4.3

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "type-fest",
-	"version": "5.4.2",
+	"version": "5.4.3",
 	"description": "A collection of essential TypeScript types",
 	"license": "(MIT OR CC0-1.0)",
 	"repository": "sindresorhus/type-fest",
@@ -27,7 +27,7 @@
 	"scripts": {
 		"test:tsc": "node --max-old-space-size=6144 ./node_modules/.bin/tsc",
 		"test:tsd": "node --max-old-space-size=6144 ./node_modules/.bin/tsd",
-		"test:xo": "node --max-old-space-size=6144 ./node_modules/.bin/xo",
+		"test:xo": "node --max-old-space-size=6144 ./node_modules/.bin/xo --ignores=lint-processors/fixtures/**/*.d.ts",
 		"test:linter": "node --test",
 		"test": "run-p test:*"
 	},

package/source/internal/numeric.d.ts

@@ -2,7 +2,7 @@ import type {IsNever} from '../is-never.d.ts';
 import type {Finite, NegativeInfinity, PositiveInfinity} from '../numeric.d.ts';
 import type {UnknownArray} from '../unknown-array.d.ts';
 import type {StringToNumber} from './string.d.ts';
-import type {IsAnyOrNever} from './type.d.ts';
+import type {IfNotAnyOrNever, IsAnyOrNever} from './type.d.ts';
 
 /**
 Returns the absolute value of a given value.
@@ -44,10 +44,11 @@ type E = IsNumberLike<'a'>;
 //=> false
 */
 export type IsNumberLike<N> =
-	IsAnyOrNever<N> extends true ? N
-		: N extends number | `${number}`
+	IfNotAnyOrNever<N,
+		N extends number | `${number}`
 			? true
-			: false;
+			: false,
+		boolean, false>;
 
 /**
 Returns the minimum number in the given union of numbers.

package/source/merge.d.ts

@@ -1,6 +1,8 @@
 import type {OmitIndexSignature} from './omit-index-signature.d.ts';
 import type {PickIndexSignature} from './pick-index-signature.d.ts';
 import type {Simplify} from './simplify.d.ts';
+import type {If} from './if.d.ts';
+import type {IsEqual} from './is-equal.d.ts';
 
 // Merges two objects without worrying about index signatures.
 type SimpleMerge<Destination, Source> = Simplify<{
@@ -47,11 +49,14 @@ Note: If you want a merge type that more accurately reflects the runtime behavio
 export type Merge<Destination, Source> =
 	Destination extends unknown // For distributing `Destination`
 		? Source extends unknown // For distributing `Source`
-			? Simplify<
-				SimpleMerge<PickIndexSignature<Destination>, PickIndexSignature<Source>>
-				& SimpleMerge<OmitIndexSignature<Destination>, OmitIndexSignature<Source>>
-			>
+			? If<IsEqual<Destination, Source>, Destination, _Merge<Destination, Source>>
 			: never // Should never happen
 		: never; // Should never happen
 
+export type _Merge<Destination, Source> =
+	Simplify<
+		SimpleMerge<PickIndexSignature<Destination>, PickIndexSignature<Source>>
+		& SimpleMerge<OmitIndexSignature<Destination>, OmitIndexSignature<Source>>
+	>;
+
 export {};

package/source/paths.d.ts

@@ -1,9 +1,10 @@
 import type {StaticPartOfArray, VariablePartOfArray, NonRecursiveType, ToString, IsNumberLike, ApplyDefaultOptions} from './internal/index.d.ts';
 import type {IsAny} from './is-any.d.ts';
 import type {UnknownArray} from './unknown-array.d.ts';
-import type {Subtract} from './subtract.d.ts';
 import type {GreaterThan} from './greater-than.d.ts';
 import type {IsNever} from './is-never.d.ts';
+import type {Sum} from './sum.d.ts';
+import type {And} from './and.d.ts';
 
 /**
 Paths options.
@@ -190,7 +191,7 @@ open('listB.1'); // TypeError. Because listB only has one element.
 */
 export type Paths<T, Options extends PathsOptions = {}> = _Paths<T, ApplyDefaultOptions<PathsOptions, DefaultPathsOptions, Options>>;
 
-type _Paths<T, Options extends Required<PathsOptions>> =
+type _Paths<T, Options extends Required<PathsOptions>, CurrentDepth extends number = 0> =
 	T extends NonRecursiveType | ReadonlyMap<unknown, unknown> | ReadonlySet<unknown>
 		? never
 		: IsAny<T> extends true
@@ -198,13 +199,13 @@ type _Paths<T, Options extends Required<PathsOptions>> =
 			: T extends UnknownArray
 				? number extends T['length']
 					// We need to handle the fixed and non-fixed index part of the array separately.
-					? InternalPaths<StaticPartOfArray<T>, Options> | InternalPaths<Array<VariablePartOfArray<T>[number]>, Options>
-					: InternalPaths<T, Options>
+					? InternalPaths<StaticPartOfArray<T>, Options, CurrentDepth> | InternalPaths<Array<VariablePartOfArray<T>[number]>, Options, CurrentDepth>
+					: InternalPaths<T, Options, CurrentDepth>
 				: T extends object
-					? InternalPaths<T, Options>
+					? InternalPaths<T, Options, CurrentDepth>
 					: never;
 
-type InternalPaths<T, Options extends Required<PathsOptions>> =
+type InternalPaths<T, Options extends Required<PathsOptions>, CurrentDepth extends number> =
 	Options['maxRecursionDepth'] extends infer MaxDepth extends number
 		? Required<T> extends infer T
 			? T extends readonly []
@@ -215,19 +216,17 @@ type InternalPaths<T, Options extends Required<PathsOptions>> =
 						[Key in keyof T]:
 						Key extends string | number // Limit `Key` to string or number.
 							? (
-								Options['bracketNotation'] extends true
-									? IsNumberLike<Key> extends true
-										? `[${Key}]`
-										: (Key | ToString<Key>)
-									: Options['bracketNotation'] extends false
+								And<Options['bracketNotation'], IsNumberLike<Key>> extends true
+									? `[${Key}]`
 									// If `Key` is a number, return `Key | `${Key}``, because both `array[0]` and `array['0']` work.
-										? (Key | ToString<Key>)
-										: never
+									: CurrentDepth extends 0
+										? Key | ToString<Key>
+										: `.${(Key | ToString<Key>)}`
 							) extends infer TranformedKey extends string | number ?
 							// 1. If style is 'a[0].b' and 'Key' is a numberlike value like 3 or '3', transform 'Key' to `[${Key}]`, else to `${Key}` | Key
 							// 2. If style is 'a.0.b', transform 'Key' to `${Key}` | Key
 							| ((Options['leavesOnly'] extends true
-								? MaxDepth extends 0
+								? MaxDepth extends CurrentDepth
 									? TranformedKey
 									: T[Key] extends infer Value
 										? (Value extends readonly [] | NonRecursiveType | ReadonlyMap<unknown, unknown> | ReadonlySet<unknown>
@@ -238,36 +237,16 @@ type InternalPaths<T, Options extends Required<PathsOptions>> =
 										: never
 								: TranformedKey
 							) extends infer _TransformedKey
-								// If `depth` is provided, the condition becomes truthy only when it reaches `0`.
+								// If `depth` is provided, the condition becomes truthy only when it reaches `CurrentDepth`.
 								// Otherwise, since `depth` defaults to `number`, the condition is always truthy, returning paths at all depths.
-								? 0 extends Options['depth']
+								? CurrentDepth extends Options['depth']
 									? _TransformedKey
 									: never
 								: never)
 							| (
 								// Recursively generate paths for the current key
-								GreaterThan<MaxDepth, 0> extends true // Limit the depth to prevent infinite recursion
-									? _Paths<T[Key],
-										{
-											bracketNotation: Options['bracketNotation'];
-											maxRecursionDepth: Subtract<MaxDepth, 1>;
-											leavesOnly: Options['leavesOnly'];
-											depth: Subtract<Options['depth'], 1>;
-										}> extends infer SubPath
-										? SubPath extends string | number
-											? (
-												Options['bracketNotation'] extends true
-													? SubPath extends `[${any}]` | `[${any}]${string}`
-														? `${TranformedKey}${SubPath}` // If next node is number key like `[3]`, no need to add `.` before it.
-														: `${TranformedKey}.${SubPath}`
-													: never
-											) | (
-												Options['bracketNotation'] extends false
-													? `${TranformedKey}.${SubPath}`
-													: never
-											)
-											: never
-										: never
+								GreaterThan<MaxDepth, CurrentDepth> extends true // Limit the depth to prevent infinite recursion
+									? `${TranformedKey}${_Paths<T[Key], Options, Sum<CurrentDepth, 1>> & (string | number)}`
 									: never
 							)
 								: never