PartialDeep: Fix behavior with functions containing multiple call signatures (#1259)

Author: som-sm

source/partial-deep.d.ts

@@ -1,4 +1,4 @@
-import type {ApplyDefaultOptions, BuiltIns} from './internal/index.d.ts';
+import type {ApplyDefaultOptions, BuiltIns, HasMultipleCallSignatures} from './internal/index.d.ts';
 import type {IsNever} from './is-never.d.ts';
 
 /**
@@ -99,16 +99,20 @@ export type PartialDeep<T, Options extends PartialDeepOptions = {}> =
 
 type _PartialDeep<T, Options extends Required<PartialDeepOptions>> = T extends BuiltIns | ((new (...arguments_: any[]) => unknown))
 	? T
-	: IsNever<keyof T> extends true // For functions with no properties
-		? T
-		: T extends Map<infer KeyType, infer ValueType>
-			? PartialMapDeep<KeyType, ValueType, Options>
-			: T extends Set<infer ItemType>
-				? PartialSetDeep<ItemType, Options>
-				: T extends ReadonlyMap<infer KeyType, infer ValueType>
-					? PartialReadonlyMapDeep<KeyType, ValueType, Options>
-					: T extends ReadonlySet<infer ItemType>
-						? PartialReadonlySetDeep<ItemType, Options>
+	: T extends Map<infer KeyType, infer ValueType>
+		? PartialMapDeep<KeyType, ValueType, Options>
+		: T extends Set<infer ItemType>
+			? PartialSetDeep<ItemType, Options>
+			: T extends ReadonlyMap<infer KeyType, infer ValueType>
+				? PartialReadonlyMapDeep<KeyType, ValueType, Options>
+				: T extends ReadonlySet<infer ItemType>
+					? PartialReadonlySetDeep<ItemType, Options>
+					: T extends (...arguments_: any[]) => unknown
+						? IsNever<keyof T> extends true
+							? T // For functions with no properties
+							: HasMultipleCallSignatures<T> extends true
+								? T
+								: ((...arguments_: Parameters<T>) => ReturnType<T>) & PartialObjectDeep<T, Options>
 						: T extends object
 							? T extends ReadonlyArray<infer ItemType> // Test for arrays/tuples, per https://github.com/microsoft/TypeScript/issues/35156
 								? Options['recurseIntoArrays'] extends true
@@ -144,11 +148,8 @@ type PartialReadonlySetDeep<T, Options extends Required<PartialDeepOptions>> = {
 /**
 Same as `PartialDeep`, but accepts only `object`s as inputs. Internal helper for `PartialDeep`.
 */
-type PartialObjectDeep<ObjectType extends object, Options extends Required<PartialDeepOptions>> =
-	(ObjectType extends (...arguments_: any) => unknown
-		? (...arguments_: Parameters<ObjectType>) => ReturnType<ObjectType>
-		: {}) & ({
-			[KeyType in keyof ObjectType]?: _PartialDeep<ObjectType[KeyType], Options>
-		});
+type PartialObjectDeep<ObjectType extends object, Options extends Required<PartialDeepOptions>> = {
+	[KeyType in keyof ObjectType]?: _PartialDeep<ObjectType[KeyType], Options>
+};
 
 export {};

source/required-deep.d.ts

@@ -1,4 +1,5 @@
 import type {BuiltIns, HasMultipleCallSignatures} from './internal/index.d.ts';
+import type {IsNever} from './is-never.d.ts';
 
 /**
 Create a type from another type with all keys and nested keys set to required.
@@ -58,7 +59,7 @@ export type RequiredDeep<T> = T extends BuiltIns
 							: T extends Promise<infer ValueType>
 								? Promise<RequiredDeep<ValueType>>
 								: T extends (...arguments_: any[]) => unknown
-									? {} extends RequiredObjectDeep<T>
+									? IsNever<keyof T> extends true
 										? T
 										: HasMultipleCallSignatures<T> extends true
 											? T

test-d/partial-deep.ts

@@ -1,4 +1,4 @@
-import {expectType, expectAssignable} from 'tsd';
+import {expectType, expectAssignable, expectNotType} from 'tsd';
 import type {PartialDeep, Simplify} from '../index.d.ts';
 
 class ClassA {
@@ -128,3 +128,10 @@ expectType<{p1?: {p2?: string; p3?: [{p4?: number}?, string?]}}>({} as Simplify<
 
 expectType<{p1?: string[]}>({} as Simplify<PartialDeep<{(): void; p1: string[]}, {allowUndefinedInNonTupleArrays: false}>>);
 expectType<{p1?: string[]}>({} as Simplify<PartialDeep<{(): void; p1: string[]}, {allowUndefinedInNonTupleArrays: true}>>);
+
+// Properties within functions containing multiple call signatures are not made partial due to TS limitations, refer https://github.com/microsoft/TypeScript/issues/29732
+type FunctionWithProperties4 = {(a1: number): string; (a1: string, a2: number): number; p1: string};
+declare const functionWithProperties4: PartialDeep<FunctionWithProperties4>;
+expectType<string>(functionWithProperties4(1));
+expectType<number>(functionWithProperties4('foo', 1));
+expectNotType<{p1?: string}>({} as Simplify<typeof functionWithProperties4>);

test-d/required-deep.ts

@@ -1,4 +1,4 @@
-import {expectType} from 'tsd';
+import {expectNotType, expectType} from 'tsd';
 import type {RequiredDeep, Simplify} from '../index.d.ts';
 import type {BuiltIns} from '../source/internal/type.d.ts';
 
@@ -80,5 +80,6 @@ expectType<{p1: {p2: string; p3: [{p4: number}, string]}}>({} as Simplify<typeof
 // Properties within functions containing multiple call signatures are not made required due to TS limitations, refer https://github.com/microsoft/TypeScript/issues/29732
 type FunctionWithProperties4 = {(a1: number): string; (a1: string, a2: number): number; p1?: string};
 declare const functionWithProperties4: RequiredDeep<FunctionWithProperties4>;
-// @ts-expect-error
-expectType<{p1: string}>({} as Simplify<typeof functionWithProperties4>);
+expectType<string>(functionWithProperties4(1));
+expectType<number>(functionWithProperties4('foo', 1));
+expectNotType<{p1: string}>({} as Simplify<typeof functionWithProperties4>);