TypeScript 交换混入组合

假设我有一个带有方法的基础编码器类

encode(obj: {body: Uint8Array}): Uint8Array

我将其扩展为接受带有一个或多个混入的不同 obj.body 类型——即：

function numberMixin(encoder) {
    return class extends encoder {
       encode(obj) {
           if (isNumberObj(obj)) {
              ...
              return super.encode(transformed);
           }
           return super.encode(obj);
        }
    }
}

并编写这些混入

const Encoder = etcMixin(numberMixin(stringMixin(Base)));

有没有办法为每个 mixin/编码器添加注释，以便生成的类的 encode 方法知道它接受哪些类型？我可以指定输入/输出功能，但这样 mixin 的顺序就很固定，不能轻易扩展。

一种选择是在每个 mixin 上使用泛型类型参数，但那样的话我必须在组合的每一步都指定类型，这看起来有些多余/太啰嗦。

numberMixin<U, T extends Constructor<IEncoder<U>>>(encoder: T): T & Constructor<IEncoder<Number|U>>;

答案＃1

我们可以利用这样一个事实：函数类型的交集被视为与重载函数相同，因此我们可以构造 encode 的类型为 BaseClass['encode'] & newOverlaodSignature。

唯一的问题是我们不能使用方法语法来做到这一点，我们需要使用函数字段语法，这意味着我们将声明字段，但需要手动将其分配给原型。此外，由于我们是手动添加函数，所以不能使用 super. 语法，我们需要手动调用基类的实现，因此在这里我们会失去一些类型安全性。

好消息是调用位置看起来不错，并且所有重载都存在：

编辑从评论中获取额外学分作业，同时收集类型，以便我们在其他 mixin 中使用它们。如果我们为类型添加一个额外的静态属性，其中包含每个添加类型的字段，我们就可以做到这一点。之所以需要一个字段而不仅仅是类型的一个字段，是因为返回的类型将是 AddedStuff & T，所以这将传递到类型字段，并且我们会得到所有 mixin 中定义的 type 字段的交集。printEncodedMixin 使用了额外的类型信息：

class EncoderBase {
    constructor(param: string) {

    }
    encode(obj: { body: Uint8Array }): Uint8Array {
        return obj.body;
    }
    static type: { Uint8Array: Uint8Array }
}
type EncoderType = {
    new (...args: any[]) : { encode: (obj: { body: Uint8Array }) => Uint8Array }
    type: any
}

function numberMixin<T extends EncoderType>(encoder: T) {
    function isNumberObj(obj: any): obj is { body: number } {
        return obj && typeof obj.body === 'number';
    }
    let resultClass = class extends encoder {
        encode!: InstanceType<T>['encode'] & ((obj: { body: number }) => Uint8Array);
        static type : { number : number }
    }
    resultClass.prototype.encode = function (obj: any) {
        if (isNumberObj(obj)) {
            return encoder.prototype.encode(obj);
        }
        return encoder.prototype.encode(obj);
    }

    return resultClass;
}

function stringMixin<T extends EncoderType>(encoder: T) {
    function isStringObj(obj: any): obj is { body: string } {
        return obj && typeof obj.body === 'string';
    }
    let resultClass = class extends encoder {
        encode!: InstanceType<T>['encode'] & ((obj: { body: string }) => Uint8Array);
        static type : { string : string }
    }
    resultClass.prototype.encode = function (obj: any) {
        if (isStringObj(obj)) {
            return encoder.prototype.encode(obj);
        }
        return encoder.prototype.encode(obj);
    }
    return resultClass;
}

function printEncodedMixin<T extends EncoderType>(encoder: T) {
    type Body<T> = T extends any ? {body : T} : never;
    return class extends encoder {
        printEncoded(b: Body<T['type'][keyof T['type']]>) {

        }
    }
}

const Encoder = printEncodedMixin(numberMixin(stringMixin(EncoderBase)));

let d = new Encoder(""); // ctor params still work
d.encode({ body: "" });
d.encode({ body: 0 });
d.encode({ body: {} }); // Error
d.printEncoded({ body: "" }) //  printEncoded({body: string;} | {body: number;} | {body: Uint8Array;}): void