Instance types of classes in TypeScript do not directly refer to their constructor type. Let's take a look at an example class:
class Foo {
a: number;
constructor(a: number) {
this.a = a;
}
}
let f: Foo = new Foo(123);
The variable f is of type Foo, but the type Foo should be thought of as an interface that describes the structure of instances of the class, rather than indicating it was constructed by the Foo constructor. You can even assign an object with the same shape to f without being created by Foo:
f = { a: 456 }; // <-- also valid
Even the constructor property doesn't hold enough typing information about the actual constructor of a class instance.
Hence, determining that the constructor named Foo has a constructor parameter of type number solely from the type Foo is impossible and leads to loss of information.
GetConstructor<I> will never function as expected because you cannot convert from the type
User to
typeof User.
However, constructor types are aware of the instances they create. With the constructor type typeof User, you can obtain its instance type. There is even an InstanceType<T> utility type available for this purpose.
Moreover, if all you need is the instance type and constructor parameter list, make your Collection generic in those types directly instead of focusing on the constructor type itself. For example, assuming the constructor argument types are array-like A and the instance type is similar to Person denoted as T, here's the modified Collection:
class Collection<A extends any[], T extends Person>{
personClass: new (...args: A) => T;
items: T[] = []
constructor(personClass: new (...args: A) => T) {
this.personClass = personClass
}
add(...params: A) {
const instance = new this.personClass(...params)
this.items.push(
instance
)
}
}
This code compiles without issues. You can then instantiate User within Collection as planned:
class User extends Person {
data!: {
name: string
}
constructor(name: string) {
super({ name })
}
get name() {
return this.data.name
}
}
const collection = new Collection(User)
// const collection: Collection<[name: string], User>
collection.add('123'); // acceptable
The type of collection becomes
Collection<[name: string], User>
, reflecting the fact that the
User constructor accepts a single string parameter and produces instances of type
User.
Class instance types in TypeScript do not hold a reference to their constructor type. Consider the following class:
class Foo {
a: number;
constructor(a: number) {
this.a = a;
}
}
let f: Foo = new Foo(123);
The value f is annotated to be of type Foo. But you should think of the type Foo as an interface describing the shape of class instances, and not as meaning "was constructed by the Foo constructor". Indeed, you can assign a value of the same shape to f without it being constructed by Foo at al:
f = { a: 456 }; // <-- also acceptable
If you look at microsoft/TypeScript#3841 you will see that even the constructor property of a class instance is not strongly typed enough to determine anything about the actual constructor.
So, there's no way of looking at the type Foo and determining that the constructor named Foo has a constructor parameter of type number. It's impossible to go from instance type to constructor type without losing information.
GetConstructor<I> will never work how you want. There's no way to go from the type named User to the type named typeof User.
On the other hand, constructor types definitely know about the instances they construct. So given the User constructor of type typeof User, you can get its instance type. There's even an InstanceType<T> utility type provided for you.
Furthermore, since all you care about is the instance type and the constructor parameter list, you can just make your Collection generic in the types of those directly, instead of caring about the constructor type itself. Let's say that the constructor argument types is an arraylike type A and the instance type is a Person-like type T. Then here's how Collection looks:
class Collection<A extends any[], T extends Person>{
personClass: new (...args: A) => T;
items: T[] = []
constructor(personClass: new (...args: A) => T) {
this.personClass = personClass
}
add(...params: A) {
const instance = new this.personClass(...params)
this.items.push(
instance
)
}
}
That all compiles with no problem. Then you can pass in User and see everything working as desired:
class User extends Person {
data!: {
name: string
}
constructor(name: string) {
super({ name })
}
get name() {
return this.data.name
}
}
const collection = new Collection(User)
// const collection: Collection<[name: string], User>
collection.add('123'); // okay
The type of collection is
Collection<[name: string], User>
, corresponding to the fact that the
User constructor takes a single
string parameter and produces instances of type
User.
Playground link to code