ConstructorOf<T> wrapper to declare type of constructor of type parameter

so if I have

class MyClass {
}

Then the type of MyClass.prototype is MyClass And the type of MyClass is typeof MyClass

If I want these two functions

function takesPrototype(p: MyClass) { /* ... */ }
function takesClass(p: typeof MyClass) { /* ... */ }

I can call them as

takesPrototype(MyClass.prototype)
takesClass(MyClass)

But what if MyClass was defined as a type parameter. For example if I want to have a function that of this type -

const mod = getModule(ModuleClass)
// mod should be of type ModuleClass

I would like to define this as such

function getModule<M extends Module>(moduleClass: typeof M): M {
 // something like a getInstance() pattern
}

The problem with this is typeof M will complain that I am trying to use M as a value while it is a type.

So I suggest a type wrapper of this type

type ConstructorOf<C> = { new( ...args: any[] ): C }

Now I can define my function as such

function getModule<M extends Module>(moduleClass: ConstructorOf<M>): M {
 // something like a getInstance() pattern
}

[alecgibson]

This would definitely be a nice global generic to have access to!

My one comment is that it should probably be called Constructor<T>, since <T> is sort of read as “of ‘T’” already.

For example:

• Array<number>: “array of numbers”
• Map<string, boolean>: “map of string to boolean”
• Partial<MyInterface>: “partial of my interface”

[championswimmer]

Is this a suggestion to add that type to the global scope?

Yes it is! Would be useful lot of places 😃