Paths: Fix behavior with WeakMaps / WeakSets (#1348)

Author: som-sm

source/paths.d.ts

@@ -1,4 +1,4 @@
-import type {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 {GreaterThan} from './greater-than.d.ts';
@@ -192,62 +192,48 @@ 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>, CurrentDepth extends number = 0> =
-	T extends NonRecursiveType | ReadonlyMap<unknown, unknown> | ReadonlySet<unknown>
+	T extends NonRecursiveType | Exclude<MapsSetsOrArrays, UnknownArray>
 		? never
 		: IsAny<T> extends true
 			? never
 			: T extends object
-				? InternalPaths<T, Options, CurrentDepth>
+				? InternalPaths<Required<T>, Options, CurrentDepth>
 				: never;
 
 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 []
-				? 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.
-							? (
-								And<Options['bracketNotation'], IsNumberLike<Key>> extends true
-									? `[${Key}]`
-									// If `Key` is a number, return `Key | `${Key}``, because both `array[0]` and `array['0']` work.
-									: 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 CurrentDepth
-									? 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 `CurrentDepth`.
-								// Otherwise, since `depth` defaults to `number`, the condition is always truthy, returning paths at all depths.
-								? CurrentDepth extends Options['depth']
-									? _TransformedKey
-									: never
+	{[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
+					: 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)
-							| (
-								// Recursively generate paths for the current key
-								GreaterThan<MaxDepth, CurrentDepth> extends true // Limit the depth to prevent infinite recursion
-									? `${TranformedKey}${_Paths<T[Key], Options, Sum<CurrentDepth, 1>> & (string | number)}`
-									: never
-							)
-								: never
-							: never
-					}[keyof T & (T extends UnknownArray ? number : unknown)]
+						: 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 {};

test-d/paths.ts

@@ -1,5 +1,6 @@
 import {expectAssignable, expectNotAssignable, expectType} from 'tsd';
-import type {Paths} from '../index.d.ts';
+import type {Paths, UnknownArray} from '../index.d.ts';
+import type {MapsSetsOrArrays, NonRecursiveType} from '../source/internal/type.d.ts';
 
 declare const normal: Paths<{foo: string}>;
 expectType<'foo'>(normal);
@@ -76,6 +77,15 @@ expectType<never>(map2);
 declare const readonlyMap: Paths<{foo?: {bar?: ReadonlyMap<string, number>}}>;
 expectType<'foo' | 'foo.bar'>(readonlyMap);
 
+declare const readonlyMap2: Paths<ReadonlyMap<string, number>>;
+expectType<never>(readonlyMap2);
+
+declare const weakMap: Paths<{foo?: {bar?: WeakMap<{a: string}, number>}}>;
+expectType<'foo' | 'foo.bar'>(weakMap);
+
+declare const weakMap2: Paths<WeakMap<{a: string}, number>>;
+expectType<never>(weakMap2);
+
 declare const set: Paths<{foo?: {bar?: Set<string>}}>;
 expectType<'foo' | 'foo.bar'>(set);
 
@@ -85,6 +95,18 @@ expectType<never>(set2);
 declare const readonlySet: Paths<{foo?: {bar?: ReadonlySet<string>}}>;
 expectType<'foo' | 'foo.bar'>(readonlySet);
 
+declare const readonlySet2: Paths<ReadonlySet<string>>;
+expectType<never>(readonlySet2);
+
+declare const weakSet: Paths<{foo?: {bar?: WeakSet<{a: string}>}}>;
+expectType<'foo' | 'foo.bar'>(weakSet);
+
+declare const weakSet2: Paths<WeakSet<{a: string}>>;
+expectType<never>(weakSet2);
+
+declare const nonRecursives: Paths<{a: NonRecursiveType | Exclude<MapsSetsOrArrays, UnknownArray>}>;
+expectType<'a'>(nonRecursives);
+
 // Test for unknown length array
 declare const trailingSpreadTuple: Paths<[{a: string}, ...Array<{b: number}>]>;
 expectType<number | `${number}` | '0.a' | `${number}.b`>(trailingSpreadTuple);
@@ -183,6 +205,9 @@ expectType<'a' | 'a.c'>(unionLeaves1);
 declare const unionLeaves2: Paths<{a: {[x: string]: number} | {c: number}}, {leavesOnly: true}>;
 expectType<`a.${string}`>(unionLeaves2); // Collapsed union
 
+declare const unionLeaves3: Paths<{a: string | {toLowerCase: number}}, {leavesOnly: true}>;
+expectType<'a' | 'a.toLowerCase'>(unionLeaves3);
+
 declare const emptyObjectLeaves: Paths<{a: {}}, {leavesOnly: true}>;
 expectType<'a'>(emptyObjectLeaves);
 
@@ -258,6 +283,18 @@ expectType<'a[1]' | 'a[2]'>(bracketNumericLeaves);
 declare const bracketNestedArrayLeaves: Paths<{a: Array<Array<Array<{b: string}>>>}, {bracketNotation: true; leavesOnly: true}>;
 expectType<`a[${number}][${number}][${number}].b`>(bracketNestedArrayLeaves);
 
+declare const mapLeaves: Paths<{a: {b: Map<string, number>; c: ReadonlyMap<string, number>}; d: WeakMap<{a: string}, number>}, {leavesOnly: true}>;
+expectType<'a.b' | 'a.c' | 'd'>(mapLeaves);
+
+declare const setLeaves: Paths<{a: {b: Set<string>; c: ReadonlySet<string>}; d: WeakSet<{a: string}>}, {leavesOnly: true}>;
+expectType<'a.b' | 'a.c' | 'd'>(setLeaves);
+
+declare const unknownLeaves: Paths<{a: {b: unknown}}, {leavesOnly: true}>;
+expectType<'a.b'>(unknownLeaves);
+
+declare const anyLeaves: Paths<{a: {b: any}}, {leavesOnly: true}>;
+expectType<'a.b'>(anyLeaves);
+
 // -- depth option --
 declare const zeroDepth: Paths<DeepObject, {depth: 0}>;
 expectType<'a'>(zeroDepth);