@umijs/mfsu 4.0.0-canary.20220718.2 → 4.0.0-canary.20220720.1

package/dist/mfsu/mfsu.js

@@ -1,179 +1,163 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
     }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
+  return a;
 };
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MFSU = void 0;
-const bundler_utils_1 = require("@umijs/bundler-utils");
-const utils_1 = require("@umijs/utils");
-const assert_1 = __importDefault(require("assert"));
-const fs_1 = require("fs");
-const path_1 = require("path");
-const mrmime_1 = require("../../compiled/mrmime");
-// @ts-ignore
-const webpack_virtual_modules_1 = __importDefault(require("../../compiled/webpack-virtual-modules"));
-const constants_1 = require("../constants");
-const dep_1 = require("../dep/dep");
-const depBuilder_1 = require("../depBuilder/depBuilder");
-const awaitImport_1 = __importStar(require("../esbuildHandlers/awaitImport"));
-const types_1 = require("../types");
-const makeArray_1 = require("../utils/makeArray");
-const buildDepPlugin_1 = require("../webpackPlugins/buildDepPlugin");
-const strategyCompileTime_1 = require("./strategyCompileTime");
-const strategyStaticAnalyze_1 = require("./strategyStaticAnalyze");
-class MFSU {
-    constructor(opts) {
-        this.alias = {};
-        this.externals = [];
-        this.depConfig = null;
-        this.buildDepsAgain = false;
-        this.progress = { done: false };
-        this.publicPath = '/';
-        this.opts = opts;
-        this.opts.mfName = this.opts.mfName || constants_1.DEFAULT_MF_NAME;
-        this.opts.tmpBase =
-            this.opts.tmpBase || (0, path_1.join)(process.cwd(), constants_1.DEFAULT_TMP_DIR_NAME);
-        this.opts.mode = this.opts.mode || types_1.Mode.development;
-        this.opts.getCacheDependency = this.opts.getCacheDependency || (() => ({}));
-        this.onProgress = (progress) => {
-            var _a, _b;
-            this.progress = {
-                ...this.progress,
-                ...progress,
-            };
-            (_b = (_a = this.opts).onMFSUProgress) === null || _b === void 0 ? void 0 : _b.call(_a, this.progress);
-        };
-        this.opts.cwd = this.opts.cwd || process.cwd();
-        if (this.opts.strategy === 'eager') {
-            if (opts.srcCodeCache) {
-                utils_1.logger.info('MFSU eager strategy enabled');
-                this.strategy = new strategyStaticAnalyze_1.StaticAnalyzeStrategy({
-                    mfsu: this,
-                    srcCodeCache: opts.srcCodeCache,
-                });
-            }
-            else {
-                utils_1.logger.warn('fallback to MFSU normal strategy, due to srcCache is not provided');
-                this.strategy = new strategyCompileTime_1.StrategyCompileTime({ mfsu: this });
-            }
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, mod));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// mfsu.ts
+var mfsu_exports = {};
+__export(mfsu_exports, {
+  MFSU: () => MFSU
+});
+module.exports = __toCommonJS(mfsu_exports);
+var import_bundler_utils = require("@umijs/bundler-utils");
+var import_utils = require("@umijs/utils");
+var import_assert = __toESM(require("assert"));
+var import_fs = require("fs");
+var import_path = require("path");
+var import_mrmime = require("../../compiled/mrmime");
+var import_webpack_virtual_modules = __toESM(require("../../compiled/webpack-virtual-modules"));
+var import_constants = require("../constants");
+var import_dep = require("../dep/dep");
+var import_depBuilder = require("../depBuilder/depBuilder");
+var import_awaitImport = __toESM(require("../esbuildHandlers/awaitImport"));
+var import_types = require("../types");
+var import_makeArray = require("../utils/makeArray");
+var import_buildDepPlugin = require("../webpackPlugins/buildDepPlugin");
+var import_strategyCompileTime = require("./strategyCompileTime");
+var import_strategyStaticAnalyze = require("./strategyStaticAnalyze");
+var MFSU = class {
+  constructor(opts) {
+    this.alias = {};
+    this.externals = [];
+    this.depConfig = null;
+    this.buildDepsAgain = false;
+    this.progress = { done: false };
+    this.publicPath = "/";
+    this.opts = opts;
+    this.opts.mfName = this.opts.mfName || import_constants.DEFAULT_MF_NAME;
+    this.opts.tmpBase = this.opts.tmpBase || (0, import_path.join)(process.cwd(), import_constants.DEFAULT_TMP_DIR_NAME);
+    this.opts.mode = this.opts.mode || import_types.Mode.development;
+    this.opts.getCacheDependency = this.opts.getCacheDependency || (() => ({}));
+    this.onProgress = (progress) => {
+      var _a, _b;
+      this.progress = __spreadValues(__spreadValues({}, this.progress), progress);
+      (_b = (_a = this.opts).onMFSUProgress) == null ? void 0 : _b.call(_a, this.progress);
+    };
+    this.opts.cwd = this.opts.cwd || process.cwd();
+    if (this.opts.strategy === "eager") {
+      if (opts.srcCodeCache) {
+        import_utils.logger.info("MFSU eager strategy enabled");
+        this.strategy = new import_strategyStaticAnalyze.StaticAnalyzeStrategy({
+          mfsu: this,
+          srcCodeCache: opts.srcCodeCache
+        });
+      } else {
+        import_utils.logger.warn("fallback to MFSU normal strategy, due to srcCache is not provided");
+        this.strategy = new import_strategyCompileTime.StrategyCompileTime({ mfsu: this });
+      }
+    } else {
+      this.strategy = new import_strategyCompileTime.StrategyCompileTime({ mfsu: this });
+    }
+    this.strategy.loadCache();
+    this.depBuilder = new import_depBuilder.DepBuilder({ mfsu: this });
+  }
+  asyncImport(content) {
+    return `await import('${(0, import_utils.winPath)(content)}');`;
+  }
+  async setWebpackConfig(opts) {
+    var _a;
+    const { mfName } = this.opts;
+    Object.assign(this.alias, ((_a = opts.config.resolve) == null ? void 0 : _a.alias) || {});
+    this.externals.push(...(0, import_makeArray.makeArray)(opts.config.externals || []));
+    const entry = {};
+    const virtualModules = {};
+    const entryObject = import_utils.lodash.isString(opts.config.entry) ? { default: [opts.config.entry] } : opts.config.entry;
+    (0, import_assert.default)(import_utils.lodash.isPlainObject(entryObject), `webpack config 'entry' value must be a string or an object.`);
+    for (const key of Object.keys(entryObject)) {
+      const virtualPath = `./mfsu-virtual-entry/${key}.js`;
+      const virtualContent = [];
+      let index = 1;
+      let hasDefaultExport = false;
+      const entryFiles = import_utils.lodash.isArray(entryObject[key]) ? entryObject[key] : [entryObject[key]];
+      for (let entry2 of entryFiles) {
+        if ((0, import_fs.statSync)(entry2).isDirectory()) {
+          const realEntry = (0, import_utils.tryPaths)([
+            (0, import_path.join)(entry2, "index.tsx"),
+            (0, import_path.join)(entry2, "index.ts"),
+            (0, import_path.join)(entry2, "index.jsx"),
+            (0, import_path.join)(entry2, "index.js")
+          ]);
+          (0, import_assert.default)(realEntry, `entry file not found, please configure the specific entry path. (e.g. 'src/index.tsx')`);
+          entry2 = realEntry;
         }
-        else {
-            this.strategy = new strategyCompileTime_1.StrategyCompileTime({ mfsu: this });
+        const content = (0, import_fs.readFileSync)(entry2, "utf-8");
+        const [_imports, exports] = await (0, import_bundler_utils.parseModule)({ content, path: entry2 });
+        if (exports.length) {
+          virtualContent.push(`const k${index} = ${this.asyncImport(entry2)}`);
+          for (const exportName of exports) {
+            if (exportName === "default") {
+              hasDefaultExport = true;
+              virtualContent.push(`export default k${index}.${exportName}`);
+            } else {
+              virtualContent.push(`export const ${exportName} = k${index}.${exportName}`);
+            }
+          }
+        } else {
+          virtualContent.push(this.asyncImport(entry2));
         }
-        this.strategy.loadCache();
-        this.depBuilder = new depBuilder_1.DepBuilder({ mfsu: this });
+        index += 1;
+      }
+      if (!hasDefaultExport) {
+        virtualContent.push(`export default 1;`);
+      }
+      virtualModules[virtualPath] = virtualContent.join("\n");
+      entry[key] = virtualPath;
     }
-    // swc don't support top-level await
-    // ref: https://github.com/vercel/next.js/issues/31054
-    asyncImport(content) {
-        return `await import('${(0, utils_1.winPath)(content)}');`;
-        // return `(async () => await import('${content}'))();`;
+    opts.config.entry = entry;
+    opts.config.plugins = opts.config.plugins || [];
+    let publicPath = opts.config.output.publicPath;
+    if (publicPath === "auto") {
+      publicPath = "/";
     }
-    async setWebpackConfig(opts) {
-        var _a;
-        const { mfName } = this.opts;
-        /**
-         * config
-         */
-        // set alias and externals with reference for babel plugin
-        Object.assign(this.alias, ((_a = opts.config.resolve) === null || _a === void 0 ? void 0 : _a.alias) || {});
-        this.externals.push(...(0, makeArray_1.makeArray)(opts.config.externals || []));
-        // entry
-        const entry = {};
-        const virtualModules = {};
-        // ensure entry object type
-        const entryObject = utils_1.lodash.isString(opts.config.entry)
-            ? { default: [opts.config.entry] }
-            : opts.config.entry;
-        (0, assert_1.default)(utils_1.lodash.isPlainObject(entryObject), `webpack config 'entry' value must be a string or an object.`);
-        for (const key of Object.keys(entryObject)) {
-            const virtualPath = `./mfsu-virtual-entry/${key}.js`;
-            const virtualContent = [];
-            let index = 1;
-            let hasDefaultExport = false;
-            const entryFiles = utils_1.lodash.isArray(entryObject[key])
-                ? entryObject[key]
-                : [entryObject[key]];
-            for (let entry of entryFiles) {
-                // ensure entry is a file
-                if ((0, fs_1.statSync)(entry).isDirectory()) {
-                    const realEntry = (0, utils_1.tryPaths)([
-                        (0, path_1.join)(entry, 'index.tsx'),
-                        (0, path_1.join)(entry, 'index.ts'),
-                        (0, path_1.join)(entry, 'index.jsx'),
-                        (0, path_1.join)(entry, 'index.js'),
-                    ]);
-                    (0, assert_1.default)(realEntry, `entry file not found, please configure the specific entry path. (e.g. 'src/index.tsx')`);
-                    entry = realEntry;
-                }
-                const content = (0, fs_1.readFileSync)(entry, 'utf-8');
-                const [_imports, exports] = await (0, bundler_utils_1.parseModule)({ content, path: entry });
-                if (exports.length) {
-                    virtualContent.push(`const k${index} = ${this.asyncImport(entry)}`);
-                    for (const exportName of exports) {
-                        if (exportName === 'default') {
-                            hasDefaultExport = true;
-                            virtualContent.push(`export default k${index}.${exportName}`);
-                        }
-                        else {
-                            virtualContent.push(`export const ${exportName} = k${index}.${exportName}`);
-                        }
-                    }
-                }
-                else {
-                    virtualContent.push(this.asyncImport(entry));
-                }
-                index += 1;
-            }
-            if (!hasDefaultExport) {
-                virtualContent.push(`export default 1;`);
-            }
-            virtualModules[virtualPath] = virtualContent.join('\n');
-            entry[key] = virtualPath;
-        }
-        opts.config.entry = entry;
-        // plugins
-        opts.config.plugins = opts.config.plugins || [];
-        // support publicPath auto
-        let publicPath = opts.config.output.publicPath;
-        if (publicPath === 'auto') {
-            publicPath = '/';
-        }
-        this.publicPath = publicPath;
-        opts.config.plugins.push(...[
-            new webpack_virtual_modules_1.default(virtualModules),
-            new this.opts.implementor.container.ModuleFederationPlugin({
-                name: '__',
-                remotes: {
-                    [mfName]: this.opts.runtimePublicPath
-                        ? // ref:
-                            // https://webpack.js.org/concepts/module-federation/#promise-based-dynamic-remotes
-                            `
+    this.publicPath = publicPath;
+    opts.config.plugins.push(...[
+      new import_webpack_virtual_modules.default(virtualModules),
+      new this.opts.implementor.container.ModuleFederationPlugin({
+        name: "__",
+        remotes: {
+          [mfName]: this.opts.runtimePublicPath ? `
 promise new Promise(resolve => {
-  const remoteUrlWithVersion = (window.publicPath || '/') + '${constants_1.REMOTE_FILE_FULL}';
+  const remoteUrlWithVersion = (window.publicPath || '/') + '${import_constants.REMOTE_FILE_FULL}';
   const script = document.createElement('script');
   script.src = remoteUrlWithVersion;
   script.onload = () => {
@@ -194,97 +178,85 @@ promise new Promise(resolve => {
   // inject this script with the src set to the versioned remoteEntry.js
   document.head.appendChild(script);
 })
-                `.trimLeft()
-                        : `${mfName}@${publicPath}${constants_1.REMOTE_FILE_FULL}`,
-                },
-            }),
-            new buildDepPlugin_1.BuildDepPlugin(this.strategy.getBuildDepPlugConfig()),
-            // new WriteCachePlugin({
-            //   onWriteCache: lodash.debounce(() => {
-            //     this.depInfo.writeCache();
-            //   }, 300),
-            // }),
-        ]);
-        // ensure topLevelAwait enabled
-        utils_1.lodash.set(opts.config, 'experiments.topLevelAwait', true);
-        /**
-         * depConfig
-         */
-        this.depConfig = opts.depConfig;
-        this.strategy.init();
-    }
-    async buildDeps() {
-        const shouldBuild = this.strategy.shouldBuild();
-        if (!shouldBuild) {
-            utils_1.logger.info('[MFSU] skip buildDeps');
-            return;
-        }
-        // Snapshot after compiled success
-        this.strategy.refresh();
-        const staticDeps = this.strategy.getDepModules();
-        const deps = dep_1.Dep.buildDeps({
-            deps: staticDeps,
-            cwd: this.opts.cwd,
-            mfsu: this,
-        });
-        utils_1.logger.info(`[MFSU] buildDeps since ${shouldBuild}`);
-        utils_1.logger.debug(deps.map((dep) => dep.file).join(', '));
-        await this.depBuilder.build({
-            deps,
-        });
-        // Write cache
-        this.strategy.writeCache();
-        if (this.buildDepsAgain) {
-            utils_1.logger.info('[MFSU] buildDepsAgain');
-            this.buildDepsAgain = false;
-            this.buildDeps().catch((e) => {
-                utils_1.printHelp.runtime(e);
-            });
+                `.trimLeft() : `${mfName}@${publicPath}${import_constants.REMOTE_FILE_FULL}`
         }
+      }),
+      new import_buildDepPlugin.BuildDepPlugin(this.strategy.getBuildDepPlugConfig())
+    ]);
+    import_utils.lodash.set(opts.config, "experiments.topLevelAwait", true);
+    this.depConfig = opts.depConfig;
+    this.strategy.init();
+  }
+  async buildDeps() {
+    const shouldBuild = this.strategy.shouldBuild();
+    if (!shouldBuild) {
+      import_utils.logger.info("[MFSU] skip buildDeps");
+      return;
     }
-    getMiddlewares() {
-        return [
-            (req, res, next) => {
-                const publicPath = this.publicPath;
-                const isMF = req.path.startsWith(`${publicPath}${constants_1.MF_VA_PREFIX}`) ||
-                    req.path.startsWith(`${publicPath}${constants_1.MF_DEP_PREFIX}`) ||
-                    req.path.startsWith(`${publicPath}${constants_1.MF_STATIC_PREFIX}`);
-                if (isMF) {
-                    this.depBuilder.onBuildComplete(() => {
-                        if (!req.path.includes(constants_1.REMOTE_FILE)) {
-                            res.setHeader('cache-control', 'max-age=31536000,immutable');
-                        }
-                        res.setHeader('content-type', (0, mrmime_1.lookup)((0, path_1.extname)(req.path)) || 'text/plain');
-                        const relativePath = req.path.replace(new RegExp(`^${publicPath}`), '/');
-                        const content = (0, fs_1.readFileSync)((0, path_1.join)(this.opts.tmpBase, relativePath));
-                        res.send(content);
-                    });
-                }
-                else {
-                    next();
-                }
-            },
-        ];
-    }
-    getBabelPlugins() {
-        return [this.strategy.getBabelPlugin()];
+    this.strategy.refresh();
+    const staticDeps = this.strategy.getDepModules();
+    const deps = import_dep.Dep.buildDeps({
+      deps: staticDeps,
+      cwd: this.opts.cwd,
+      mfsu: this
+    });
+    import_utils.logger.info(`[MFSU] buildDeps since ${shouldBuild}`);
+    import_utils.logger.debug(deps.map((dep) => dep.file).join(", "));
+    await this.depBuilder.build({
+      deps
+    });
+    this.strategy.writeCache();
+    if (this.buildDepsAgain) {
+      import_utils.logger.info("[MFSU] buildDepsAgain");
+      this.buildDepsAgain = false;
+      this.buildDeps().catch((e) => {
+        import_utils.printHelp.runtime(e);
+      });
     }
-    getEsbuildLoaderHandler() {
-        if (this.opts.strategy === 'eager') {
-            const opts = this.strategy.getBabelPlugin()[1];
-            return [(0, awaitImport_1.getImportHandlerV4)(opts)];
+  }
+  getMiddlewares() {
+    return [
+      (req, res, next) => {
+        const publicPath = this.publicPath;
+        const isMF = req.path.startsWith(`${publicPath}${import_constants.MF_VA_PREFIX}`) || req.path.startsWith(`${publicPath}${import_constants.MF_DEP_PREFIX}`) || req.path.startsWith(`${publicPath}${import_constants.MF_STATIC_PREFIX}`);
+        if (isMF) {
+          this.depBuilder.onBuildComplete(() => {
+            if (!req.path.includes(import_constants.REMOTE_FILE)) {
+              res.setHeader("cache-control", "max-age=31536000,immutable");
+            }
+            res.setHeader("content-type", (0, import_mrmime.lookup)((0, import_path.extname)(req.path)) || "text/plain");
+            const relativePath = req.path.replace(new RegExp(`^${publicPath}`), "/");
+            const content = (0, import_fs.readFileSync)((0, import_path.join)(this.opts.tmpBase, relativePath));
+            res.send(content);
+          });
+        } else {
+          next();
         }
-        const cache = new Map();
-        const checkOpts = this.strategy.getBabelPlugin()[1];
-        return [
-            (0, awaitImport_1.default)({
-                cache,
-                opts: checkOpts,
-            }),
-        ];
-    }
-    getCacheFilePath() {
-        return this.strategy.getCacheFilePath();
+      }
+    ];
+  }
+  getBabelPlugins() {
+    return [this.strategy.getBabelPlugin()];
+  }
+  getEsbuildLoaderHandler() {
+    if (this.opts.strategy === "eager") {
+      const opts = this.strategy.getBabelPlugin()[1];
+      return [(0, import_awaitImport.getImportHandlerV4)(opts)];
     }
-}
-exports.MFSU = MFSU;
+    const cache = /* @__PURE__ */ new Map();
+    const checkOpts = this.strategy.getBabelPlugin()[1];
+    return [
+      (0, import_awaitImport.default)({
+        cache,
+        opts: checkOpts
+      })
+    ];
+  }
+  getCacheFilePath() {
+    return this.strategy.getCacheFilePath();
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MFSU
+});

package/dist/mfsu/strategyCompileTime.d.ts

@@ -18,4 +18,3 @@ export declare class StrategyCompileTime implements IMFSUStrategy {
     getBuildDepPlugConfig(): IBuildDepPluginOpts;
     private getAwaitImportCollectOpts;
 }
-//# sourceMappingURL=strategyCompileTime.d.ts.map