ConstructorParameters is not working for private constructors (and protected constructors)

TypeScript Version: 3.4 Search Terms: ConstructorParameters, private constructor

Code

class Foo
{ public constructor(a: number, b: boolean, c: string) { } }

class Bar
{ private constructor(a: number, b: boolean, c: string) { } }

type FooCtorArgs = ConstructorParameters<typeof Foo>;
type BarCtorArgs = ConstructorParameters<typeof Bar>;

Expected behavior: BarCtorArgs is [number, boolean, string].

Actual behavior: Error in line 8: Type 'typeof Bar' does not satisfy the constraint 'new (...args: any) => any'. Cannot assign a 'private' constructor type to a 'public' constructor type.

Playground Link: https://www.typescriptlang.org/play/#src=class Foo { public constructor(a%3A number%2C b%3A boolean%2C c%3A string) { } } class Bar { private constructor(a%3A number%2C b%3A boolean%2C c%3A string) { } } type FooCtorArgs %3D ConstructorParameters<typeof Foo>%3B type BarCtorArgs %3D ConstructorParameters<typeof Bar>%3B

---

Use Case

Convenient factory pattern to mimic asynchronous object construction.

class Component
{
    public static async create(...args: ConstructorParameters<typeof Component>)
    {
        const component = new Component(...args);
        await component.initialize();
        return component;
    }

    private constructor(a: number, b: boolean, c: string)
    { /* stuff */ }

    private async initialize()
    { /* asynchronous setup */ }
}

Ideas for Solution

Allow visibility modifiers in interfaces. Yes, if you use an interface to outline the visible properties of an object to a user this makes no sense, but why not allow interfaces to be a flexible tool to specify internal rules of implementations? I think this problem could be solved, if the ConstructorParameters type could be defined like the following:

type ConstructorParameters<T extends {private new (...args: any[]): any}> = T extends new (...args: infer P) => any ? P : never;

Which is of course no allowed at the moment.

[dhmk083]

With some hacks this works and is quite short:

// 1. Make an abstract class
abstract class Foo {
    // 2. Make a public ctor
    constructor(readonly x: number, protected y: string) {}

    public static create = createFactory(Foo)
}

function createFactory<T extends abstract new (...args: any) => any>(c: T) {
  return (...args: ConstructorParameters<T>): InstanceType<T> => {
    // @ts-ignore
    return new c(...args)
  }
}

[Slion]

But you can declare derived class as abstract too, can’t you? 😃

abstract class Foo {...}

abstract class Bar extends Foo {...}

new Bar(1, 'a') // expected error
Bar.create(1, 'a') // ok

You are correct, that works great!