Generic factory parameters in Typescript

Question

This is the sample from the official Typescript documentation for a generic factory. In this sample the constructor does not take parameters.

function create<T>(c: {new(): T; }): T {
  return new c();
}

How could I rewrite this so that in addition to a type, the factory method accepts other parameters and passes them when it invokes the constructor of the class it is instantiating? So the return statement would look something like this:

return c(p1, p2);

Something that wasn't clear to me is that this

{new(): T; }

is effectively an interface, inasmuch as it defines the terms of assessment for compatibility of a proposed class, incidentally also declaring the constructor signature. I'm going to answer my own question.

Answer 1

This is what I would do:

module Factory {
    export function createInstance<T extends Wibble, K extends IRaw1>(ctor: { new (raw: K): T }, data: K): T {
        return new ctor(data);
    }
}
var raw1 = { Foo: "foo" } as IRaw1;
var d1 = Factory.createInstance(Wibble, raw1);

var raw2 = { Foo: "foo", Bar: "bar" } as IRaw2;
var d2 = Factory.createInstance(Wobble, raw2);

If your constructors need more arguments, then just add them to the one object you're passing to the ctor, this way you won't need to add more generic constraints per argument.

Answer 2

You can't define a single factory method that can pass an arbitrary number of parameters to the constructor of an arbitrary class.

You can, however, define a factory method for any specific number of constructor parameters. Here's a rather elaborate sample in the Typescript playground. It defines classes and interfaces and derived classes and interfaces and then uses them to demonstrate the factory method working.

Line 38 of the example is probably the most interesting and impressive part of the whole show: an incompatible parameter is specified and this is statically detected by the editor! By implication line 38 has passed the same check, and this matches expectation; Wobble is a derivative of Wibble and therefore acceptable, and the parameter is declared as IRaw2 which is a derivative of the declared parameter type of IRaw1, and therefore also acceptable.

If you wanted a two-parameter constructor it would look like this:

export function createInstance<T1, T2, T3>(ctor: new(p: T1, q: T2) => T3, p:T1, q:T2): T3 {
  return new ctor(p, q);
}