如何用导入做类的相互递归？

Question

如何正确处理导入循环依赖？

base.ts

import * as all from './all'
export class Base {}
export class Container extends Base {
  parse(){
    console.log(all)
  }
}

所有.ts

import { Base, Container } from './base';
export class A extends Base {}
export class B extends Container {}

main.ts

import { Container } from './base';
new Container().parse();

汇总生成的代码：

class A extends Base {
}
class B extends Container {
}
const all = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
  __proto__: null,
  A,
  B
}, Symbol.toStringTag, { value: "Module" }));
class Base {
}
class Container extends Base {
  parse() {
    console.log(all);
  }
}
new Container().parse();

将

class B extends Container

放在

class Container

之前，这当然失败了。

也许，当需要这样的逻辑时，没有办法优雅地处理它，bundle有自己的规则来选择先放置哪个循环依赖，并且顺序非常重要，无法正确提升循环依赖项.即

class

不能吊在

class extends

所以我可以提供两个丑陋/技巧解决方案作为最后的手段，使代码尽可能少工作

解决方案一：

  class A extends f() {}
  class C extends f() {}

  var _B; // only var can wrok, let will fail
  function f() {
    //make sure the return class with the same identity
    if (!_B) {
      _B = class B {
        static id = Math.random();
      };
    }
    return _B;
  }

解决方案可以工作，因为

function

总是被吊起来

解决方案二：

import './all' //magic import make things work!
import { Container } from './base';
new Container().parse();

这可以工作，因为它强制执行循环依赖的依赖解析顺序