@umijs/mfsu 4.0.0-beta.8 → 4.0.0-canary-20240513.3

package/dist/dep/getModuleExports.js

@@ -1,45 +1,60 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getModuleExports = void 0;
-const es_module_lexer_1 = require("@umijs/bundler-utils/compiled/es-module-lexer");
-const esbuild_1 = require("@umijs/bundler-utils/compiled/esbuild");
-const path_1 = require("path");
-const getCJSExports_1 = require("./getCJSExports");
-function getModuleExports({ content, filePath, }) {
-    return __awaiter(this, void 0, void 0, function* () {
-        // Support tsx and jsx
-        if (filePath && /\.(tsx|jsx)$/.test(filePath)) {
-            content = (yield (0, esbuild_1.transform)(content, {
-                sourcemap: false,
-                sourcefile: filePath,
-                format: 'esm',
-                target: 'es6',
-                loader: (0, path_1.extname)(filePath).slice(1),
-            })).code;
-        }
-        yield es_module_lexer_1.init;
-        const [imports, exports] = (0, es_module_lexer_1.parse)(content);
-        let isCJS = !imports.length && !exports.length;
-        let cjsEsmExports = null;
-        if (isCJS) {
-            cjsEsmExports = (0, getCJSExports_1.getCJSExports)({ content });
-            if (cjsEsmExports.includes('__esModule')) {
-                isCJS = false;
-            }
-        }
-        return {
-            exports: cjsEsmExports || exports,
-            isCJS,
-        };
-    });
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/dep/getModuleExports.ts
+var getModuleExports_exports = {};
+__export(getModuleExports_exports, {
+  getModuleExports: () => getModuleExports
+});
+module.exports = __toCommonJS(getModuleExports_exports);
+var import_es_module_lexer = require("@umijs/bundler-utils/compiled/es-module-lexer");
+var import_esbuild = require("@umijs/bundler-utils/compiled/esbuild");
+var import_path = require("path");
+var import_getCJSExports = require("./getCJSExports");
+async function getModuleExports({
+  content,
+  filePath
+}) {
+  if (filePath && /\.(tsx|jsx)$/.test(filePath)) {
+    content = (await (0, import_esbuild.transform)(content, {
+      sourcemap: false,
+      sourcefile: filePath,
+      format: "esm",
+      target: "es6",
+      loader: (0, import_path.extname)(filePath).slice(1)
+    })).code;
+  }
+  await import_es_module_lexer.init;
+  const [imports, exports] = (0, import_es_module_lexer.parse)(content);
+  let isCJS = !imports.length && !exports.length;
+  let cjsEsmExports = null;
+  if (isCJS) {
+    cjsEsmExports = (0, import_getCJSExports.getCJSExports)({ content });
+    if (cjsEsmExports.includes("__esModule")) {
+      isCJS = false;
+    }
+  }
+  return {
+    exports: cjsEsmExports || exports,
+    isCJS
+  };
 }
-exports.getModuleExports = getModuleExports;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getModuleExports
+});

package/dist/depBuilder/depBuilder.d.ts

@@ -1,5 +1,5 @@
 import { Dep } from '../dep/dep';
-import { MFSU } from '../mfsu';
+import { MFSU } from '../mfsu/mfsu';
 interface IOpts {
     mfsu: MFSU;
 }
@@ -16,8 +16,13 @@ export declare class DepBuilder {
         onBuildComplete: Function;
         deps: Dep[];
     }): Promise<void>;
+    buildWithWorker(opts: {
+        onBuildComplete: Function;
+        deps: Dep[];
+    }): Promise<void>;
     build(opts: {
         deps: Dep[];
+        useWorker: boolean;
     }): Promise<void>;
     onBuildComplete(fn: Function): void;
     writeMFFiles(opts: {
@@ -28,4 +33,3 @@ export declare class DepBuilder {
     }): import("webpack").Configuration;
 }
 export {};
-//# sourceMappingURL=depBuilder.d.ts.map

package/dist/depBuilder/depBuilder.js

@@ -1,165 +1,229 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DepBuilder = void 0;
-const bundler_esbuild_1 = require("@umijs/bundler-esbuild");
-const utils_1 = require("@umijs/utils");
-const fs_1 = require("fs");
-const path_1 = require("path");
-const constants_1 = require("../constants");
-const depChunkIdPrefixPlugin_1 = require("../webpackPlugins/depChunkIdPrefixPlugin");
-const stripSourceMapUrlPlugin_1 = require("../webpackPlugins/stripSourceMapUrlPlugin");
-const getESBuildEntry_1 = require("./getESBuildEntry");
-class DepBuilder {
-    constructor(opts) {
-        this.completeFns = [];
-        this.isBuilding = false;
-        this.opts = opts;
-    }
-    buildWithWebpack(opts) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const config = this.getWebpackConfig({ deps: opts.deps });
-            return new Promise((resolve, reject) => {
-                const compiler = this.opts.mfsu.opts.implementor(config);
-                compiler.run((err, stats) => {
-                    opts.onBuildComplete();
-                    if (err || (stats === null || stats === void 0 ? void 0 : stats.hasErrors())) {
-                        if (err) {
-                            reject(err);
-                        }
-                        if (stats) {
-                            const errorMsg = stats.toString('errors-only');
-                            // console.error(errorMsg);
-                            reject(new Error(errorMsg));
-                        }
-                    }
-                    else {
-                        resolve(stats);
-                    }
-                    compiler.close(() => { });
-                });
-            });
-        });
-    }
-    // TODO: support watch and rebuild
-    buildWithESBuild(opts) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const entryContent = (0, getESBuildEntry_1.getESBuildEntry)({ deps: opts.deps });
-            const ENTRY_FILE = 'esbuild-entry.js';
-            const tmpDir = this.opts.mfsu.opts.tmpBase;
-            const entryPath = (0, path_1.join)(tmpDir, ENTRY_FILE);
-            (0, fs_1.writeFileSync)(entryPath, entryContent, 'utf-8');
-            const date = new Date().getTime();
-            yield (0, bundler_esbuild_1.build)({
-                cwd: this.opts.mfsu.opts.cwd,
-                entry: {
-                    [`${constants_1.MF_VA_PREFIX}remoteEntry`]: entryPath,
-                },
-                config: {
-                    outputPath: tmpDir,
-                    alias: this.opts.mfsu.alias,
-                    externals: this.opts.mfsu.externals,
-                },
-            });
-            utils_1.logger.event(`[mfsu] compiled with esbuild successfully in ${+new Date() - date} ms`);
-            opts.onBuildComplete();
-        });
-    }
-    build(opts) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.isBuilding = true;
-            yield this.writeMFFiles({ deps: opts.deps });
-            const newOpts = Object.assign(Object.assign({}, opts), { onBuildComplete: () => {
-                    this.isBuilding = false;
-                    this.completeFns.forEach((fn) => fn());
-                    this.completeFns = [];
-                } });
-            if (this.opts.mfsu.opts.buildDepWithESBuild) {
-                yield this.buildWithESBuild(newOpts);
-            }
-            else {
-                yield this.buildWithWebpack(newOpts);
-            }
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/depBuilder/depBuilder.ts
+var depBuilder_exports = {};
+__export(depBuilder_exports, {
+  DepBuilder: () => DepBuilder
+});
+module.exports = __toCommonJS(depBuilder_exports);
+var import_bundler_esbuild = require("@umijs/bundler-esbuild");
+var import_utils = require("@umijs/utils");
+var import_fs = require("fs");
+var import_path = require("path");
+var import_constants = require("../constants");
+var import_depChunkIdPrefixPlugin = require("../webpackPlugins/depChunkIdPrefixPlugin");
+var import_stripSourceMapUrlPlugin = require("../webpackPlugins/stripSourceMapUrlPlugin");
+var import_getESBuildEntry = require("./getESBuildEntry");
+var MF_ENTRY = "mf_index.js";
+var DepBuilder = class {
+  constructor(opts) {
+    this.completeFns = [];
+    this.isBuilding = false;
+    this.opts = opts;
+  }
+  async buildWithWebpack(opts) {
+    const config = this.getWebpackConfig({ deps: opts.deps });
+    return new Promise((resolve, reject) => {
+      const compiler = this.opts.mfsu.opts.implementor(config);
+      compiler.run((err, stats) => {
+        opts.onBuildComplete();
+        if (err || (stats == null ? void 0 : stats.hasErrors())) {
+          if (err) {
+            reject(err);
+          }
+          if (stats) {
+            const errorMsg = stats.toString("errors-only");
+            reject(new Error(errorMsg));
+          }
+        } else {
+          resolve(stats);
+        }
+        compiler.close(() => {
         });
-    }
-    onBuildComplete(fn) {
-        if (this.isBuilding) {
-            this.completeFns.push(fn);
+      });
+    });
+  }
+  // TODO: support watch and rebuild
+  async buildWithESBuild(opts) {
+    const entryContent = (0, import_getESBuildEntry.getESBuildEntry)({
+      mfName: this.opts.mfsu.opts.mfName,
+      deps: opts.deps
+    });
+    const ENTRY_FILE = "esbuild-entry.js";
+    const tmpDir = this.opts.mfsu.opts.tmpBase;
+    const entryPath = (0, import_path.join)(tmpDir, ENTRY_FILE);
+    (0, import_fs.writeFileSync)(entryPath, entryContent, "utf-8");
+    const date = (/* @__PURE__ */ new Date()).getTime();
+    await (0, import_bundler_esbuild.build)({
+      cwd: this.opts.mfsu.opts.cwd,
+      entry: {
+        [`${import_constants.MF_VA_PREFIX}remoteEntry`]: entryPath
+      },
+      config: {
+        ...this.opts.mfsu.opts.depBuildConfig,
+        outputPath: tmpDir,
+        alias: this.opts.mfsu.alias,
+        externals: this.opts.mfsu.externals
+      },
+      inlineStyle: true
+    });
+    import_utils.logger.event(
+      `[mfsu] compiled with esbuild successfully in ${+/* @__PURE__ */ new Date() - date} ms`
+    );
+    opts.onBuildComplete();
+  }
+  async buildWithWorker(opts) {
+    const worker = this.opts.mfsu.opts.startBuildWorker(opts.deps);
+    worker.postMessage(opts.deps);
+    return new Promise((resolve, reject) => {
+      const onMessage = ({
+        progress,
+        done
+      }) => {
+        if (done) {
+          opts.onBuildComplete();
+          worker.off("message", onMessage);
+          if (done.withError) {
+            import_utils.logger.debug("[MFSU][eager][main] build failed", done.withError);
+            reject(done.withError);
+          } else {
+            resolve();
+          }
         }
-        else {
-            fn();
+        if (progress) {
+          this.opts.mfsu.onProgress(progress);
         }
+      };
+      worker.on("message", onMessage);
+      worker.once("error", (e) => {
+        import_utils.logger.error("[MFSU][eager] worker got Error", e);
+        opts.onBuildComplete();
+        reject(e);
+      });
+    });
+  }
+  async build(opts) {
+    this.isBuilding = true;
+    const onBuildComplete = () => {
+      this.isBuilding = false;
+      this.completeFns.forEach((fn) => fn());
+      this.completeFns = [];
+    };
+    try {
+      const buildOpts = {
+        ...opts,
+        onBuildComplete
+      };
+      if (this.opts.mfsu.opts.strategy === "eager" && opts.useWorker) {
+        await this.buildWithWorker(buildOpts);
+        return;
+      }
+      await this.writeMFFiles({ deps: opts.deps });
+      if (this.opts.mfsu.opts.buildDepWithESBuild) {
+        await this.buildWithESBuild(buildOpts);
+      } else {
+        await this.buildWithWebpack(buildOpts);
+      }
+    } catch (e) {
+      onBuildComplete();
+      throw e;
     }
-    writeMFFiles(opts) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const tmpBase = this.opts.mfsu.opts.tmpBase;
-            // expose files
-            for (const dep of opts.deps) {
-                const content = yield dep.buildExposeContent();
-                (0, fs_1.writeFileSync)((0, path_1.join)(tmpBase, dep.filePath), content, 'utf-8');
-            }
-            // index file
-            (0, fs_1.writeFileSync)((0, path_1.join)(tmpBase, 'index.js'), '"😛"', 'utf-8');
-        });
+  }
+  onBuildComplete(fn) {
+    if (this.isBuilding) {
+      this.completeFns.push(fn);
+    } else {
+      fn();
     }
-    getWebpackConfig(opts) {
-        var _a, _b;
-        const mfName = this.opts.mfsu.opts.mfName;
-        const depConfig = utils_1.lodash.cloneDeep(this.opts.mfsu.depConfig);
-        // depConfig.stats = 'none';
-        depConfig.entry = (0, path_1.join)(this.opts.mfsu.opts.tmpBase, 'index.js');
-        depConfig.output.path = this.opts.mfsu.opts.tmpBase;
-        // disable devtool
-        depConfig.devtool = false;
-        // disable library
-        // library 会影响 external 的语法，导致报错
-        // ref: https://github.com/umijs/plugins/blob/6d3fc2d/packages/plugin-qiankun/src/slave/index.ts#L83
-        if ((_a = depConfig.output) === null || _a === void 0 ? void 0 : _a.library)
-            delete depConfig.output.library;
-        if ((_b = depConfig.output) === null || _b === void 0 ? void 0 : _b.libraryTarget)
-            delete depConfig.output.libraryTarget;
-        // merge all deps to vendor
-        depConfig.optimization || (depConfig.optimization = {});
-        depConfig.optimization.splitChunks = {
-            chunks: 'all',
-            maxInitialRequests: Infinity,
-            minSize: 0,
-            cacheGroups: {
-                vendor: {
-                    test: /.+/,
-                    name(_module, _chunks, cacheGroupKey) {
-                        return `${constants_1.MF_DEP_PREFIX}___${cacheGroupKey}`;
-                    },
-                },
-            },
-        };
-        depConfig.plugins = depConfig.plugins || [];
-        depConfig.plugins.push(new depChunkIdPrefixPlugin_1.DepChunkIdPrefixPlugin());
-        depConfig.plugins.push(new stripSourceMapUrlPlugin_1.StripSourceMapUrlPlugin({
-            webpack: this.opts.mfsu.opts.implementor,
-        }));
-        const exposes = opts.deps.reduce((memo, dep) => {
-            memo[`./${dep.shortFile}`] = (0, path_1.join)(this.opts.mfsu.opts.tmpBase, dep.filePath);
-            return memo;
-        }, {});
-        depConfig.plugins.push(new this.opts.mfsu.opts.implementor.container.ModuleFederationPlugin({
-            library: {
-                type: 'global',
-                name: mfName,
-            },
-            name: mfName,
-            filename: constants_1.REMOTE_FILE_FULL,
-            exposes,
-        }));
-        return depConfig;
+  }
+  async writeMFFiles(opts) {
+    const tmpBase = this.opts.mfsu.opts.tmpBase;
+    import_utils.fsExtra.mkdirpSync(tmpBase);
+    for (const dep of opts.deps) {
+      const content = await dep.buildExposeContent();
+      (0, import_fs.writeFileSync)((0, import_path.join)(tmpBase, dep.filePath), content, "utf-8");
     }
-}
-exports.DepBuilder = DepBuilder;
+    (0, import_fs.writeFileSync)((0, import_path.join)(tmpBase, MF_ENTRY), '"😛"', "utf-8");
+  }
+  getWebpackConfig(opts) {
+    var _a, _b;
+    const mfName = this.opts.mfsu.opts.mfName;
+    const depConfig = import_utils.lodash.cloneDeep(this.opts.mfsu.depConfig);
+    depConfig.entry = (0, import_path.join)(this.opts.mfsu.opts.tmpBase, MF_ENTRY);
+    depConfig.output.path = this.opts.mfsu.opts.tmpBase;
+    depConfig.output.publicPath = "auto";
+    depConfig.devtool = false;
+    if ((_a = depConfig.output) == null ? void 0 : _a.library)
+      delete depConfig.output.library;
+    if ((_b = depConfig.output) == null ? void 0 : _b.libraryTarget)
+      delete depConfig.output.libraryTarget;
+    depConfig.optimization || (depConfig.optimization = {});
+    depConfig.optimization.splitChunks = {
+      chunks: (chunk) => {
+        const hasShared = chunk.getModules().some((m) => {
+          return m.type === "consume-shared-module" || m.type === "provide-module" || m.type === "provide-shared-module";
+        });
+        return !hasShared;
+      },
+      maxInitialRequests: Infinity,
+      minSize: 0,
+      cacheGroups: {
+        vendor: {
+          test: /.+/,
+          name(_module, _chunks, cacheGroupKey) {
+            return `${import_constants.MF_DEP_PREFIX}___${cacheGroupKey}`;
+          }
+        }
+      }
+    };
+    depConfig.plugins = depConfig.plugins || [];
+    depConfig.plugins.push(new import_depChunkIdPrefixPlugin.DepChunkIdPrefixPlugin());
+    depConfig.plugins.push(
+      new import_stripSourceMapUrlPlugin.StripSourceMapUrlPlugin({
+        webpack: this.opts.mfsu.opts.implementor
+      })
+    );
+    depConfig.plugins.push(
+      new this.opts.mfsu.opts.implementor.ProgressPlugin((percent, msg) => {
+        this.opts.mfsu.onProgress({ percent, status: msg });
+      })
+    );
+    const exposes = opts.deps.reduce((memo, dep) => {
+      memo[`./${dep.file}`] = (0, import_path.join)(this.opts.mfsu.opts.tmpBase, dep.filePath);
+      return memo;
+    }, {});
+    depConfig.plugins.push(
+      new this.opts.mfsu.opts.implementor.container.ModuleFederationPlugin({
+        library: {
+          type: "global",
+          name: mfName
+        },
+        name: mfName,
+        filename: import_constants.REMOTE_FILE_FULL,
+        exposes,
+        shared: this.opts.mfsu.opts.shared || {}
+      })
+    );
+    return depConfig;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DepBuilder
+});

package/dist/depBuilder/getESBuildEntry.d.ts

@@ -1,5 +1,5 @@
 import { Dep } from '../dep/dep';
 export declare function getESBuildEntry(opts: {
+    mfName: string;
     deps: Dep[];
 }): string;
-//# sourceMappingURL=getESBuildEntry.d.ts.map

package/dist/depBuilder/getESBuildEntry.js

@@ -1,9 +1,43 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getESBuildEntry = void 0;
-const constants_1 = require("../constants");
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/depBuilder/getESBuildEntry.ts
+var getESBuildEntry_exports = {};
+__export(getESBuildEntry_exports, {
+  getESBuildEntry: () => getESBuildEntry
+});
+module.exports = __toCommonJS(getESBuildEntry_exports);
+var import_constants = require("../constants");
+var ES_INTEROP_FUNC = `__exportStar`;
+var ES_INTEROP_HELPER = `
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+  if (k2 === undefined) k2 = k;
+  Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+  if (k2 === undefined) k2 = k;
+  o[k2] = m[k];
+}));
+var ${ES_INTEROP_FUNC} = (this && this.__exportStar) || function(m, exports) {
+  for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+`;
 function getESBuildEntry(opts) {
-    return `
+  return `
 (function() {
 /******/   "use strict";
 /******/   var __webpack_modules__ = ({});
@@ -266,8 +300,9 @@ function getESBuildEntry(opts) {
 var __webpack_exports__ = {};
 (function() {
   var exports = __webpack_exports__;
+${ES_INTEROP_HELPER}
   var moduleMap = {
-${opts.deps.map(getDepModuleStr).join(',\n')}
+${opts.deps.map(getDepModuleStr).join(",\n")}
   };
   var get = function(module, getScope) {
     __webpack_require__.R = getScope;
@@ -293,23 +328,24 @@ ${opts.deps.map(getDepModuleStr).join(',\n')}
     get: function() { return get; },
     init: function() { return init; }
   });
-  self.mf = __webpack_exports__;
+  self.${opts.mfName} = __webpack_exports__;
 })();
 })();
   `;
 }
-exports.getESBuildEntry = getESBuildEntry;
-function normalizeFile(file) {
-    return file.replace(/\//g, '_');
-}
 function getDepModuleStr(dep) {
-    return `
+  return `
 "./${dep.file}": function() {
   return new Promise(resolve => {
-    import('./${constants_1.MF_VA_PREFIX}${normalizeFile(dep.file)}.js').then(module => {
-      resolve(() => module);
+    import('./${import_constants.MF_VA_PREFIX}${dep.normalizedFile}.js').then(module => {
+      module.default && ${ES_INTEROP_FUNC}(module, module.default);
+      resolve(() => module.default || module);
     });
   })
 }
   `.trim();
 }
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getESBuildEntry
+});

package/dist/depInfo.d.ts

@@ -1,18 +1,32 @@
-import { MFSU } from './mfsu';
+import { MFSU } from './mfsu/mfsu';
 import { ModuleGraph } from './moduleGraph';
 interface IOpts {
     mfsu: MFSU;
 }
-export declare class DepInfo {
+export declare type DepModule = {
+    file: string;
+    version: string;
+    importer?: string;
+};
+export interface IDepInfo {
+    shouldBuild(): string | boolean;
+    snapshot(): void;
+    loadCache(): void;
+    writeCache(): void;
+    getCacheFilePath(): string;
+    getDepModules(): Record<string, DepModule>;
+}
+export declare class DepInfo implements IDepInfo {
     private opts;
-    cacheFilePath: string;
+    private readonly cacheFilePath;
     moduleGraph: ModuleGraph;
-    cacheDependency: object;
+    private cacheDependency;
     constructor(opts: IOpts);
-    shouldBuild(): boolean;
+    shouldBuild(): false | "cacheDependency has changed" | "moduleGraph has changed";
     snapshot(): void;
     loadCache(): void;
     writeCache(): void;
+    getDepModules(): Record<string, DepModule>;
+    getCacheFilePath(): string;
 }
 export {};
-//# sourceMappingURL=depInfo.d.ts.map