如何解开打字稿通用内部类型

Question

I have a graph of generic classes, where the wrapped type is needed to specify other classes.

interface Data {
    id: number,
}

class EntityClass<T extends Data> {
    public data;

    constructor(data: T) {
        this.data = data;
    }
}

class Result<T extends Data> {
    public data

    constructor(data) {
        this.data = data;
    }
}

Right now I'm passing both the type ( EntityClass<any> and the internal type ( DataClass ), even though it always matches what would be any here.

function extract<Class extends EntityClass<any>, DataClass extends Data>(
    entity: Class
) : Result<DataClass> {}

Is there a way to "unwrap" the internal type of EntityClass, to avoid passing both? Here's what I'd like to do:

function extract<Class extends EntityClass<InternalClass>>(
    entity: Class
) : Result<InternalClass> {}

Answer 1

This a basic application of conditional types and their inference behavior

class EntityClass<T extends Data> {
    public data: T; // T assuming this should be T

    constructor(data: T) {
        this.data = data;
    }
}

type GetDataClass<T  extends EntityClass<any>> = T  extends EntityClass<infer U > ? U: never;
function extract<Class extends EntityClass<any>>(
    entity: Class
) : Result<GetDataClass<Class>> { return null as any}

Or you can also do it with a type query as well, but that means you will be tied to the data field, the conditional type will extract the generic type based on structure without you having to specify a particular field.

function extract<Class extends EntityClass<any>>(
    entity: Class
) : Result<Class['data']> { return null as any}

You can read more about type queries and conditional types here