TypeScript中Mixin实现多继承可构建但无法生成声明文件的原因

这是个非常典型的TypeScript类型系统边界问题，核心在于运行时类型检查和声明文件生成规则的差异，尤其是涉及到类表达式的私有/protected成员时。

一、为什么代码能正常编译运行？ #

TypeScript在编译当前模块的代码时，主要做的是内部类型一致性检查：

• 你的TaggedMixin函数内部创建的Tagged类，继承了传入的父类，TS能清晰推导它的成员可访问性（比如protected成员可以在子类TaggedClass中访问）。
• TaggedClass继承自Tagged时，TS能确认你在构造函数中访问的ANON_PROTECTED、TAG_PROTECTED等成员确实在父类中存在且可访问，所以不会在编译阶段报错，代码也能正常运行。

简单说：只要当前模块内的类型逻辑自洽，TS就会放行运行时编译。

二、为什么生成声明文件（.d.ts）时报错？ #

你看到的TS(4094)错误，本质原因是：TypeScript不允许导出的类表达式包含私有/protected成员。

背后的逻辑是：

1. 声明文件的作用是给外部模块提供类型提示，而私有/protected成员本来就不应该被外部代码访问。
2. 类表达式（比如你TaggedMixin返回的class Tagged extends superClass）没有一个稳定的“具名身份”，TypeScript无法在声明文件中准确描述它的protected成员的访问范围——protected成员的访问权限是绑定到类的继承链的，但匿名类的继承关系在声明文件里无法被清晰定义。
3. 私有成员更是完全不应该出现在声明文件中，因为它们只能在类内部访问，外部代码根本无法触及，强行写入声明会误导类型系统。

你的代码中，Tagged作为导出变量（间接导出，因为TaggedClass继承了它），它的TAG_PROTECTED、tag_private等私有/protected成员会被TS判定为“不应该出现在对外暴露的声明中”，所以生成.d.ts时就会抛出错误。

三、怎么解决这个问题？ #

要兼顾Mixin的设计意图和声明文件生成，有几种可行的方案：

方案1：用接口隐藏内部成员 #

定义一个只包含公共成员的接口，让Mixin返回的类实现这个接口，同时在声明中只暴露接口的类型：

// 定义Mixin的公共接口
interface TaggedPublic {
  tag_public: string;
}

interface TaggedPublicConstructor {
  new(...args: any[]): TaggedPublic;
  TAG_PUBLIC: string;
}

// 定义构造函数类型
type Ctor = new (...args: any[]) => {};

export function TaggedMixin<Super extends Ctor>(superClass: Super): Super & TaggedPublicConstructor {
  class Tagged extends superClass implements TaggedPublic {
    public static TAG_PUBLIC: string = "public-tag";
    protected static TAG_PROTECTED: string = "protected-tag";
    private static TAG_PRIVATE: string = "private-tag";
    public tag_public!: string;
    protected tag_protected!: number;
    private tag_private!: number;
  }
  // 类型断言为公共接口类型
  return Tagged as Super & TaggedPublicConstructor;
}

const Tagged = TaggedMixin(class {
  public static ANON_PUBLIC: string = "anon-public";
  protected static ANON_PROTECTED: string = "anon-protected";
  private static ANON_PRIVATE: string = "anon-private";
  public anon_public!: string;
  protected anon_protected!: number;
  private anon_private!: number;
});

export class TaggedClass extends Tagged {
  constructor() {
    super();
    TaggedClass.ANON_PUBLIC;
    TaggedClass.ANON_PROTECTED;
    TaggedClass.TAG_PUBLIC;
    TaggedClass.TAG_PROTECTED;
    this.anon_public;
    this.anon_protected;
    this.tag_public;
    this.tag_protected;
  }
}

这样生成声明文件时，只会暴露TaggedPublic接口中的公共成员，内部的私有/protected成员不会出现在.d.ts中，避免报错。

方案2：用模块级私有数据模拟私有成员 #

如果需要保留私有成员的封装性，可以用WeakMap来存储实例的私有数据，避免在类中定义私有成员：

type Ctor = new (...args: any[]) => {};

// 模块级私有存储
const tagPrivateData = new WeakMap<InstanceType<ReturnType<typeof TaggedMixin>>, { tag_private: number }>();
const tagProtectedData = new WeakMap<InstanceType<ReturnType<typeof TaggedMixin>>, { tag_protected: number }>();

export function TaggedMixin<Super extends Ctor>(superClass: Super) {
  class Tagged extends superClass {
    public static TAG_PUBLIC: string = "public-tag";
    protected static TAG_PROTECTED: string = "protected-tag";
    private static TAG_PRIVATE: string = "private-tag";
    public tag_public!: string;

    constructor(...args: any[]) {
      super(...args);
      tagPrivateData.set(this, { tag_private: 123 });
      tagProtectedData.set(this, { tag_protected: 456 });
    }

    // 可以通过方法访问私有数据
    getTagPrivate(): number {
      return tagPrivateData.get(this)!.tag_private;
    }
  }
  return Tagged;
}

这种方式下，类中没有私有/protected的实例成员，生成声明文件时就不会触发TS4094错误，同时也保留了数据的封装性。

总结 #

TypeScript允许代码运行是因为它能在当前模块内验证类型的一致性，但生成声明文件时需要考虑外部代码的类型安全——导出的类表达式的私有/protected成员无法被准确地在声明中描述，所以会抛出错误。通过接口隐藏内部成员或用模块级存储模拟私有数据，就能解决这个问题。

内容的提问来源于stack exchange，提问作者Florian Bachmann