@module-federation/modern-js 0.14.2 → 0.15.0

package/dist/esm-node/cli/configPlugin.js

@@ -0,0 +1,340 @@
+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";
+const 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";
+  }
+}
+const getMFConfig = async (userConfig) => {
+  const { config, configPath } = userConfig;
+  if (config) {
+    return config;
+  }
+  const mfConfigPath = configPath ? configPath : defaultPath;
+  const preBundlePath = await bundle(mfConfigPath);
+  const mfConfig = (await import(preBundlePath)).default;
+  return mfConfig;
+};
+const injectRuntimePlugins = (runtimePlugin, runtimePlugins) => {
+  if (!runtimePlugins.includes(runtimePlugin)) {
+    runtimePlugins.push(runtimePlugin);
+  }
+};
+const replaceRemoteUrl = (mfConfig, remoteIpStrategy) => {
+  if (remoteIpStrategy && remoteIpStrategy === "inherit") {
+    return;
+  }
+  if (!mfConfig.remotes) {
+    return;
+  }
+  const ipv4 = getIPV4();
+  const handleRemoteObject = (remoteObject) => {
+    Object.keys(remoteObject).forEach((remoteKey) => {
+      const remote = remoteObject[remoteKey];
+      if (Array.isArray(remote)) {
+        return;
+      }
+      if (typeof remote === "string" && remote.includes(LOCALHOST)) {
+        remoteObject[remoteKey] = remote.replace(LOCALHOST, ipv4);
+      }
+      if (typeof 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((remoteObject) => {
+      if (typeof remoteObject === "string") {
+        return;
+      }
+      handleRemoteObject(remoteObject);
+    });
+  } else if (typeof mfConfig.remotes !== "string") {
+    handleRemoteObject(mfConfig.remotes);
+  }
+};
+const patchDTSConfig = (mfConfig, isServer) => {
+  if (isServer) {
+    return;
+  }
+  const 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);
+        }
+      }
+    }
+  }
+};
+const patchMFConfig = (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(`${PLUGIN_IDENTIFIER} mfConfig.name can not be empty!`);
+  }
+  const runtimePlugins = [
+    ...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) {
+  const ignoreWarnings = chain.get("ignoreWarnings") || [];
+  const ignoredMsgs = [
+    "external script",
+    "process.env.WS_NO_BUFFER_UTIL",
+    `Can't resolve 'utf-8-validate`
+  ];
+  ignoreWarnings.push((warning) => {
+    if (ignoredMsgs.some((msg) => warning.message.includes(msg))) {
+      return true;
+    }
+    return false;
+  });
+  chain.ignoreWarnings(ignoreWarnings);
+}
+function addMyTypes2Ignored(chain, mfConfig) {
+  const watchOptions = chain.get("watchOptions");
+  if (!watchOptions || !watchOptions.ignored) {
+    chain.watchOptions({
+      ignored: /[\\/](?:\.git|node_modules|@mf-types)[\\/]/
+    });
+    return;
+  }
+  const ignored = watchOptions.ignored;
+  const DEFAULT_IGNORED_GLOB = "**/@mf-types/**";
+  if (Array.isArray(ignored)) {
+    if (mfConfig.dts !== false && typeof mfConfig.dts === "object" && typeof mfConfig.dts.consumeTypes === "object" && mfConfig.dts.consumeTypes.remoteTypesFolder) {
+      chain.watchOptions({
+        ...watchOptions,
+        ignored: ignored.concat(`**/${mfConfig.dts.consumeTypes.remoteTypesFolder}/**`)
+      });
+    } else {
+      chain.watchOptions({
+        ...watchOptions,
+        ignored: ignored.concat(DEFAULT_IGNORED_GLOB)
+      });
+    }
+    return;
+  }
+  if (typeof ignored !== "string") {
+    chain.watchOptions({
+      ...watchOptions,
+      ignored: /[\\/](?:\.git|node_modules|@mf-types)[\\/]/
+    });
+    return;
+  }
+  chain.watchOptions({
+    ...watchOptions,
+    ignored: ignored.concat(DEFAULT_IGNORED_GLOB)
+  });
+}
+function patchBundlerConfig(options) {
+  var _modernjsConfig_deploy;
+  const { chain, modernjsConfig, isServer, mfConfig, enableSSR } = options;
+  chain.optimization.delete("runtimeChunk");
+  patchIgnoreWarning(chain);
+  if (!chain.output.get("chunkLoadingGlobal")) {
+    chain.output.chunkLoadingGlobal(`chunk_${mfConfig.name}`);
+  }
+  if (!chain.output.get("uniqueName")) {
+    chain.output.uniqueName(mfConfig.name);
+  }
+  const splitChunkConfig = chain.optimization.splitChunks.entries();
+  if (!isServer) {
+    autoDeleteSplitChunkCacheGroups(mfConfig, splitChunkConfig);
+  }
+  if (!isServer && enableSSR && splitChunkConfig && typeof 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;
+    const 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;
+    const publicPath = `http://localhost:${port}/`;
+    chain.output.publicPath(publicPath);
+  }
+  if (isServer && enableSSR) {
+    const uniqueName = mfConfig.name || chain.output.get("uniqueName");
+    const chunkFileName = chain.output.get("chunkFilename");
+    if (typeof chunkFileName === "string" && uniqueName && !chunkFileName.includes(uniqueName)) {
+      const suffix = `${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);
+  }
+}
+const moduleFederationConfigPlugin = (userConfig) => ({
+  name: "@modern-js/plugin-module-federation-config",
+  pre: [
+    "@modern-js/plugin-initialize"
+  ],
+  post: [
+    "@modern-js/plugin-module-federation"
+  ],
+  setup: async (api) => {
+    var _userConfig_userConfig, _modernjsConfig_server;
+    const modernjsConfig = api.getConfig();
+    const mfConfig = await getMFConfig(userConfig.originPluginOptions);
+    const csrConfig = userConfig.csrConfig || JSON.parse(JSON.stringify(mfConfig));
+    const ssrConfig = userConfig.ssrConfig || JSON.parse(JSON.stringify(mfConfig));
+    userConfig.ssrConfig = ssrConfig;
+    userConfig.csrConfig = csrConfig;
+    var _userConfig_userConfig_ssr;
+    const 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((chain) => {
+      const target = chain.get("target");
+      if (skipByTarget(target)) {
+        return;
+      }
+      const isWeb = isWebTarget(target);
+      addMyTypes2Ignored(chain, !isWeb ? ssrConfig : csrConfig);
+      const 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(() => {
+      var _modernjsConfig_tools, _userConfig_csrConfig, _modernjsConfig_source, _modernjsConfig_source1, _modernjsConfig_dev;
+      const bundlerType = api.getAppContext().bundlerType === "rspack" ? "rspack" : "webpack";
+      const ipv4 = getIPV4();
+      if (userConfig.remoteIpStrategy === void 0) {
+        if (!enableSSR) {
+          userConfig.remoteIpStrategy = "inherit";
+        } else {
+          userConfig.remoteIpStrategy = "ipv4";
+        }
+      }
+      const devServerConfig = (_modernjsConfig_tools = modernjsConfig.tools) === null || _modernjsConfig_tools === void 0 ? void 0 : _modernjsConfig_tools.devServer;
+      const corsWarnMsgs = [
+        "View https://module-federation.io/guide/troubleshooting/other.html#cors-warn for more details."
+      ];
+      if (typeof 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.');
+      }
+      const exposes = (_userConfig_csrConfig = userConfig.csrConfig) === null || _userConfig_csrConfig === void 0 ? void 0 : _userConfig_csrConfig.exposes;
+      const 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"));
+      }
+      const corsHeaders = hasExposes ? {
+        "Access-Control-Allow-Origin": "*",
+        "Access-Control-Allow-Methods": "GET, POST, PUT, DELETE, PATCH, OPTIONS",
+        "Access-Control-Allow-Headers": "*"
+      } : void 0;
+      const 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
+        }
+      };
+    });
+  }
+});
+var configPlugin_default = moduleFederationConfigPlugin;
+export {
+  addMyTypes2Ignored,
+  configPlugin_default as default,
+  getMFConfig,
+  isWebTarget,
+  moduleFederationConfigPlugin,
+  patchBundlerConfig,
+  patchMFConfig,
+  setEnv,
+  skipByTarget
+};

package/dist/esm-node/cli/configPlugin.spec.js

@@ -0,0 +1,91 @@
+import { it, expect, describe } from "vitest";
+import { patchMFConfig } from "./configPlugin";
+import { getIPV4 } from "./utils";
+const mfConfig = {
+  name: "host",
+  filename: "remoteEntry.js",
+  remotes: {
+    remote: "http://localhost:3000/remoteEntry.js"
+  },
+  shared: {
+    react: {
+      singleton: true,
+      eager: true
+    },
+    "react-dom": {
+      singleton: true,
+      eager: true
+    }
+  }
+};
+describe("patchMFConfig", async () => {
+  it("patchMFConfig: server", async () => {
+    const patchedConfig = JSON.parse(JSON.stringify(mfConfig));
+    patchMFConfig(patchedConfig, true);
+    const ipv4 = getIPV4();
+    expect(patchedConfig).toStrictEqual({
+      dev: false,
+      dts: false,
+      filename: "remoteEntry.js",
+      library: {
+        name: "host",
+        type: "commonjs-module"
+      },
+      name: "host",
+      remotes: {
+        remote: `http://${ipv4}:3000/remoteEntry.js`
+      },
+      remoteType: "script",
+      runtimePlugins: [
+        require.resolve("@module-federation/modern-js/shared-strategy"),
+        require.resolve("@module-federation/modern-js/auto-fetch-data"),
+        require.resolve("@module-federation/node/runtimePlugin"),
+        require.resolve("@module-federation/modern-js/inject-node-fetch")
+      ],
+      shared: {
+        react: {
+          eager: true,
+          singleton: true
+        },
+        "react-dom": {
+          eager: true,
+          singleton: true
+        }
+      }
+    });
+  });
+  it("patchMFConfig: client", async () => {
+    const patchedConfig = JSON.parse(JSON.stringify(mfConfig));
+    patchMFConfig(patchedConfig, false);
+    const ipv4 = getIPV4();
+    expect(patchedConfig).toStrictEqual({
+      filename: "remoteEntry.js",
+      name: "host",
+      remotes: {
+        remote: `http://${ipv4}:3000/remoteEntry.js`
+      },
+      remoteType: "script",
+      runtimePlugins: [
+        require.resolve("@module-federation/modern-js/shared-strategy"),
+        require.resolve("@module-federation/modern-js/auto-fetch-data")
+      ],
+      shared: {
+        react: {
+          eager: true,
+          singleton: true
+        },
+        "react-dom": {
+          eager: true,
+          singleton: true
+        }
+      },
+      dts: {
+        consumeTypes: {
+          runtimePkgs: [
+            "@module-federation/modern-js/runtime"
+          ]
+        }
+      }
+    });
+  });
+});

package/dist/esm-node/cli/index.js

@@ -0,0 +1,70 @@
+import { ModuleFederationPlugin as WebpackModuleFederationPlugin, AsyncBoundaryPlugin } from "@module-federation/enhanced";
+import { ModuleFederationPlugin as RspackModuleFederationPlugin } from "@module-federation/enhanced/rspack";
+import { moduleFederationConfigPlugin } from "./configPlugin";
+import { moduleFederationSSRPlugin } from "./ssrPlugin";
+import { isWebTarget } from "./utils";
+const moduleFederationPlugin = (userConfig = {}) => {
+  var _userConfig_fetchServerQuery;
+  const internalModernPluginOptions = {
+    csrConfig: void 0,
+    ssrConfig: void 0,
+    browserPlugin: void 0,
+    nodePlugin: void 0,
+    distOutputDir: "",
+    originPluginOptions: userConfig,
+    remoteIpStrategy: userConfig === null || userConfig === void 0 ? void 0 : userConfig.remoteIpStrategy,
+    userConfig: userConfig || {},
+    fetchServerQuery: (_userConfig_fetchServerQuery = userConfig.fetchServerQuery) !== null && _userConfig_fetchServerQuery !== void 0 ? _userConfig_fetchServerQuery : void 0
+  };
+  return {
+    name: "@modern-js/plugin-module-federation",
+    setup: async (api) => {
+      const modernjsConfig = api.getConfig();
+      api.modifyBundlerChain((chain) => {
+        const bundlerType = api.getAppContext().bundlerType === "rspack" ? "rspack" : "webpack";
+        const browserPluginOptions = internalModernPluginOptions.csrConfig;
+        const MFPlugin = bundlerType === "webpack" ? WebpackModuleFederationPlugin : RspackModuleFederationPlugin;
+        if (isWebTarget(chain.get("target"))) {
+          chain.plugin("plugin-module-federation").use(MFPlugin, [
+            browserPluginOptions
+          ]).init((Plugin, args) => {
+            internalModernPluginOptions.browserPlugin = new Plugin(args[0]);
+            return internalModernPluginOptions.browserPlugin;
+          });
+        }
+        if (bundlerType === "webpack") {
+          var _modernjsConfig_source;
+          const enableAsyncEntry = (_modernjsConfig_source = modernjsConfig.source) === null || _modernjsConfig_source === void 0 ? void 0 : _modernjsConfig_source.enableAsyncEntry;
+          if (!enableAsyncEntry && browserPluginOptions.async !== false) {
+            const asyncBoundaryPluginOptions = typeof browserPluginOptions.async === "object" ? browserPluginOptions.async : {
+              eager: (module) => module && /\.federation/.test((module === null || module === void 0 ? void 0 : module.request) || ""),
+              excludeChunk: (chunk) => chunk.name === browserPluginOptions.name
+            };
+            chain.plugin("async-boundary-plugin").use(AsyncBoundaryPlugin, [
+              asyncBoundaryPluginOptions
+            ]);
+          }
+        }
+      });
+      api._internalServerPlugins(({ plugins }) => {
+        plugins.push({
+          name: "@module-federation/modern-js/server"
+        });
+        return {
+          plugins
+        };
+      });
+    },
+    usePlugins: [
+      moduleFederationConfigPlugin(internalModernPluginOptions),
+      moduleFederationSSRPlugin(internalModernPluginOptions)
+    ]
+  };
+};
+var cli_default = moduleFederationPlugin;
+import { createModuleFederationConfig } from "@module-federation/enhanced";
+export {
+  createModuleFederationConfig,
+  cli_default as default,
+  moduleFederationPlugin
+};

package/dist/esm-node/cli/mfRuntimePlugins/auto-fetch-data.js

@@ -0,0 +1,68 @@
+import { getDataFetchInfo, initDataFetchMap, getDataFetchItem, getDataFetchMap, isCSROnly } from "../../utils";
+import logger from "../../logger";
+import { getDataFetchMapKey, isDataLoaderExpose, loadDataFetchModule } from "../../utils/dataFetch";
+import { MF_DATA_FETCH_TYPE, MF_DATA_FETCH_STATUS } from "../../constant";
+import { DATA_FETCH_CLIENT_SUFFIX } from "@module-federation/rsbuild-plugin/constant";
+const autoFetchData = () => ({
+  name: "auto-fetch-data-plugin",
+  beforeInit(args) {
+    initDataFetchMap();
+    return args;
+  },
+  afterLoadSnapshot(args) {
+    const { id, moduleInfo, remoteSnapshot, host } = args;
+    if (typeof id === "string" && isDataLoaderExpose(id)) {
+      return args;
+    }
+    if (!remoteSnapshot || !id || !("modules" in remoteSnapshot)) {
+      return args;
+    }
+    const { name, alias } = moduleInfo;
+    const dataFetchInfo = getDataFetchInfo({
+      name,
+      alias,
+      id,
+      remoteSnapshot
+    });
+    if (!dataFetchInfo) {
+      return args;
+    }
+    const { dataFetchId, dataFetchName } = dataFetchInfo;
+    const dataFetchMapKey = getDataFetchMapKey(dataFetchInfo, {
+      name: host.name,
+      version: host.options.version
+    });
+    logger.debug("======= auto fetch plugin dataFetchMapKey: ", dataFetchMapKey);
+    if (!dataFetchMapKey) {
+      return args;
+    }
+    const dataFetchItem = getDataFetchItem(dataFetchMapKey);
+    if (dataFetchItem) {
+      return args;
+    }
+    const dataFetchMap = getDataFetchMap();
+    const downgradeType = remoteSnapshot.modules.find((module) => module.moduleName === `${dataFetchName}${DATA_FETCH_CLIENT_SUFFIX}`) ? MF_DATA_FETCH_TYPE.FETCH_CLIENT : MF_DATA_FETCH_TYPE.FETCH_SERVER;
+    let finalDataFetchId = dataFetchId;
+    if (typeof window !== "undefined") {
+      finalDataFetchId = downgradeType === MF_DATA_FETCH_TYPE.FETCH_CLIENT ? `${dataFetchId}${DATA_FETCH_CLIENT_SUFFIX}` : dataFetchId;
+    }
+    const getDataFetchGetter = () => loadDataFetchModule(host, finalDataFetchId);
+    const dataFetchFnItem = [
+      getDataFetchGetter,
+      downgradeType
+    ];
+    if (typeof window === "undefined" || isCSROnly()) {
+      dataFetchFnItem.push(getDataFetchGetter());
+    }
+    dataFetchMap[dataFetchMapKey] = [
+      dataFetchFnItem,
+      void 0,
+      MF_DATA_FETCH_STATUS.AWAIT
+    ];
+    return args;
+  }
+});
+var auto_fetch_data_default = autoFetchData;
+export {
+  auto_fetch_data_default as default
+};

package/dist/esm-node/cli/mfRuntimePlugins/inject-node-fetch.js

@@ -0,0 +1,14 @@
+import nodeFetch from "node-fetch";
+const injectNodeFetchPlugin = () => ({
+  name: "inject-node-fetch-plugin",
+  beforeInit(args) {
+    if (!globalThis.fetch) {
+      globalThis.fetch = nodeFetch;
+    }
+    return args;
+  }
+});
+var inject_node_fetch_default = injectNodeFetchPlugin;
+export {
+  inject_node_fetch_default as default
+};

package/dist/esm-node/cli/mfRuntimePlugins/resolve-entry-ipv4.js

@@ -0,0 +1,62 @@
+import { LOCALHOST } from "../../constant";
+const ipv4 = typeof FEDERATION_IPV4 !== "undefined" ? FEDERATION_IPV4 : "127.0.0.1";
+const remoteIpStrategy = typeof REMOTE_IP_STRATEGY !== "undefined" ? REMOTE_IP_STRATEGY : "inherit";
+function replaceObjectLocalhost(key, obj) {
+  if (remoteIpStrategy !== "ipv4") {
+    return;
+  }
+  if (!(key in obj)) {
+    return;
+  }
+  const remote = obj[key];
+  if (remote && typeof remote === "string" && remote.includes(LOCALHOST)) {
+    obj[key] = replaceLocalhost(remote);
+  }
+}
+function replaceLocalhost(url) {
+  return url.replace(LOCALHOST, ipv4);
+}
+const resolveEntryIpv4Plugin = () => ({
+  name: "resolve-entry-ipv4",
+  beforeRegisterRemote(args) {
+    const { remote } = args;
+    replaceObjectLocalhost("entry", remote);
+    return args;
+  },
+  async afterResolve(args) {
+    const { remoteInfo } = args;
+    replaceObjectLocalhost("entry", remoteInfo);
+    return args;
+  },
+  beforeLoadRemoteSnapshot(args) {
+    const { moduleInfo } = args;
+    if ("entry" in moduleInfo) {
+      replaceObjectLocalhost("entry", moduleInfo);
+      return args;
+    }
+    if ("version" in moduleInfo) {
+      replaceObjectLocalhost("version", moduleInfo);
+    }
+    return args;
+  },
+  loadRemoteSnapshot(args) {
+    const { remoteSnapshot } = args;
+    if ("publicPath" in remoteSnapshot) {
+      replaceObjectLocalhost("publicPath", remoteSnapshot);
+    }
+    if ("getPublicPath" in remoteSnapshot) {
+      replaceObjectLocalhost("getPublicPath", remoteSnapshot);
+    }
+    if (remoteSnapshot.remotesInfo) {
+      Object.keys(remoteSnapshot.remotesInfo).forEach((key) => {
+        const remoteInfo = remoteSnapshot.remotesInfo[key];
+        replaceObjectLocalhost("matchedVersion", remoteInfo);
+      });
+    }
+    return args;
+  }
+});
+var resolve_entry_ipv4_default = resolveEntryIpv4Plugin;
+export {
+  resolve_entry_ipv4_default as default
+};

package/dist/esm-node/cli/mfRuntimePlugins/shared-strategy.js

@@ -0,0 +1,23 @@
+const sharedStrategy = () => ({
+  name: "shared-strategy-plugin",
+  beforeInit(args) {
+    const { userOptions } = args;
+    const shared = userOptions.shared;
+    if (shared) {
+      Object.keys(shared).forEach((sharedKey) => {
+        const sharedConfigs = shared[sharedKey];
+        const arraySharedConfigs = Array.isArray(sharedConfigs) ? sharedConfigs : [
+          sharedConfigs
+        ];
+        arraySharedConfigs.forEach((s) => {
+          s.strategy = "loaded-first";
+        });
+      });
+    }
+    return args;
+  }
+});
+var shared_strategy_default = sharedStrategy;
+export {
+  shared_strategy_default as default
+};