@module-federation/modern-js 0.14.2 → 0.15.0

package/dist/cjs/utils/dataFetch.js

@@ -0,0 +1,211 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var dataFetch_exports = {};
+__export(dataFetch_exports, {
+  fetchData: () => fetchData,
+  flushDataFetch: () => flushDataFetch,
+  getDataFetchIdWithErrorMsgs: () => getDataFetchIdWithErrorMsgs,
+  getDataFetchInfo: () => getDataFetchInfo,
+  getDataFetchItem: () => getDataFetchItem,
+  getDataFetchMap: () => getDataFetchMap,
+  getDataFetchMapKey: () => getDataFetchMapKey,
+  initDataFetchMap: () => initDataFetchMap,
+  isDataLoaderExpose: () => isDataLoaderExpose,
+  loadDataFetchModule: () => loadDataFetchModule,
+  setDataFetchItemLoadedStatus: () => setDataFetchItemLoadedStatus,
+  wrapDataFetchId: () => wrapDataFetchId
+});
+module.exports = __toCommonJS(dataFetch_exports);
+var import_sdk = require("@module-federation/sdk");
+var import_utils = require("../utils");
+var import_logger = __toESM(require("../logger"));
+var import_downgrade = require("../ssr-runtime/downgrade");
+var import_constant = require("../constant");
+var import_constant2 = require("@module-federation/rsbuild-plugin/constant");
+const getDataFetchInfo = ({ name, alias, id, remoteSnapshot }) => {
+  if (!remoteSnapshot) {
+    return;
+  }
+  if (!("modules" in remoteSnapshot)) {
+    return;
+  }
+  const regex = new RegExp(`^${name}(/[^/].*|)$`);
+  const nameOrAlias = regex.test(id) ? name : alias || name;
+  const expose = id.replace(nameOrAlias, "");
+  let dataFetchName = "";
+  let dataFetchId = "";
+  if (expose.startsWith("/")) {
+    dataFetchName = `${expose.slice(1)}.${import_constant2.DATA_FETCH_IDENTIFIER}`;
+    dataFetchId = `${id}.${import_constant2.DATA_FETCH_IDENTIFIER}`;
+  } else if (expose === "") {
+    dataFetchName = import_constant2.DATA_FETCH_IDENTIFIER;
+    dataFetchId = `${id}/${import_constant2.DATA_FETCH_IDENTIFIER}`;
+  } else {
+    return;
+  }
+  if (!dataFetchName || !dataFetchId) {
+    return;
+  }
+  if (!remoteSnapshot.modules.find((module2) => module2.moduleName === dataFetchName)) {
+    return;
+  }
+  return {
+    dataFetchName,
+    dataFetchId
+  };
+};
+function initDataFetchMap() {
+  var _globalThis;
+  (_globalThis = globalThis).__MF_DATA_FETCH_MAP__ || (_globalThis.__MF_DATA_FETCH_MAP__ = {});
+}
+function getDataFetchItem(id) {
+  var _globalThis___MF_DATA_FETCH_MAP__;
+  return (_globalThis___MF_DATA_FETCH_MAP__ = globalThis.__MF_DATA_FETCH_MAP__) === null || _globalThis___MF_DATA_FETCH_MAP__ === void 0 ? void 0 : _globalThis___MF_DATA_FETCH_MAP__[id];
+}
+function getDataFetchMap() {
+  return globalThis.__MF_DATA_FETCH_MAP__;
+}
+const flushDataFetch = () => {
+  globalThis.__MF_DATA_FETCH_MAP__ = {};
+  globalThis[import_constant.DOWNGRADE_KEY] = void 0;
+};
+function setDataFetchItemLoadedStatus(id) {
+  const dataFetchItem = getDataFetchItem(id);
+  if (!dataFetchItem) {
+    return;
+  }
+  dataFetchItem[2] = import_constant.MF_DATA_FETCH_STATUS.LOADED;
+}
+const wrapDataFetchId = (id) => {
+  return `${import_constant.WRAP_DATA_FETCH_ID_IDENTIFIER}${id}${import_constant.WRAP_DATA_FETCH_ID_IDENTIFIER}`;
+};
+const getDataFetchIdWithErrorMsgs = (errMsgs) => {
+  const firstIdentifierIndex = errMsgs.indexOf(import_constant.WRAP_DATA_FETCH_ID_IDENTIFIER);
+  if (firstIdentifierIndex === -1) {
+    return void 0;
+  }
+  const secondIdentifierIndex = errMsgs.indexOf(import_constant.WRAP_DATA_FETCH_ID_IDENTIFIER, firstIdentifierIndex + import_constant.WRAP_DATA_FETCH_ID_IDENTIFIER.length);
+  if (secondIdentifierIndex === -1) {
+    return void 0;
+  }
+  return errMsgs.substring(firstIdentifierIndex + import_constant.WRAP_DATA_FETCH_ID_IDENTIFIER.length, secondIdentifierIndex);
+};
+async function fetchData(id, params, remoteInfo) {
+  const callFetchData = async () => {
+    const item = getDataFetchItem(id);
+    if (!item) {
+      return;
+    }
+    const [fetchDataFnArr, ..._rest] = item;
+    const fetchDataFn = await fetchDataFnArr[2];
+    if (!fetchDataFn) {
+      return;
+    }
+    return fetchDataFn(params);
+  };
+  if ((0, import_sdk.isBrowserEnv)()) {
+    var _dataFetchItem_;
+    const dataFetchItem = getDataFetchItem(id);
+    if (!dataFetchItem) {
+      throw new Error(`dataFetchItem not found, id: ${id}`);
+    }
+    if ((_dataFetchItem_ = dataFetchItem[1]) === null || _dataFetchItem_ === void 0 ? void 0 : _dataFetchItem_[0]) {
+      return dataFetchItem[1][0];
+    }
+    if ((0, import_utils.isCSROnly)()) {
+      import_logger.default.debug("==========csr only!");
+      return callFetchData();
+    }
+    if (remoteInfo) {
+      return (0, import_downgrade.callDowngrade)(id, params, remoteInfo);
+    }
+    const mfDowngrade = (0, import_downgrade.getDowngradeTag)();
+    if (mfDowngrade) {
+      if (typeof mfDowngrade === "boolean") {
+        return (0, import_downgrade.callDowngrade)(id, {
+          ...params,
+          isDowngrade: true
+        });
+      }
+      if (mfDowngrade.includes(id)) {
+        return (0, import_downgrade.callDowngrade)(id, {
+          ...params,
+          isDowngrade: true
+        });
+      }
+    }
+    let res;
+    let rej;
+    const p = new Promise((resolve, reject) => {
+      res = resolve;
+      rej = reject;
+    });
+    dataFetchItem[1] = [
+      p,
+      res,
+      rej
+    ];
+    dataFetchItem[2] = import_constant.MF_DATA_FETCH_STATUS.AWAIT;
+    return dataFetchItem[1][0];
+  }
+  return callFetchData();
+}
+function getDataFetchMapKey(dataFetchInfo, hostInfo) {
+  if (!dataFetchInfo || !hostInfo) {
+    return;
+  }
+  const { dataFetchId } = dataFetchInfo;
+  return (0, import_sdk.composeKeyWithSeparator)(dataFetchId, hostInfo.name, hostInfo.version);
+}
+async function loadDataFetchModule(instance, id) {
+  return instance.loadRemote(id).then((m) => {
+    if (m && typeof m === "object" && "fetchData" in m && typeof m.fetchData === "function") {
+      return m.fetchData;
+    }
+    throw new Error(`fetchData not found in remote ${id}, ${JSON.stringify(m)}`);
+  });
+}
+function isDataLoaderExpose(exposeKey) {
+  return exposeKey.endsWith(import_constant2.DATA_FETCH_IDENTIFIER) || exposeKey.endsWith(import_constant2.DATA_FETCH_CLIENT_SUFFIX);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  fetchData,
+  flushDataFetch,
+  getDataFetchIdWithErrorMsgs,
+  getDataFetchInfo,
+  getDataFetchItem,
+  getDataFetchMap,
+  getDataFetchMapKey,
+  initDataFetchMap,
+  isDataLoaderExpose,
+  loadDataFetchModule,
+  setDataFetchItemLoadedStatus,
+  wrapDataFetchId
+});

package/dist/cjs/utils/index.js

@@ -0,0 +1,54 @@
+"use strict";
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var utils_exports = {};
+__export(utils_exports, {
+  getLoadedRemoteInfos: () => getLoadedRemoteInfos,
+  isCSROnly: () => isCSROnly
+});
+module.exports = __toCommonJS(utils_exports);
+__reExport(utils_exports, require("./dataFetch"), module.exports);
+function getLoadedRemoteInfos(id, instance) {
+  if (!instance) {
+    return;
+  }
+  const { name, expose } = instance.remoteHandler.idToRemoteMap[id] || {};
+  if (!name) {
+    return;
+  }
+  const module2 = instance.moduleCache.get(name);
+  if (!module2) {
+    return;
+  }
+  const { remoteSnapshot } = instance.snapshotHandler.getGlobalRemoteInfo(module2.remoteInfo);
+  return {
+    ...module2.remoteInfo,
+    snapshot: remoteSnapshot,
+    expose
+  };
+}
+function isCSROnly() {
+  return window._SSR_DATA === void 0;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getLoadedRemoteInfos,
+  isCSROnly,
+  ...require("./dataFetch")
+});

package/dist/esm/cli/configPlugin.js

@@ -0,0 +1,388 @@
+import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _object_spread } from "@swc/helpers/_/_object_spread";
+import { _ as _object_spread_props } from "@swc/helpers/_/_object_spread_props";
+import { _ as _to_consumable_array } from "@swc/helpers/_/_to_consumable_array";
+import { _ as _type_of } from "@swc/helpers/_/_type_of";
+import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
+import path from "path";
+import { getIPV4, isWebTarget, skipByTarget } from "./utils";
+import { encodeName } from "@module-federation/sdk";
+import { bundle } from "@modern-js/node-bundle-require";
+import { LOCALHOST, PLUGIN_IDENTIFIER } from "../constant";
+import { autoDeleteSplitChunkCacheGroups, addDataFetchExposes } from "@module-federation/rsbuild-plugin/utils";
+import logger from "../logger";
+import { isDev } from "./utils";
+var defaultPath = path.resolve(process.cwd(), "module-federation.config.ts");
+function setEnv(enableSSR) {
+  if (enableSSR) {
+    process.env["MF_DISABLE_EMIT_STATS"] = "true";
+    process.env["MF_SSR_PRJ"] = "true";
+  }
+}
+var getMFConfig = function() {
+  var _ref = _async_to_generator(function(userConfig) {
+    var config, configPath, mfConfigPath, preBundlePath, mfConfig;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          config = userConfig.config, configPath = userConfig.configPath;
+          if (config) {
+            return [
+              2,
+              config
+            ];
+          }
+          mfConfigPath = configPath ? configPath : defaultPath;
+          return [
+            4,
+            bundle(mfConfigPath)
+          ];
+        case 1:
+          preBundlePath = _state.sent();
+          return [
+            4,
+            import(preBundlePath)
+          ];
+        case 2:
+          mfConfig = _state.sent().default;
+          return [
+            2,
+            mfConfig
+          ];
+      }
+    });
+  });
+  return function getMFConfig2(userConfig) {
+    return _ref.apply(this, arguments);
+  };
+}();
+var injectRuntimePlugins = function(runtimePlugin, runtimePlugins) {
+  if (!runtimePlugins.includes(runtimePlugin)) {
+    runtimePlugins.push(runtimePlugin);
+  }
+};
+var replaceRemoteUrl = function(mfConfig, remoteIpStrategy) {
+  if (remoteIpStrategy && remoteIpStrategy === "inherit") {
+    return;
+  }
+  if (!mfConfig.remotes) {
+    return;
+  }
+  var ipv4 = getIPV4();
+  var handleRemoteObject = function(remoteObject) {
+    Object.keys(remoteObject).forEach(function(remoteKey) {
+      var remote = remoteObject[remoteKey];
+      if (Array.isArray(remote)) {
+        return;
+      }
+      if (typeof remote === "string" && remote.includes(LOCALHOST)) {
+        remoteObject[remoteKey] = remote.replace(LOCALHOST, ipv4);
+      }
+      if ((typeof remote === "undefined" ? "undefined" : _type_of(remote)) === "object" && !Array.isArray(remote.external) && remote.external.includes(LOCALHOST)) {
+        remote.external = remote.external.replace(LOCALHOST, ipv4);
+      }
+    });
+  };
+  if (Array.isArray(mfConfig.remotes)) {
+    mfConfig.remotes.forEach(function(remoteObject) {
+      if (typeof remoteObject === "string") {
+        return;
+      }
+      handleRemoteObject(remoteObject);
+    });
+  } else if (typeof mfConfig.remotes !== "string") {
+    handleRemoteObject(mfConfig.remotes);
+  }
+};
+var patchDTSConfig = function(mfConfig, isServer) {
+  if (isServer) {
+    return;
+  }
+  var ModernJSRuntime = "@module-federation/modern-js/runtime";
+  if (mfConfig.dts !== false) {
+    var _mfConfig_dts, _mfConfig_dts1;
+    if (typeof mfConfig.dts === "boolean" || mfConfig.dts === void 0) {
+      mfConfig.dts = {
+        consumeTypes: {
+          runtimePkgs: [
+            ModernJSRuntime
+          ]
+        }
+      };
+    } else if (((_mfConfig_dts = mfConfig.dts) === null || _mfConfig_dts === void 0 ? void 0 : _mfConfig_dts.consumeTypes) || ((_mfConfig_dts1 = mfConfig.dts) === null || _mfConfig_dts1 === void 0 ? void 0 : _mfConfig_dts1.consumeTypes) === void 0) {
+      var _mfConfig_dts2;
+      if (typeof mfConfig.dts.consumeTypes === "boolean" || ((_mfConfig_dts2 = mfConfig.dts) === null || _mfConfig_dts2 === void 0 ? void 0 : _mfConfig_dts2.consumeTypes) === void 0) {
+        mfConfig.dts.consumeTypes = {
+          runtimePkgs: [
+            ModernJSRuntime
+          ]
+        };
+      } else {
+        mfConfig.dts.consumeTypes.runtimePkgs = mfConfig.dts.consumeTypes.runtimePkgs || [];
+        if (!mfConfig.dts.consumeTypes.runtimePkgs.includes(ModernJSRuntime)) {
+          mfConfig.dts.consumeTypes.runtimePkgs.push(ModernJSRuntime);
+        }
+      }
+    }
+  }
+};
+var patchMFConfig = function(mfConfig, isServer, remoteIpStrategy, enableSSR) {
+  replaceRemoteUrl(mfConfig, remoteIpStrategy);
+  addDataFetchExposes(mfConfig.exposes, isServer);
+  if (mfConfig.remoteType === void 0) {
+    mfConfig.remoteType = "script";
+  }
+  if (!mfConfig.name) {
+    throw new Error("".concat(PLUGIN_IDENTIFIER, " mfConfig.name can not be empty!"));
+  }
+  var runtimePlugins = _to_consumable_array(mfConfig.runtimePlugins || []);
+  patchDTSConfig(mfConfig, isServer);
+  injectRuntimePlugins(require.resolve("@module-federation/modern-js/shared-strategy"), runtimePlugins);
+  injectRuntimePlugins(require.resolve("@module-federation/modern-js/auto-fetch-data"), runtimePlugins);
+  if (enableSSR && isDev()) {
+    injectRuntimePlugins(require.resolve("@module-federation/modern-js/resolve-entry-ipv4"), runtimePlugins);
+  }
+  if (isServer) {
+    injectRuntimePlugins(require.resolve("@module-federation/node/runtimePlugin"), runtimePlugins);
+    if (isDev()) {
+      injectRuntimePlugins(require.resolve("@module-federation/node/record-dynamic-remote-entry-hash-plugin"), runtimePlugins);
+    }
+    injectRuntimePlugins(require.resolve("@module-federation/modern-js/inject-node-fetch"), runtimePlugins);
+    if (!mfConfig.library) {
+      mfConfig.library = {
+        type: "commonjs-module",
+        name: mfConfig.name
+      };
+    } else {
+      if (!mfConfig.library.type) {
+        mfConfig.library.type = "commonjs-module";
+      }
+      if (!mfConfig.library.name) {
+        mfConfig.library.name = mfConfig.name;
+      }
+    }
+  }
+  mfConfig.runtimePlugins = runtimePlugins;
+  if (!isServer) {
+    var _mfConfig_library;
+    if (((_mfConfig_library = mfConfig.library) === null || _mfConfig_library === void 0 ? void 0 : _mfConfig_library.type) === "commonjs-module") {
+      mfConfig.library.type = "global";
+    }
+    return mfConfig;
+  }
+  mfConfig.dts = false;
+  mfConfig.dev = false;
+  return mfConfig;
+};
+function patchIgnoreWarning(chain) {
+  var ignoreWarnings = chain.get("ignoreWarnings") || [];
+  var ignoredMsgs = [
+    "external script",
+    "process.env.WS_NO_BUFFER_UTIL",
+    "Can't resolve 'utf-8-validate"
+  ];
+  ignoreWarnings.push(function(warning) {
+    if (ignoredMsgs.some(function(msg) {
+      return warning.message.includes(msg);
+    })) {
+      return true;
+    }
+    return false;
+  });
+  chain.ignoreWarnings(ignoreWarnings);
+}
+function addMyTypes2Ignored(chain, mfConfig) {
+  var watchOptions = chain.get("watchOptions");
+  if (!watchOptions || !watchOptions.ignored) {
+    chain.watchOptions({
+      ignored: /[\\/](?:\.git|node_modules|@mf-types)[\\/]/
+    });
+    return;
+  }
+  var ignored = watchOptions.ignored;
+  var DEFAULT_IGNORED_GLOB = "**/@mf-types/**";
+  if (Array.isArray(ignored)) {
+    if (mfConfig.dts !== false && _type_of(mfConfig.dts) === "object" && _type_of(mfConfig.dts.consumeTypes) === "object" && mfConfig.dts.consumeTypes.remoteTypesFolder) {
+      chain.watchOptions(_object_spread_props(_object_spread({}, watchOptions), {
+        ignored: ignored.concat("**/".concat(mfConfig.dts.consumeTypes.remoteTypesFolder, "/**"))
+      }));
+    } else {
+      chain.watchOptions(_object_spread_props(_object_spread({}, watchOptions), {
+        ignored: ignored.concat(DEFAULT_IGNORED_GLOB)
+      }));
+    }
+    return;
+  }
+  if (typeof ignored !== "string") {
+    chain.watchOptions(_object_spread_props(_object_spread({}, watchOptions), {
+      ignored: /[\\/](?:\.git|node_modules|@mf-types)[\\/]/
+    }));
+    return;
+  }
+  chain.watchOptions(_object_spread_props(_object_spread({}, watchOptions), {
+    ignored: ignored.concat(DEFAULT_IGNORED_GLOB)
+  }));
+}
+function patchBundlerConfig(options) {
+  var _modernjsConfig_deploy;
+  var chain = options.chain, modernjsConfig = options.modernjsConfig, isServer = options.isServer, mfConfig = options.mfConfig, enableSSR = options.enableSSR;
+  chain.optimization.delete("runtimeChunk");
+  patchIgnoreWarning(chain);
+  if (!chain.output.get("chunkLoadingGlobal")) {
+    chain.output.chunkLoadingGlobal("chunk_".concat(mfConfig.name));
+  }
+  if (!chain.output.get("uniqueName")) {
+    chain.output.uniqueName(mfConfig.name);
+  }
+  var splitChunkConfig = chain.optimization.splitChunks.entries();
+  if (!isServer) {
+    autoDeleteSplitChunkCacheGroups(mfConfig, splitChunkConfig);
+  }
+  if (!isServer && enableSSR && splitChunkConfig && (typeof splitChunkConfig === "undefined" ? "undefined" : _type_of(splitChunkConfig)) === "object" && splitChunkConfig.cacheGroups) {
+    splitChunkConfig.chunks = "async";
+    logger.warn('splitChunks.chunks = async is not allowed with stream SSR mode, it will auto changed to "async"');
+  }
+  if (isDev() && chain.output.get("publicPath") === "auto") {
+    var _modernjsConfig_dev, _modernjsConfig_server;
+    var port = ((_modernjsConfig_dev = modernjsConfig.dev) === null || _modernjsConfig_dev === void 0 ? void 0 : _modernjsConfig_dev.port) || ((_modernjsConfig_server = modernjsConfig.server) === null || _modernjsConfig_server === void 0 ? void 0 : _modernjsConfig_server.port) || 8080;
+    var publicPath = "http://localhost:".concat(port, "/");
+    chain.output.publicPath(publicPath);
+  }
+  if (isServer && enableSSR) {
+    var uniqueName = mfConfig.name || chain.output.get("uniqueName");
+    var chunkFileName = chain.output.get("chunkFilename");
+    if (typeof chunkFileName === "string" && uniqueName && !chunkFileName.includes(uniqueName)) {
+      var suffix = "".concat(encodeName(uniqueName), "-[chunkhash].js");
+      chain.output.chunkFilename(chunkFileName.replace(".js", suffix));
+    }
+  }
+  if (isDev() && enableSSR && !isServer) {
+    chain.resolve.fallback.set("crypto", false).set("stream", false).set("vm", false);
+  }
+  if (((_modernjsConfig_deploy = modernjsConfig.deploy) === null || _modernjsConfig_deploy === void 0 ? void 0 : _modernjsConfig_deploy.microFrontend) && Object.keys(mfConfig.exposes || {}).length) {
+    chain.optimization.usedExports(false);
+  }
+}
+var moduleFederationConfigPlugin = function(userConfig) {
+  return {
+    name: "@modern-js/plugin-module-federation-config",
+    pre: [
+      "@modern-js/plugin-initialize"
+    ],
+    post: [
+      "@modern-js/plugin-module-federation"
+    ],
+    setup: function() {
+      var _ref = _async_to_generator(function(api) {
+        var _userConfig_userConfig, _modernjsConfig_server, modernjsConfig, mfConfig, csrConfig, ssrConfig, _userConfig_userConfig_ssr, enableSSR;
+        return _ts_generator(this, function(_state) {
+          switch (_state.label) {
+            case 0:
+              modernjsConfig = api.getConfig();
+              return [
+                4,
+                getMFConfig(userConfig.originPluginOptions)
+              ];
+            case 1:
+              mfConfig = _state.sent();
+              csrConfig = userConfig.csrConfig || JSON.parse(JSON.stringify(mfConfig));
+              ssrConfig = userConfig.ssrConfig || JSON.parse(JSON.stringify(mfConfig));
+              userConfig.ssrConfig = ssrConfig;
+              userConfig.csrConfig = csrConfig;
+              enableSSR = Boolean((_userConfig_userConfig_ssr = (_userConfig_userConfig = userConfig.userConfig) === null || _userConfig_userConfig === void 0 ? void 0 : _userConfig_userConfig.ssr) !== null && _userConfig_userConfig_ssr !== void 0 ? _userConfig_userConfig_ssr : Boolean(modernjsConfig === null || modernjsConfig === void 0 ? void 0 : (_modernjsConfig_server = modernjsConfig.server) === null || _modernjsConfig_server === void 0 ? void 0 : _modernjsConfig_server.ssr));
+              api.modifyBundlerChain(function(chain) {
+                var target = chain.get("target");
+                if (skipByTarget(target)) {
+                  return;
+                }
+                var isWeb = isWebTarget(target);
+                addMyTypes2Ignored(chain, !isWeb ? ssrConfig : csrConfig);
+                var targetMFConfig = !isWeb ? ssrConfig : csrConfig;
+                patchMFConfig(targetMFConfig, !isWeb, userConfig.remoteIpStrategy || "ipv4", enableSSR);
+                patchBundlerConfig({
+                  chain,
+                  isServer: !isWeb,
+                  modernjsConfig,
+                  mfConfig,
+                  enableSSR
+                });
+                userConfig.distOutputDir = chain.output.get("path") || path.resolve(process.cwd(), "dist");
+              });
+              api.config(function() {
+                var _modernjsConfig_tools, _userConfig_csrConfig, _modernjsConfig_source, _modernjsConfig_source1, _modernjsConfig_dev;
+                var bundlerType = api.getAppContext().bundlerType === "rspack" ? "rspack" : "webpack";
+                var ipv4 = getIPV4();
+                if (userConfig.remoteIpStrategy === void 0) {
+                  if (!enableSSR) {
+                    userConfig.remoteIpStrategy = "inherit";
+                  } else {
+                    userConfig.remoteIpStrategy = "ipv4";
+                  }
+                }
+                var devServerConfig = (_modernjsConfig_tools = modernjsConfig.tools) === null || _modernjsConfig_tools === void 0 ? void 0 : _modernjsConfig_tools.devServer;
+                var corsWarnMsgs = [
+                  "View https://module-federation.io/guide/troubleshooting/other.html#cors-warn for more details."
+                ];
+                if ((typeof devServerConfig === "undefined" ? "undefined" : _type_of(devServerConfig)) !== "object" || !("headers" in devServerConfig)) {
+                  corsWarnMsgs.unshift('Detect devServer.headers is empty, mf modern plugin will add default cors header: devServer.headers["Access-Control-Allow-Headers"] = "*". It is recommended to specify an allowlist of trusted origins instead.');
+                }
+                var exposes = (_userConfig_csrConfig = userConfig.csrConfig) === null || _userConfig_csrConfig === void 0 ? void 0 : _userConfig_csrConfig.exposes;
+                var hasExposes = exposes && Array.isArray(exposes) ? exposes.length : Object.keys(exposes !== null && exposes !== void 0 ? exposes : {}).length;
+                if (corsWarnMsgs.length > 1 && hasExposes) {
+                  logger.warn(corsWarnMsgs.join("\n"));
+                }
+                var corsHeaders = hasExposes ? {
+                  "Access-Control-Allow-Origin": "*",
+                  "Access-Control-Allow-Methods": "GET, POST, PUT, DELETE, PATCH, OPTIONS",
+                  "Access-Control-Allow-Headers": "*"
+                } : void 0;
+                var defineConfig = {
+                  REMOTE_IP_STRATEGY: JSON.stringify(userConfig.remoteIpStrategy)
+                };
+                if (enableSSR && isDev()) {
+                  defineConfig["FEDERATION_IPV4"] = JSON.stringify(ipv4);
+                }
+                var _modernjsConfig_source_enableAsyncEntry;
+                return {
+                  tools: {
+                    devServer: {
+                      headers: corsHeaders
+                    }
+                  },
+                  source: {
+                    alias: {
+                      // TODO: deprecated
+                      "@modern-js/runtime/mf": require.resolve("@module-federation/modern-js/runtime")
+                    },
+                    define: defineConfig,
+                    enableAsyncEntry: bundlerType === "rspack" ? (_modernjsConfig_source_enableAsyncEntry = (_modernjsConfig_source = modernjsConfig.source) === null || _modernjsConfig_source === void 0 ? void 0 : _modernjsConfig_source.enableAsyncEntry) !== null && _modernjsConfig_source_enableAsyncEntry !== void 0 ? _modernjsConfig_source_enableAsyncEntry : true : (_modernjsConfig_source1 = modernjsConfig.source) === null || _modernjsConfig_source1 === void 0 ? void 0 : _modernjsConfig_source1.enableAsyncEntry
+                  },
+                  dev: {
+                    assetPrefix: (modernjsConfig === null || modernjsConfig === void 0 ? void 0 : (_modernjsConfig_dev = modernjsConfig.dev) === null || _modernjsConfig_dev === void 0 ? void 0 : _modernjsConfig_dev.assetPrefix) ? modernjsConfig.dev.assetPrefix : true
+                  }
+                };
+              });
+              return [
+                2
+              ];
+          }
+        });
+      });
+      return function(api) {
+        return _ref.apply(this, arguments);
+      };
+    }()
+  };
+};
+var configPlugin_default = moduleFederationConfigPlugin;
+export {
+  addMyTypes2Ignored,
+  configPlugin_default as default,
+  getMFConfig,
+  isWebTarget,
+  moduleFederationConfigPlugin,
+  patchBundlerConfig,
+  patchMFConfig,
+  setEnv,
+  skipByTarget
+};