ConstructorParameters<T> cannot get correct types of overloaded constructor

[meteorlxy]

TypeScript Version: 3.8.2

Search Terms: ConstructorParameters, overload

Code

interface Options {
	a: string;
	b: string;
}

class Foo {
	constructor(a: string, b: string);
	constructor(options: Options);
	constructor(options: Options | string, b?: string) {
		// implement
	}
}

// Expected: type Params = [Options] | [string, string]
// Actual: type Params = [Options]
type Params = ConstructorParameters<typeof Foo>;

const paramArray: Params = ['foo', 'bar']; // error
const paramObj: Params = [{ a: 'foo', b: 'bar' }]; // ok

Expected behavior:

type Params = [Options] | [string, string]

Actual behavior:

type Params = [Options]

Playground Link: playground link

Related Issues:

• Conditional types, overloads, and declaration files. #35657 - similar but closed by the author

[jcalz]

This is going to be a design limitation like #26591 and #24275.

You can build something yourself that sort of works, as shown in this SO answer, at least up to some fixed number of overloads. You'd get

type OrderedParams = OverloadedConstructorParameters<typeof Foo>; 
// [[string, string], [Options]]
type Params = OrderedParams[number]; 
// [string, string] | [Options]

const paramArray: Params = ['foo', 'bar']; // okay
const paramObj: Params = [{ a: 'foo', b: 'bar' }]; // okay

implementation details

type ConstructorOverloads<T> =
    T extends {
        new(...args: infer A1): infer R1; new(...args: infer A2): infer R2;
        new(...args: infer A3): infer R3; new(...args: infer A4): infer R4
    } ? [
        new (...args: A1) => R1, new (...args: A2) => R2,
        new (...args: A3) => R3, new (...args: A4) => R4
    ] : T extends {
        new(...args: infer A1): infer R1; new(...args: infer A2): infer R2;
        new(...args: infer A3): infer R3
    } ? [
        new (...args: A1) => R1, new (...args: A2) => R2,
        new (...args: A3) => R3
    ] : T extends {
        new(...args: infer A1): infer R1; new(...args: infer A2): infer R2
    } ? [
        new (...args: A1) => R1, new (...args: A2) => R2
    ] : T extends {
        new(...args: infer A1): infer R1
    } ? [
        new (...args: A1) => R1
    ] : any

type OverloadedConstructorParameters<T> =
    ConstructorOverloads<T> extends infer O ?
    { [K in keyof O]: ConstructorParameters<Extract<O[K], new (...args: any) => any>> } : never

type OverloadedInstanceType<T> =
    ConstructorOverloads<T> extends infer O ?
    { [K in keyof O]: InstanceType<Extract<O[K], new (...args: any) => any>> } : never

Playground link

[typescript-bot]

This issue has been marked as a 'Duplicate' and has seen no recent activity. It has been automatically closed for house-keeping purposes.

[JasonHK]

This is going to be a design limitation like #26591 and #24275.

You can build something yourself that sort of works, as shown in this SO answer, at least up to some fixed number of overloads. You'd get

type OrderedParams = OverloadedConstructorParameters<typeof Foo>; 
// [[string, string], [Options]]
type Params = OrderedParams[number]; 
// [string, string] | [Options]

const paramArray: Params = ['foo', 'bar']; // okay
const paramObj: Params = [{ a: 'foo', b: 'bar' }]; // okay

implementation details

Playground link

@jcalz That hack has a big flaw. If the overload function or constructor had one or more overload with no arguments, the infer will totally be screwed.

declare function basicFunction(): void;
declare function basicFunction(value: number): void;

type FunctionOverloads<T> =
    T extends {
        (...args: infer A1): infer R1;
        (...args: infer A2): infer R2;
        (...args: infer A3): infer R3;
    } ? [
        (...args: A1) => R1,
        (...args: A2) => R2,
        (...args: A3) => R3,
    ] : T extends {
        (...args: infer A1): infer R1;
        (...args: infer A2): infer R2;
    } ? [
        (...args: A1) => R1,
        (...args: A2) => R2,
    ] : T extends {
        (...args: infer A1): infer R1;
    } ? [
        (...args: A1) => R1,
    ] : never;

type T = FunctionOverloads<typeof basicFunction>;

TypeScript Playground

For some reason T is [(...args: unknown[]) => unknown, () => void, (value: number) => void] but not [() => void, (value: number) => void].

[CMCDragonkai]

Is there a proper solution for this?