TypeScript：用于实现抽象 class 的 Mixin

Question

I would like to create a mixin for the implementation of an abstract class implementation

So I have an abstract class

abstract class A {
    doStuff(): void {
        this.doMoreStuff();
    }

    abstract doMoreStuff(): void;
}

and an implementation for which I want a mixin:

class B extends A {
    doMoreStuff(): void {
        console.log(3 + 5);
    }
}

This mixin, for example, does some additional reporting when work is done:

type Constructor<T> = new (...args: unknown[]) => T;

function WorkReporter<T extends A, TBase extends Constructor<T>>(Base: TBase): TBase {
    return class W extends Base {
        doStuff(): void {
            console.log("Does stuff");
            super.doStuff();
        }

        doMoreStuff(): void {
            console.log("Does more stuff!");
            super.doMoreStuff();
        }
    };
}

And eventually, the mixin is used:

const ReportedWork = WorkReporter(B);
new ReportedWork().doStuff();

---

However, I can't get this to work. I can't find a way how to create a mixin not for A itself, but for any implementation of A. For the mixin, I get:

Class 'W' incorrectly extends base class 'T'.
  'W' is assignable to the constraint of type 'T', but 'T' could be instantiated with a different subtype of constraint 'A'.

And for the doMoreStuff call within the mixin, I get:

Abstract method 'doMoreStuff' in class 'A' cannot be accessed via super expression.

How can I achieve this? I need a mixin which calls the implementation of an abstract super class and extending its functionality.

Answer 1

instead of

super.doMoreStuff();

try

(Base.prototype as A).doMoreStuff?.call(this);

and why not just

function WorkReporter<TBase extends Constructor<A>>(Base: TBase): TBase { ...