如何基于泛型类型定义抽象属性

Question

What I'm trying to do is to define type of a property in abstract class and initialize it in child classes.

link to playground

---

I have type that returns different type based on whether passed argument is an array:

type ArrayElement<T> = T extends (infer R)[] ? R : never;
type Children<T> = T extends unknown[] ? Wrapper<ArrayElement<T>>[] : Map<string, Wrapper>;

The wrapper class defines its children property as type Children<T> :

abstract class Wrapper<T = any> {
    // need access to children in this class.
    abstract children: Children<T>

    getChildren(): Wrapper[] {
        return Array.from(this.children.values())
    }
}

I would expect to initialize children property in child classes with either Array or a Map , but even with correct generic passed to Wrapper it doesn't work.

class WrapperArray<T extends unknown[]> extends Wrapper<T> {
    // Property 'children' in type 'WrapperArray<T>' is not assignable to the same 
    // property in base type 'Wrapper<T>'.
    // Type 'Wrapper<ArrayElement<T>>[]' is not assignable to type 'Children<T>'.(2416)
    children = [] as Wrapper<ArrayElement<T>>[];
}

class WrapperGroup<T> extends Wrapper<T> {
    // Property 'children' in type 'WrapperGroup<T>' is not assignable to the same 
    // property in base type 'Wrapper<T>'.
    // Type 'Map<string, Wrapper<any>>' is not assignable to type 'Children<T>'.(2416)
    children = new Map<string, Wrapper>();
}

Answer 1

updated playground

Alright, so solution was easier than I thought. All I had to do, is to cast child class children property to Children type with correct generic:

abstract class Wrapper<T = any> {
    abstract children: Children<T>;

    getChildren(): Wrapper[] {
        return Array.from(this.children.values());
    }
}

class WrapperArray<T extends unknown[]> extends Wrapper<T> {
    children = [] as Wrapper<ArrayElement<T>>[] as Children<T>l;

    test() {
        // works
        this.children.map(c => c)
    }
}

// Not so sure if {} is enough, because it allows arrays tho
class WrapperGroup<T extends {}> extends Wrapper<T> {
    children = new Map<string, Wrapper>() as Children<T>;

    test() {
        // works
        this.children.get('test')
    }
}