@module-federation/modern-js 0.0.0-next-20250401063000 → 0.0.0-next-20250402032411

package/dist/cjs/cli/configPlugin.js

@@ -28,21 +28,251 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var configPlugin_exports = {};
 __export(configPlugin_exports, {
+  addMyTypes2Ignored: () => addMyTypes2Ignored,
   default: () => configPlugin_default,
+  getMFConfig: () => getMFConfig,
   isWebTarget: () => import_utils.isWebTarget,
   moduleFederationConfigPlugin: () => moduleFederationConfigPlugin,
+  patchBundlerConfig: () => patchBundlerConfig,
+  patchMFConfig: () => patchMFConfig,
   setEnv: () => setEnv,
   skipByTarget: () => import_utils.skipByTarget
 });
 module.exports = __toCommonJS(configPlugin_exports);
 var import_path = __toESM(require("path"));
 var import_utils = require("./utils");
+var import_sdk = require("@module-federation/sdk");
+var import_node_bundle_require = require("@modern-js/node-bundle-require");
+var import_constant = require("../constant");
+var import_logger = __toESM(require("./logger"));
+var import_utils2 = require("@module-federation/rsbuild-plugin/utils");
+const defaultPath = import_path.default.resolve(process.cwd(), "module-federation.config.ts");
+const isDev = process.env.NODE_ENV === "development";
 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 (0, import_node_bundle_require.bundle)(mfConfigPath);
+  const mfConfig = (await Promise.resolve().then(() => __toESM(require(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 = (0, import_utils.getIPV4)();
+  const handleRemoteObject = (remoteObject) => {
+    Object.keys(remoteObject).forEach((remoteKey) => {
+      const remote = remoteObject[remoteKey];
+      if (Array.isArray(remote)) {
+        return;
+      }
+      if (typeof remote === "string" && remote.includes(import_constant.LOCALHOST)) {
+        remoteObject[remoteKey] = remote.replace(import_constant.LOCALHOST, ipv4);
+      }
+      if (typeof remote === "object" && !Array.isArray(remote.external) && remote.external.includes(import_constant.LOCALHOST)) {
+        remote.external = remote.external.replace(import_constant.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 = "@modern-js/runtime/mf";
+  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) => {
+  replaceRemoteUrl(mfConfig, remoteIpStrategy);
+  if (mfConfig.remoteType === void 0) {
+    mfConfig.remoteType = "script";
+  }
+  if (!mfConfig.name) {
+    throw new Error(`${import_constant.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);
+  if (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) {
+    (0, import_utils2.autoDeleteSplitChunkCacheGroups)(mfConfig, splitChunkConfig);
+  }
+  if (!isServer && enableSSR && splitChunkConfig && typeof splitChunkConfig === "object" && splitChunkConfig.cacheGroups) {
+    splitChunkConfig.chunks = "async";
+    import_logger.default.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 = `${(0, import_sdk.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: [
@@ -54,7 +284,7 @@ const moduleFederationConfigPlugin = (userConfig) => ({
   setup: async (api) => {
     var _userConfig_userConfig, _modernjsConfig_server;
     const modernjsConfig = api.getConfig();
-    const mfConfig = await (0, import_utils.getMFConfig)(userConfig.originPluginOptions);
+    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;
@@ -67,10 +297,10 @@ const moduleFederationConfigPlugin = (userConfig) => ({
         return;
       }
       const isWeb = (0, import_utils.isWebTarget)(target);
-      (0, import_utils.addMyTypes2Ignored)(chain, !isWeb ? ssrConfig : csrConfig);
+      addMyTypes2Ignored(chain, !isWeb ? ssrConfig : csrConfig);
       const targetMFConfig = !isWeb ? ssrConfig : csrConfig;
-      (0, import_utils.patchMFConfig)(targetMFConfig, !isWeb, userConfig.remoteIpStrategy || "ipv4");
-      (0, import_utils.patchBundlerConfig)({
+      patchMFConfig(targetMFConfig, !isWeb, userConfig.remoteIpStrategy || "ipv4");
+      patchBundlerConfig({
         // @ts-expect-error chain type is not correct
         chain,
         isServer: !isWeb,
@@ -122,8 +352,12 @@ const moduleFederationConfigPlugin = (userConfig) => ({
 var configPlugin_default = moduleFederationConfigPlugin;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  addMyTypes2Ignored,
+  getMFConfig,
   isWebTarget,
   moduleFederationConfigPlugin,
+  patchBundlerConfig,
+  patchMFConfig,
   setEnv,
   skipByTarget
 });

package/dist/cjs/cli/{utils.spec.js → configPlugin.spec.js}

@@ -22,6 +22,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 var import_vitest = require("vitest");
+var import_configPlugin = require("./configPlugin");
 var import_utils = require("./utils");
 const mfConfig = {
   name: "host",
@@ -43,7 +44,7 @@ const mfConfig = {
 (0, import_vitest.describe)("patchMFConfig", async () => {
   (0, import_vitest.it)("patchMFConfig: server", async () => {
     const patchedConfig = JSON.parse(JSON.stringify(mfConfig));
-    (0, import_utils.patchMFConfig)(patchedConfig, true);
+    (0, import_configPlugin.patchMFConfig)(patchedConfig, true);
     const ipv4 = (0, import_utils.getIPV4)();
     (0, import_vitest.expect)(patchedConfig).toStrictEqual({
       dev: false,
@@ -77,7 +78,7 @@ const mfConfig = {
   });
   (0, import_vitest.it)("patchMFConfig: client", async () => {
     const patchedConfig = JSON.parse(JSON.stringify(mfConfig));
-    (0, import_utils.patchMFConfig)(patchedConfig, false);
+    (0, import_configPlugin.patchMFConfig)(patchedConfig, false);
     const ipv4 = (0, import_utils.getIPV4)();
     (0, import_vitest.expect)(patchedConfig).toStrictEqual({
       filename: "remoteEntry.js",

package/dist/cjs/cli/manifest.js

@@ -33,26 +33,30 @@ __export(manifest_exports, {
 module.exports = __toCommonJS(manifest_exports);
 var import_path = __toESM(require("path"));
 var import_utils = require("@modern-js/utils");
-function mergeStats(browserStats, nodeStats, ssrDir) {
+function mergeStats(browserStats, nodeStats, ssrPublicPath) {
   const ssrRemoteEntry = nodeStats.metaData.remoteEntry;
-  ssrRemoteEntry.path = ssrDir;
   browserStats.metaData.ssrRemoteEntry = ssrRemoteEntry;
+  if ("publicPath" in browserStats.metaData) {
+    browserStats.metaData.ssrPublicPath = ssrPublicPath;
+  }
   return browserStats;
 }
-function mergeManifest(browserManifest, nodeManifest, ssrDir) {
+function mergeManifest(browserManifest, nodeManifest, ssrPublicPath) {
   const ssrRemoteEntry = nodeManifest.metaData.remoteEntry;
-  ssrRemoteEntry.path = ssrDir;
   browserManifest.metaData.ssrRemoteEntry = ssrRemoteEntry;
+  if ("publicPath" in browserManifest.metaData) {
+    browserManifest.metaData.ssrPublicPath = ssrPublicPath;
+  }
   return browserManifest;
 }
-function mergeStatsAndManifest(nodePlugin, browserPlugin, ssrDir) {
+function mergeStatsAndManifest(nodePlugin, browserPlugin, ssrPublicPath) {
   const nodeResourceInfo = nodePlugin.statsResourceInfo;
   const browserResourceInfo = browserPlugin.statsResourceInfo;
   if (!browserResourceInfo || !nodeResourceInfo || !browserResourceInfo.stats || !nodeResourceInfo.stats || !browserResourceInfo.manifest || !nodeResourceInfo.manifest) {
     throw new Error("can not get browserResourceInfo or nodeResourceInfo");
   }
-  const mergedStats = mergeStats(browserResourceInfo.stats.stats, nodeResourceInfo.stats.stats, ssrDir);
-  const mergedManifest = mergeManifest(browserResourceInfo.manifest.manifest, nodeResourceInfo.manifest.manifest, ssrDir);
+  const mergedStats = mergeStats(browserResourceInfo.stats.stats, nodeResourceInfo.stats.stats, ssrPublicPath);
+  const mergedManifest = mergeManifest(browserResourceInfo.manifest.manifest, nodeResourceInfo.manifest.manifest, ssrPublicPath);
   return {
     mergedStats,
     mergedStatsFilePath: browserResourceInfo.stats.filename,
@@ -60,8 +64,8 @@ function mergeStatsAndManifest(nodePlugin, browserPlugin, ssrDir) {
     mergedManifestFilePath: browserResourceInfo.manifest.filename
   };
 }
-function updateStatsAndManifest(nodePlugin, browserPlugin, outputDir, ssrDir) {
-  const { mergedStats, mergedStatsFilePath, mergedManifest, mergedManifestFilePath } = mergeStatsAndManifest(nodePlugin, browserPlugin, ssrDir);
+function updateStatsAndManifest(nodePlugin, browserPlugin, outputDir, ssrPublicPath) {
+  const { mergedStats, mergedStatsFilePath, mergedManifest, mergedManifestFilePath } = mergeStatsAndManifest(nodePlugin, browserPlugin, ssrPublicPath);
   import_utils.fs.writeFileSync(import_path.default.resolve(outputDir, mergedStatsFilePath), JSON.stringify(mergedStats, null, 2));
   import_utils.fs.writeFileSync(import_path.default.resolve(outputDir, mergedManifestFilePath), JSON.stringify(mergedManifest, null, 2));
 }

package/dist/cjs/cli/ssrPlugin.js

@@ -41,7 +41,6 @@ var import_rspack = require("@module-federation/enhanced/rspack");
 var import_universe_entry_chunk_tracker_plugin = __toESM(require("@module-federation/node/universe-entry-chunk-tracker-plugin"));
 var import_manifest = require("./manifest");
 var import_constant = require("./constant");
-var import_constant2 = require("../constant");
 var import_logger = __toESM(require("./logger"));
 var import_utils2 = require("./utils");
 function setEnv() {
@@ -49,6 +48,52 @@ function setEnv() {
   process.env["MF_SSR_PRJ"] = "true";
 }
 const CHAIN_MF_PLUGIN_ID = "plugin-module-federation-server";
+let ssrPublicPath = "";
+const mfSSRRsbuildPlugin = (pluginOptions) => {
+  return {
+    name: "@modern-js/plugin-mf-post-config",
+    pre: [
+      "@modern-js/builder-plugin-ssr"
+    ],
+    setup(api) {
+      if (pluginOptions.csrConfig.getPublicPath) {
+        return;
+      }
+      let csrOutputPath = "";
+      let ssrOutputPath = "";
+      let ssrEnv = "";
+      api.modifyEnvironmentConfig((config, { name }) => {
+        const target = config.output.target;
+        if ((0, import_utils2.skipByTarget)(target)) {
+          return config;
+        }
+        if ((0, import_utils2.isWebTarget)(target)) {
+          csrOutputPath = config.output.distPath.root;
+        } else {
+          ssrOutputPath = config.output.distPath.root;
+          ssrEnv = name;
+        }
+        return config;
+      });
+      const modifySSRPublicPath = (config, utils) => {
+        if (ssrEnv !== utils.environment.name) {
+          return config;
+        }
+        ssrPublicPath = `${config.output.publicPath}${import_path.default.relative(csrOutputPath, ssrOutputPath)}/`;
+        config.output.publicPath = ssrPublicPath;
+        return config;
+      };
+      api.modifyWebpackConfig((config, utils) => {
+        modifySSRPublicPath(config, utils);
+        return config;
+      });
+      api.modifyRspackConfig((config, utils) => {
+        modifySSRPublicPath(config, utils);
+        return config;
+      });
+    }
+  };
+};
 const moduleFederationSSRPlugin = (pluginOptions) => ({
   name: "@modern-js/plugin-module-federation-ssr",
   pre: [
@@ -60,8 +105,6 @@ const moduleFederationSSRPlugin = (pluginOptions) => ({
     const modernjsConfig = api.getConfig();
     var _pluginOptions_userConfig_ssr;
     const enableSSR = (_pluginOptions_userConfig_ssr = (_pluginOptions_userConfig = pluginOptions.userConfig) === null || _pluginOptions_userConfig === void 0 ? void 0 : _pluginOptions_userConfig.ssr) !== null && _pluginOptions_userConfig_ssr !== void 0 ? _pluginOptions_userConfig_ssr : Boolean(modernjsConfig === null || modernjsConfig === void 0 ? void 0 : (_modernjsConfig_server = modernjsConfig.server) === null || _modernjsConfig_server === void 0 ? void 0 : _modernjsConfig_server.ssr);
-    let csrOutputPath = "";
-    let ssrOutputPath = "";
     if (!enableSSR) {
       return;
     }
@@ -112,14 +155,12 @@ const moduleFederationSSRPlugin = (pluginOptions) => ({
           "@module-federation/node/utils": "NOT_USED_IN_BROWSER"
         });
       }
-      if (!isWeb) {
-        ssrOutputPath = chain.output.get("path") || import_path.default.resolve(process.cwd(), `dist/${import_constant2.MODERN_JS_SERVER_DIR}`);
-      } else {
-        csrOutputPath = chain.output.get("path") || import_path.default.resolve(process.cwd(), "dist");
-      }
     });
     api.config(() => {
       return {
+        builderPlugins: [
+          mfSSRRsbuildPlugin(pluginOptions)
+        ],
         tools: {
           devServer: {
             before: [
@@ -152,11 +193,11 @@ const moduleFederationSSRPlugin = (pluginOptions) => ({
     });
     api.onAfterBuild(() => {
       const { nodePlugin, browserPlugin, distOutputDir } = pluginOptions;
-      (0, import_manifest.updateStatsAndManifest)(nodePlugin, browserPlugin, distOutputDir, import_path.default.relative(csrOutputPath, ssrOutputPath));
+      (0, import_manifest.updateStatsAndManifest)(nodePlugin, browserPlugin, distOutputDir, ssrPublicPath);
     });
     api.onDevCompileDone(() => {
       const { nodePlugin, browserPlugin, distOutputDir } = pluginOptions;
-      (0, import_manifest.updateStatsAndManifest)(nodePlugin, browserPlugin, distOutputDir, import_path.default.relative(csrOutputPath, ssrOutputPath));
+      (0, import_manifest.updateStatsAndManifest)(nodePlugin, browserPlugin, distOutputDir, ssrPublicPath);
     });
   }
 });