Комбинируйте примеси с дженериками в node.js

Кажется, что это невозможно. Поскольку MyWorld не является типом, это скорее странное описание типа.

Когда я позволяю своей идее указать тип, я получаю эту строку:

const MyWorld: { new(): ({ world: string[]; createDog(): void } & any); prototype: { world: string[]; createDog(): void } } = AnimalCreator(PlantCreator(DefaultCreator));

Мое решение состоит в том, чтобы заставить пользователя по соглашению создать экземпляр пользователем и вернуть world моего примера.

Я изменил свою игровую площадку, чтобы получить этот код:

abstract class Playground {
    abstract createWorld(): string[];
    play() {
        console.info("Creating world containing:");
        this.createWorld().forEach(item => console.info(`- ${item}`))
    }
}

class MyPlayground extends Playground {
    createWorld(): string[] {
        const world = new MyWorld();
        world.someMagic();
        world.createPlant();
        world.createDog();
        return world.getWorldList();
    }
}

new MyPlayground().play();

Вывод кода выше:

Creating world containing:
- magic
- Plant
- Dog

Вы на самом деле были не за горами, но вы размыли границы между Типами и Ценностями. К счастью, Javascript/Typescript позволяет это сделать.

// Match only a constructor
type Creator<T = {}> = new (...args: any[]) => T;

// Match an actual class
interface CreatorClass<T> {
    new(...args: any[]): T;
}

class DefaultCreator {
        world:string[] = [];
        someMagic() {
            this.world.push("magic")
        }
        getWorldList() {
            return this.world;
        }
}

function PlantCreator<TBase extends Creator>(Base: TBase) {
    return class extends Base {
        private world = (<DefaultCreator><any>this).world;
        createPlant() {
            this.world.push("Plant")
        }
    };
}

function AnimalCreator<TBase extends Creator>(Base: TBase) {
    return class extends Base {
        private world = (<DefaultCreator><any>this).world;
        createDog() {
            this.world.push("Dog")
        }
    };
}

interface IPlantWorld {
    createPlant(): void;
}

interface IAnimalWorld {
  createDog();
}

const MyWorld: CreatorClass<IPlantWorld & IAnimalWorld> = AnimalCreator(PlantCreator(DefaultCreator));

abstract class Playground {
    // I want to have a reference of the class' constructor
    createOtherWorld<T>(creator: Creator<T>) {
        return new creator();
    }

    // I want to reference the class itself
    createWorld<T>(creator: CreatorClass<T>): T {
        return new creator() as T;
    }
    play() {
        this.createWorld(DefaultCreator);
    }
}



class EverythingPlaygroundFactory extends Playground {
    play() {
        // provide the type information
        return this.createWorld<IAnimalWorld & IPlantWorld>(MyWorld);
    }
}

let pg = new EverythingPlaygroundFactory();
let world = pg.createWorld(MyWorld);
world.createPlant();
world.createDog();

pg.createOtherWorld(MyWorld.prototype.constructor);

Вероятно, это больше похоже на то, что вы искали.

Что следует отметить:

type Creator<T = {}> = new (... args: any[]) => T может и будет ссылаться только на фактический конструктор любого класса, но никогда не будет соответствовать всему классу/объекту класса. Всегда помните, что классы/функции являются исполняемыми объектами.