type-fest 5.4.2 → 5.4.4

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "type-fest",
-	"version": "5.4.2",
+	"version": "5.4.4",
 	"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/is-union.d.ts

@@ -1,4 +1,5 @@
 import type {IsNever} from './is-never.d.ts';
+import type {IsEqual} from './is-equal.d.ts';
 
 /**
 Returns a boolean for whether the given type is a union.
@@ -24,7 +25,7 @@ type InternalIsUnion<T, U = T> =
 	IsNever<T> extends true
 		? false
 		: T extends any
-			? [U] extends [T]
+			? IsEqual<U, T> extends true
 				? false
 				: true
 			: never

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

@@ -1,5 +1,5 @@
-import type {LiteralUnion} from './literal-union.d.ts';
 import type {JsonObject, JsonValue} from './json-value.d.ts';
+import type {LiteralUnion} from './literal-union.d.ts';
 
 export namespace PackageJson {
 	/**
@@ -526,7 +526,7 @@ export namespace PackageJson {
 		Engines that this package runs on.
 		*/
 		engines?: {
-			[EngineName in 'npm' | 'node' | string]?: string;
+			[EngineName in LiteralUnion<'npm' | 'node', string>]?: string;
 		};
 
 		/**

package/source/paths.d.ts

@@ -1,9 +1,10 @@
-import type {StaticPartOfArray, VariablePartOfArray, NonRecursiveType, ToString, IsNumberLike, ApplyDefaultOptions} from './internal/index.d.ts';
+import type {NonRecursiveType, ToString, IsNumberLike, ApplyDefaultOptions, MapsSetsOrArrays} 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,90 +191,51 @@ 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>> =
-	T extends NonRecursiveType | ReadonlyMap<unknown, unknown> | ReadonlySet<unknown>
+type _Paths<T, Options extends Required<PathsOptions>, CurrentDepth extends number = 0> =
+	T extends NonRecursiveType | Exclude<MapsSetsOrArrays, UnknownArray>
 		? never
 		: IsAny<T> extends true
 			? never
-			: 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>
-				: T extends object
-					? InternalPaths<T, Options>
-					: never;
-
-type InternalPaths<T, Options extends Required<PathsOptions>> =
-	Options['maxRecursionDepth'] extends infer MaxDepth extends number
-		? Required<T> extends infer T
-			? T extends readonly []
-				? never
-				: IsNever<keyof T> extends true // Check for empty object
-					? never
-					: {
-						[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
-									// If `Key` is a number, return `Key | `${Key}``, because both `array[0]` and `array['0']` work.
-										? (Key | ToString<Key>)
-										: never
-							) 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
-									? TranformedKey
-									: T[Key] extends infer Value
-										? (Value extends readonly [] | NonRecursiveType | ReadonlyMap<unknown, unknown> | ReadonlySet<unknown>
-											? TranformedKey
-											: IsNever<keyof Value> extends true // Check for empty object
-												? TranformedKey
-												: never)
-										: never
-								: TranformedKey
-							) extends infer _TransformedKey
-								// If `depth` is provided, the condition becomes truthy only when it reaches `0`.
-								// Otherwise, since `depth` defaults to `number`, the condition is always truthy, returning paths at all depths.
-								? 0 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
-									: never
-							)
-								: never
-							: never
-					}[keyof T & (T extends UnknownArray ? number : unknown)]
+			: T extends object
+				? InternalPaths<Required<T>, Options, CurrentDepth>
+				: never;
+
+type InternalPaths<T, Options extends Required<PathsOptions>, CurrentDepth extends number> =
+	{[Key in keyof T]: Key extends string | number // Limit `Key` to `string | number`
+		? (
+			And<Options['bracketNotation'], IsNumberLike<Key>> extends true
+				? `[${Key}]`
+				: CurrentDepth extends 0
+					// Return both `Key` and `ToString<Key>` because for number keys, like `1`, both `1` and `'1'` are valid keys.
+					? Key | ToString<Key>
+					: `.${(Key | ToString<Key>)}`
+		) extends infer TransformedKey extends string | number
+			? ((Options['leavesOnly'] extends true
+				? Options['maxRecursionDepth'] extends CurrentDepth
+					? TransformedKey
+					: IsNever<T[Key]> extends true
+						? TransformedKey
+						: T[Key] extends infer Value // For distributing `T[Key]`
+							? (Value extends readonly [] | NonRecursiveType | Exclude<MapsSetsOrArrays, UnknownArray>
+								? TransformedKey
+								: IsNever<keyof Value> extends true // Check for empty object & `unknown`, because `keyof unknown` is `never`.
+									? TransformedKey
+									: never)
+							: never // Should never happen
+				: TransformedKey
+			) extends infer _TransformedKey
+				// If `depth` is provided, the condition becomes truthy only when it matches `CurrentDepth`.
+				// Otherwise, since `depth` defaults to `number`, the condition is always truthy, returning paths at all depths.
+				? CurrentDepth extends Options['depth']
+					? _TransformedKey
+					: never
+				: never)
+			// Recursively generate paths for the current key
+			| (GreaterThan<Options['maxRecursionDepth'], CurrentDepth> extends true // Limit the depth to prevent infinite recursion
+				? `${TransformedKey}${_Paths<T[Key], Options, Sum<CurrentDepth, 1>> & (string | number)}`
+				: never)
 			: never
-		: never;
+		: never
+	}[keyof T & (T extends UnknownArray ? number : unknown)];
 
 export {};