@module-federation/modern-js 0.14.2 → 0.14.3

package/dist/esm/cli/index.js

@@ -0,0 +1,88 @@
+import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _type_of } from "@swc/helpers/_/_type_of";
+import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
+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";
+var moduleFederationPlugin = function() {
+  var userConfig = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
+  var 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 || {}
+  };
+  return {
+    name: "@modern-js/plugin-module-federation",
+    setup: function() {
+      var _ref = _async_to_generator(function(api) {
+        var modernjsConfig;
+        return _ts_generator(this, function(_state) {
+          modernjsConfig = api.getConfig();
+          api.modifyBundlerChain(function(chain) {
+            var bundlerType = api.getAppContext().bundlerType === "rspack" ? "rspack" : "webpack";
+            var browserPluginOptions = internalModernPluginOptions.csrConfig;
+            var MFPlugin = bundlerType === "webpack" ? WebpackModuleFederationPlugin : RspackModuleFederationPlugin;
+            if (isWebTarget(chain.get("target"))) {
+              chain.plugin("plugin-module-federation").use(MFPlugin, [
+                browserPluginOptions
+              ]).init(function(Plugin, args) {
+                internalModernPluginOptions.browserPlugin = new Plugin(args[0]);
+                return internalModernPluginOptions.browserPlugin;
+              });
+            }
+            if (bundlerType === "webpack") {
+              var _modernjsConfig_source;
+              var enableAsyncEntry = (_modernjsConfig_source = modernjsConfig.source) === null || _modernjsConfig_source === void 0 ? void 0 : _modernjsConfig_source.enableAsyncEntry;
+              if (!enableAsyncEntry && browserPluginOptions.async !== false) {
+                var asyncBoundaryPluginOptions = _type_of(browserPluginOptions.async) === "object" ? browserPluginOptions.async : {
+                  eager: function(module) {
+                    return module && /\.federation/.test((module === null || module === void 0 ? void 0 : module.request) || "");
+                  },
+                  excludeChunk: function(chunk) {
+                    return chunk.name === browserPluginOptions.name;
+                  }
+                };
+                chain.plugin("async-boundary-plugin").use(AsyncBoundaryPlugin, [
+                  asyncBoundaryPluginOptions
+                ]);
+              }
+            }
+          });
+          api._internalServerPlugins(function(param) {
+            var plugins = param.plugins;
+            plugins.push({
+              name: "@module-federation/modern-js/server"
+            });
+            return {
+              plugins
+            };
+          });
+          return [
+            2
+          ];
+        });
+      });
+      return function(api) {
+        return _ref.apply(this, arguments);
+      };
+    }(),
+    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/cli/logger.js

@@ -0,0 +1,7 @@
+import { createLogger } from "@module-federation/sdk";
+import { PLUGIN_IDENTIFIER } from "../constant";
+var logger = createLogger(PLUGIN_IDENTIFIER);
+var logger_default = logger;
+export {
+  logger_default as default
+};

package/dist/esm/cli/manifest.js

@@ -0,0 +1,41 @@
+import path from "path";
+import fs from "fs-extra";
+function mergeStats(browserStats, nodeStats) {
+  var ssrRemoteEntry = nodeStats.metaData.remoteEntry;
+  browserStats.metaData.ssrRemoteEntry = ssrRemoteEntry;
+  if ("publicPath" in browserStats.metaData) {
+    browserStats.metaData.ssrPublicPath = nodeStats.metaData.publicPath;
+  }
+  return browserStats;
+}
+function mergeManifest(browserManifest, nodeManifest) {
+  var ssrRemoteEntry = nodeManifest.metaData.remoteEntry;
+  browserManifest.metaData.ssrRemoteEntry = ssrRemoteEntry;
+  if ("publicPath" in browserManifest.metaData) {
+    browserManifest.metaData.ssrPublicPath = nodeManifest.metaData.publicPath;
+  }
+  return browserManifest;
+}
+function mergeStatsAndManifest(nodePlugin, browserPlugin) {
+  var nodeResourceInfo = nodePlugin.statsResourceInfo;
+  var browserResourceInfo = browserPlugin.statsResourceInfo;
+  if (!browserResourceInfo || !nodeResourceInfo || !browserResourceInfo.stats || !nodeResourceInfo.stats || !browserResourceInfo.manifest || !nodeResourceInfo.manifest) {
+    throw new Error("can not get browserResourceInfo or nodeResourceInfo");
+  }
+  var mergedStats = mergeStats(browserResourceInfo.stats.stats, nodeResourceInfo.stats.stats);
+  var mergedManifest = mergeManifest(browserResourceInfo.manifest.manifest, nodeResourceInfo.manifest.manifest);
+  return {
+    mergedStats,
+    mergedStatsFilePath: browserResourceInfo.stats.filename,
+    mergedManifest,
+    mergedManifestFilePath: browserResourceInfo.manifest.filename
+  };
+}
+function updateStatsAndManifest(nodePlugin, browserPlugin, outputDir) {
+  var _mergeStatsAndManifest = mergeStatsAndManifest(nodePlugin, browserPlugin), mergedStats = _mergeStatsAndManifest.mergedStats, mergedStatsFilePath = _mergeStatsAndManifest.mergedStatsFilePath, mergedManifest = _mergeStatsAndManifest.mergedManifest, mergedManifestFilePath = _mergeStatsAndManifest.mergedManifestFilePath;
+  fs.writeFileSync(path.resolve(outputDir, mergedStatsFilePath), JSON.stringify(mergedStats, null, 2));
+  fs.writeFileSync(path.resolve(outputDir, mergedManifestFilePath), JSON.stringify(mergedManifest, null, 2));
+}
+export {
+  updateStatsAndManifest
+};

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

@@ -0,0 +1,16 @@
+import nodeFetch from "node-fetch";
+var injectNodeFetchPlugin = function() {
+  return {
+    name: "inject-node-fetch-plugin",
+    beforeInit: function 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/cli/mfRuntimePlugins/resolve-entry-ipv4.js

@@ -0,0 +1,74 @@
+import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
+import { LOCALHOST } from "../../constant";
+var ipv4 = typeof FEDERATION_IPV4 !== "undefined" ? FEDERATION_IPV4 : "127.0.0.1";
+var remoteIpStrategy = typeof REMOTE_IP_STRATEGY !== "undefined" ? REMOTE_IP_STRATEGY : "inherit";
+function replaceObjectLocalhost(key, obj) {
+  if (remoteIpStrategy !== "ipv4") {
+    return;
+  }
+  if (!(key in obj)) {
+    return;
+  }
+  var remote = obj[key];
+  if (remote && typeof remote === "string" && remote.includes(LOCALHOST)) {
+    obj[key] = replaceLocalhost(remote);
+  }
+}
+function replaceLocalhost(url) {
+  return url.replace(LOCALHOST, ipv4);
+}
+var resolveEntryIpv4Plugin = function() {
+  return {
+    name: "resolve-entry-ipv4",
+    beforeRegisterRemote: function beforeRegisterRemote(args) {
+      var remote = args.remote;
+      replaceObjectLocalhost("entry", remote);
+      return args;
+    },
+    afterResolve: function afterResolve(args) {
+      return _async_to_generator(function() {
+        var remoteInfo;
+        return _ts_generator(this, function(_state) {
+          remoteInfo = args.remoteInfo;
+          replaceObjectLocalhost("entry", remoteInfo);
+          return [
+            2,
+            args
+          ];
+        });
+      })();
+    },
+    beforeLoadRemoteSnapshot: function beforeLoadRemoteSnapshot(args) {
+      var moduleInfo = args.moduleInfo;
+      if ("entry" in moduleInfo) {
+        replaceObjectLocalhost("entry", moduleInfo);
+        return args;
+      }
+      if ("version" in moduleInfo) {
+        replaceObjectLocalhost("version", moduleInfo);
+      }
+      return args;
+    },
+    loadRemoteSnapshot: function loadRemoteSnapshot(args) {
+      var remoteSnapshot = args.remoteSnapshot;
+      if ("publicPath" in remoteSnapshot) {
+        replaceObjectLocalhost("publicPath", remoteSnapshot);
+      }
+      if ("getPublicPath" in remoteSnapshot) {
+        replaceObjectLocalhost("getPublicPath", remoteSnapshot);
+      }
+      if (remoteSnapshot.remotesInfo) {
+        Object.keys(remoteSnapshot.remotesInfo).forEach(function(key) {
+          var 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/cli/mfRuntimePlugins/shared-strategy.js

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

package/dist/esm/cli/ssrPlugin.js

@@ -0,0 +1,199 @@
+import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _type_of } from "@swc/helpers/_/_type_of";
+import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
+import path from "path";
+import fs from "fs-extra";
+import { ModuleFederationPlugin } from "@module-federation/enhanced/webpack";
+import { ModuleFederationPlugin as RspackModuleFederationPlugin } from "@module-federation/enhanced/rspack";
+import UniverseEntryChunkTrackerPlugin from "@module-federation/node/universe-entry-chunk-tracker-plugin";
+import { updateStatsAndManifest } from "./manifest";
+import { isDev } from "./constant";
+import logger from "./logger";
+import { isWebTarget, skipByTarget } from "./utils";
+function setEnv() {
+  process.env["MF_DISABLE_EMIT_STATS"] = "true";
+  process.env["MF_SSR_PRJ"] = "true";
+}
+var CHAIN_MF_PLUGIN_ID = "plugin-module-federation-server";
+var mfSSRRsbuildPlugin = function(pluginOptions) {
+  return {
+    name: "@modern-js/plugin-mf-post-config",
+    pre: [
+      "@modern-js/builder-plugin-ssr"
+    ],
+    setup: function setup(api) {
+      if (pluginOptions.csrConfig.getPublicPath) {
+        return;
+      }
+      var csrOutputPath = "";
+      var ssrOutputPath = "";
+      var ssrEnv = "";
+      api.modifyEnvironmentConfig(function(config, param) {
+        var name = param.name;
+        var target = config.output.target;
+        if (skipByTarget(target)) {
+          return config;
+        }
+        if (isWebTarget(target)) {
+          csrOutputPath = config.output.distPath.root;
+        } else {
+          ssrOutputPath = config.output.distPath.root;
+          ssrEnv = name;
+        }
+        return config;
+      });
+      var modifySSRPublicPath = function(config, utils) {
+        if (ssrEnv !== utils.environment.name) {
+          return config;
+        }
+        var userSSRConfig = pluginOptions.userConfig.ssr ? _type_of(pluginOptions.userConfig.ssr) === "object" ? pluginOptions.userConfig.ssr : {} : {};
+        if (userSSRConfig.distOutputDir) {
+          return;
+        }
+        config.output.publicPath = "".concat(config.output.publicPath).concat(path.relative(csrOutputPath, ssrOutputPath), "/");
+        return config;
+      };
+      api.modifyWebpackConfig(function(config, utils) {
+        modifySSRPublicPath(config, utils);
+        return config;
+      });
+      api.modifyRspackConfig(function(config, utils) {
+        modifySSRPublicPath(config, utils);
+        return config;
+      });
+    }
+  };
+};
+var moduleFederationSSRPlugin = function(pluginOptions) {
+  return {
+    name: "@modern-js/plugin-module-federation-ssr",
+    pre: [
+      "@modern-js/plugin-module-federation-config",
+      "@modern-js/plugin-module-federation"
+    ],
+    setup: function() {
+      var _ref = _async_to_generator(function(api) {
+        var _pluginOptions_userConfig, _modernjsConfig_server, modernjsConfig, _pluginOptions_userConfig_ssr, enableSSR;
+        return _ts_generator(this, function(_state) {
+          modernjsConfig = api.getConfig();
+          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);
+          if (!enableSSR) {
+            return [
+              2
+            ];
+          }
+          setEnv();
+          api._internalRuntimePlugins(function(param) {
+            var entrypoint = param.entrypoint, plugins = param.plugins;
+            if (!isDev) {
+              return {
+                entrypoint,
+                plugins
+              };
+            }
+            plugins.push({
+              name: "mfSSR",
+              path: "@module-federation/modern-js/ssr-runtime",
+              config: {}
+            });
+            return {
+              entrypoint,
+              plugins
+            };
+          });
+          api.modifyBundlerChain(function(chain) {
+            var target = chain.get("target");
+            if (skipByTarget(target)) {
+              return;
+            }
+            var bundlerType = api.getAppContext().bundlerType === "rspack" ? "rspack" : "webpack";
+            var MFPlugin = bundlerType === "webpack" ? ModuleFederationPlugin : RspackModuleFederationPlugin;
+            var isWeb = isWebTarget(target);
+            if (!isWeb) {
+              if (!chain.plugins.has(CHAIN_MF_PLUGIN_ID)) {
+                chain.plugin(CHAIN_MF_PLUGIN_ID).use(MFPlugin, [
+                  pluginOptions.ssrConfig
+                ]).init(function(Plugin, args) {
+                  pluginOptions.nodePlugin = new Plugin(args[0]);
+                  return pluginOptions.nodePlugin;
+                });
+              }
+            }
+            if (!isWeb) {
+              chain.target("async-node");
+              if (isDev) {
+                chain.plugin("UniverseEntryChunkTrackerPlugin").use(UniverseEntryChunkTrackerPlugin);
+              }
+              var userSSRConfig = pluginOptions.userConfig.ssr ? _type_of(pluginOptions.userConfig.ssr) === "object" ? pluginOptions.userConfig.ssr : {} : {};
+              var publicPath = chain.output.get("publicPath");
+              if (userSSRConfig.distOutputDir && publicPath) {
+                chain.output.publicPath("".concat(publicPath).concat(userSSRConfig.distOutputDir, "/"));
+              }
+            }
+            if (isDev && isWeb) {
+              chain.externals({
+                "@module-federation/node/utils": "NOT_USED_IN_BROWSER"
+              });
+            }
+          });
+          api.config(function() {
+            return {
+              builderPlugins: [
+                mfSSRRsbuildPlugin(pluginOptions)
+              ],
+              tools: {
+                devServer: {
+                  before: [
+                    function(req, res, next) {
+                      if (!enableSSR) {
+                        next();
+                        return;
+                      }
+                      try {
+                        var _req_url, _req_url1;
+                        if (((_req_url = req.url) === null || _req_url === void 0 ? void 0 : _req_url.includes(".json")) && !((_req_url1 = req.url) === null || _req_url1 === void 0 ? void 0 : _req_url1.includes("hot-update"))) {
+                          var filepath = path.join(process.cwd(), "dist".concat(req.url));
+                          fs.statSync(filepath);
+                          res.setHeader("Access-Control-Allow-Origin", "*");
+                          res.setHeader("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, PATCH, OPTIONS");
+                          res.setHeader("Access-Control-Allow-Headers", "*");
+                          fs.createReadStream(filepath).pipe(res);
+                        } else {
+                          next();
+                        }
+                      } catch (err) {
+                        logger.debug(err);
+                        next();
+                      }
+                    }
+                  ]
+                }
+              }
+            };
+          });
+          api.onAfterBuild(function() {
+            var nodePlugin = pluginOptions.nodePlugin, browserPlugin = pluginOptions.browserPlugin, distOutputDir = pluginOptions.distOutputDir;
+            updateStatsAndManifest(nodePlugin, browserPlugin, distOutputDir);
+          });
+          api.onDevCompileDone(function() {
+            var nodePlugin = pluginOptions.nodePlugin, browserPlugin = pluginOptions.browserPlugin, distOutputDir = pluginOptions.distOutputDir;
+            updateStatsAndManifest(nodePlugin, browserPlugin, distOutputDir);
+          });
+          return [
+            2
+          ];
+        });
+      });
+      return function(api) {
+        return _ref.apply(this, arguments);
+      };
+    }()
+  };
+};
+var ssrPlugin_default = moduleFederationSSRPlugin;
+export {
+  CHAIN_MF_PLUGIN_ID,
+  ssrPlugin_default as default,
+  moduleFederationSSRPlugin,
+  setEnv
+};

package/dist/esm/cli/utils.js

@@ -0,0 +1,49 @@
+import os from "os";
+var localIpv4 = "127.0.0.1";
+var getIpv4Interfaces = function() {
+  try {
+    var interfaces = os.networkInterfaces();
+    var ipv4Interfaces = [];
+    Object.values(interfaces).forEach(function(detail) {
+      detail === null || detail === void 0 ? void 0 : detail.forEach(function(detail2) {
+        var familyV4Value = typeof detail2.family === "string" ? "IPv4" : 4;
+        if (detail2.family === familyV4Value && detail2.address !== localIpv4) {
+          ipv4Interfaces.push(detail2);
+        }
+      });
+    });
+    return ipv4Interfaces;
+  } catch (_err) {
+    return [];
+  }
+};
+var getIPV4 = function() {
+  var ipv4Interfaces = getIpv4Interfaces();
+  var ipv4Interface = ipv4Interfaces[0] || {
+    address: localIpv4
+  };
+  return ipv4Interface.address;
+};
+var isWebTarget = function(target) {
+  var WEB_TARGET = "web";
+  if (Array.isArray(target)) {
+    return target.includes(WEB_TARGET);
+  } else if (typeof target === "string") {
+    return target === WEB_TARGET;
+  }
+  return false;
+};
+var skipByTarget = function(target) {
+  var IGNORE_TARGET = "webworker";
+  if (Array.isArray(target)) {
+    return target.includes(IGNORE_TARGET);
+  } else if (typeof target === "string") {
+    return target === IGNORE_TARGET;
+  }
+  return false;
+};
+export {
+  getIPV4,
+  isWebTarget,
+  skipByTarget
+};

package/dist/esm/constant.js

@@ -0,0 +1,6 @@
+var LOCALHOST = "localhost";
+var PLUGIN_IDENTIFIER = "[ Modern.js Module Federation ]";
+export {
+  LOCALHOST,
+  PLUGIN_IDENTIFIER
+};