Typescript 该表达式不可调用，联合体的每个成员

我已经将我的方法与我最近的当前体系 struct 保持一致，努力将复杂性尽可能降至最低.

我的目标是最接近令人满意的结果，但我遇到了这种方法的一次失败的测试.

我快要放弃了，因为已经过go 三天了！ 然而，如果您的专业知识能够找到一个确保所有测试成功的解决方案，那就太棒了！

getComponentFromEntity可能是关键，也许需要一个黑魔法类型的图案来解决这个问题？！

感谢您抽出宝贵的时间

◽playground link

//utils types
type Constructor<T> = { new(...args: any): T };
type ExtractComponentType<T> = T extends Entity<infer C> ? C : never;
type EntitiesCareMap<C extends Component> = Map<number, Entity<C>>
type ComponentType<T extends Component = Component> = Constructor<T>;
type TupleToInstances3<T extends readonly unknown[]> = {
    [K in keyof T]: T[K] extends Constructor<infer U> ? U extends {} ? U : never : never;
}

type ExtractSystemComponents4<
    S extends Rules,
    K extends RULES
> = S[K] extends ComponentType[] ? S[K] extends never[] ? UnknowComponent : TupleToInstances3<S[K]>[number] : never;

interface SystemUpdate<S extends System = System, R extends Rules = S['rules']> {
    entities: EntitiesCareMap<
        ExtractSystemComponents4<R, RULES.hasAll>
    >;

}
// issue

class Entity<
    C extends Component = Component,
> {
    declare public components: Set<C>;

    get<T extends C>(componentClass: Constructor<T>): T {
        return undefined as unknown as T;
    }
        has<T extends Component>( componentClass: Constructor<T> ): this is Entity<T> {
        return false;
    }

}
abstract class Component {
    foo() { }
}

enum RULES {
    hasAll,
}
type Rules = { readonly [K in RULES]?: ComponentType[] };
abstract class System {
    abstract rules: Rules;
    abstract onUpdate(t: SystemUpdate<System, Rules>): void;
}

export class UnknowComponent extends Component {
    #component!: never;
}

export class AComponent extends Component {
    #component!: never;
}
export class BComponent extends Component {
    #component!: never;
}
export class CComponent extends Component {
    #component!: never;
}
export class DComponent extends Component {
    #component!: never;
}

class SystemA extends System {
    public rules = {
        [RULES.hasAll]: [AComponent, BComponent],
    };

    onUpdate({entities}: SystemUpdate<SystemA>) {
        entities.forEach(( e ) => {
            e.get(BComponent)// ? this should pass.
            e.get(AComponent)// ? this should pass.
            e.get(CComponent)// ? this should error
            if (e.has(CComponent)) {
                e.get(CComponent)// ? this should pass.
                e.get(DComponent)// ? this should error
                if (e.has(DComponent)) {
                    e.get(DComponent)// ? this should pass.
                }
            }
        });
    }
}



declare const ab: Entity<BComponent> | Entity<BComponent | CComponent>;

/** Get a components from entity */
function getComponentFromEntity<E extends Entity, C extends ExtractComponentType<E>>(entity: E, component: Constructor<C>): C {
    return entity.get(component);
}

getComponentFromEntity(ab, BComponent) // ? this should pass.
getComponentFromEntity(ab, AComponent) // ? this should error.
getComponentFromEntity(ab, CComponent) // ? this should error.
//^?

declare const a: Entity<BComponent | CComponent>;
a.get(BComponent)// ? this should pass.
a.get(AComponent)// ? this should error