@module-federation/modern-js 0.0.0-next-20250613163655 → 0.0.0-next-20250616091910

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/server/data-fetch-server-plugin.js

@@ -0,0 +1,236 @@
+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 _ts_generator } from "@swc/helpers/_/_ts_generator";
+import { DATA_FETCH_QUERY, MF_DATA_FETCH_STATUS } from "@module-federation/bridge-react/data-fetch-constant";
+import { getDataFetchMap, fetchData, initDataFetchMap, loadDataFetchModule } from "@module-federation/bridge-react/data-fetch-utils";
+import { SEPARATOR, MANIFEST_EXT } from "@module-federation/sdk";
+import logger from "../../logger";
+function wrapSetTimeout(targetPromise) {
+  var delay = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 2e4, id = arguments.length > 2 ? arguments[2] : void 0;
+  if (targetPromise && typeof targetPromise.then === "function") {
+    return new Promise(function(resolve, reject) {
+      var timeoutId = setTimeout(function() {
+        logger.warn("Data fetch for ID ".concat(id, " timed out after 20 seconds."));
+        reject(new Error("Data fetch for ID ".concat(id, " timed out after 20 seconds")));
+      }, delay);
+      targetPromise.then(function(value) {
+        clearTimeout(timeoutId);
+        resolve(value);
+      }).catch(function(err) {
+        clearTimeout(timeoutId);
+        reject(err);
+      });
+    });
+  }
+}
+function addProtocol(url) {
+  if (url.startsWith("//")) {
+    return "https:" + url;
+  }
+  return url;
+}
+var getDecodeQuery = function(url, name) {
+  var res = url.searchParams.get(name);
+  if (!res) {
+    return null;
+  }
+  return decodeURIComponent(res);
+};
+var middleware = function() {
+  var _ref = _async_to_generator(function(ctx, next) {
+    var _globalThis___FEDERATION__, url, dataFetchId, params, remoteInfo, remoteInfoQuery, _dataFetchMap_dataFetchId, _dataFetchMap_dataFetchId1, dataFetchMap, fetchDataPromise, targetPromise, wrappedPromise, res, hostInstance, remoteEntry, remote, _hostInstance_snapshotHandler_getGlobalRemoteInfo, hostGlobalSnapshot, remoteSnapshot, dataFetchItem, callFetchDataPromise, wrappedPromise1, res1, remoteId, hostInstance1, dataFetchFn, data, e;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          try {
+            url = new URL(ctx.req.url);
+            dataFetchId = getDecodeQuery(url, DATA_FETCH_QUERY);
+            params = JSON.parse(getDecodeQuery(url, "params") || "{}");
+            remoteInfoQuery = getDecodeQuery(url, "remoteInfo");
+            remoteInfo = remoteInfoQuery ? JSON.parse(remoteInfoQuery) : null;
+          } catch (e2) {
+            logger.error("fetch data from server, error: ", e2);
+            return [
+              2,
+              next()
+            ];
+          }
+          if (!dataFetchId) {
+            return [
+              2,
+              next()
+            ];
+          }
+          logger.log("fetch data from server, dataFetchId: ", dataFetchId);
+          logger.debug("fetch data from server, moduleInfo: ", (_globalThis___FEDERATION__ = globalThis.__FEDERATION__) === null || _globalThis___FEDERATION__ === void 0 ? void 0 : _globalThis___FEDERATION__.moduleInfo);
+          _state.label = 1;
+        case 1:
+          _state.trys.push([
+            1,
+            9,
+            ,
+            10
+          ]);
+          dataFetchMap = getDataFetchMap();
+          if (!dataFetchMap) {
+            initDataFetchMap();
+          }
+          fetchDataPromise = (_dataFetchMap_dataFetchId = dataFetchMap[dataFetchId]) === null || _dataFetchMap_dataFetchId === void 0 ? void 0 : _dataFetchMap_dataFetchId[1];
+          logger.debug("fetch data from server, fetchDataPromise: ", fetchDataPromise);
+          if (!(fetchDataPromise && ((_dataFetchMap_dataFetchId1 = dataFetchMap[dataFetchId]) === null || _dataFetchMap_dataFetchId1 === void 0 ? void 0 : _dataFetchMap_dataFetchId1[2]) !== MF_DATA_FETCH_STATUS.ERROR))
+            return [
+              3,
+              4
+            ];
+          targetPromise = fetchDataPromise[0];
+          wrappedPromise = wrapSetTimeout(targetPromise, 2e4, dataFetchId);
+          if (!wrappedPromise)
+            return [
+              3,
+              3
+            ];
+          return [
+            4,
+            wrappedPromise
+          ];
+        case 2:
+          res = _state.sent();
+          logger.log("fetch data from server, fetchDataPromise res: ", res);
+          return [
+            2,
+            ctx.json(res)
+          ];
+        case 3:
+          logger.error("Expected a Promise from fetchDataPromise[0] for dataFetchId ".concat(dataFetchId, ", but received:"), targetPromise, "Will try call new dataFetch again...");
+          _state.label = 4;
+        case 4:
+          if (remoteInfo) {
+            try {
+              hostInstance = globalThis.__FEDERATION__.__INSTANCES__[0];
+              remoteEntry = "".concat(addProtocol(remoteInfo.ssrPublicPath) + remoteInfo.ssrRemoteEntry);
+              if (!hostInstance) {
+                throw new Error("host instance not found!");
+              }
+              remote = hostInstance.options.remotes.find(function(remote2) {
+                return remote2.name === remoteInfo.name;
+              });
+              logger.debug("find remote: ", JSON.stringify(remote));
+              if (!remote) {
+                hostInstance.registerRemotes([
+                  {
+                    name: remoteInfo.name,
+                    entry: remoteEntry,
+                    entryGlobalName: remoteInfo.globalName
+                  }
+                ]);
+              } else if (!("entry" in remote) || !remote.entry.includes(MANIFEST_EXT)) {
+                _hostInstance_snapshotHandler_getGlobalRemoteInfo = hostInstance.snapshotHandler.getGlobalRemoteInfo(remoteInfo), hostGlobalSnapshot = _hostInstance_snapshotHandler_getGlobalRemoteInfo.hostGlobalSnapshot, remoteSnapshot = _hostInstance_snapshotHandler_getGlobalRemoteInfo.remoteSnapshot;
+                logger.debug("find hostGlobalSnapshot: ", JSON.stringify(hostGlobalSnapshot));
+                logger.debug("find remoteSnapshot: ", JSON.stringify(remoteSnapshot));
+                if (!hostGlobalSnapshot || !remoteSnapshot) {
+                  if ("version" in remote) {
+                    delete remote.version;
+                  }
+                  remote.entry = remoteEntry;
+                  remote.entryGlobalName = remoteInfo.globalName;
+                }
+              }
+            } catch (e2) {
+              ctx.status(500);
+              return [
+                2,
+                ctx.text("failed to fetch ".concat(remoteInfo.name, " data, error:\n ").concat(e2))
+              ];
+            }
+          }
+          dataFetchItem = dataFetchMap[dataFetchId];
+          logger.debug("fetch data from server, dataFetchItem: ", dataFetchItem);
+          if (!dataFetchItem)
+            return [
+              3,
+              6
+            ];
+          callFetchDataPromise = fetchData(dataFetchId, _object_spread_props(_object_spread({}, params), {
+            isDowngrade: !remoteInfo
+          }));
+          wrappedPromise1 = wrapSetTimeout(callFetchDataPromise, 2e4, dataFetchId);
+          if (!wrappedPromise1)
+            return [
+              3,
+              6
+            ];
+          return [
+            4,
+            wrappedPromise1
+          ];
+        case 5:
+          res1 = _state.sent();
+          logger.log("fetch data from server, dataFetchItem res: ", res1);
+          return [
+            2,
+            ctx.json(res1)
+          ];
+        case 6:
+          remoteId = dataFetchId.split(SEPARATOR)[0];
+          hostInstance1 = globalThis.__FEDERATION__.__INSTANCES__[0];
+          if (!hostInstance1) {
+            throw new Error("host instance not found!");
+          }
+          return [
+            4,
+            loadDataFetchModule(hostInstance1, remoteId)
+          ];
+        case 7:
+          dataFetchFn = _state.sent();
+          return [
+            4,
+            dataFetchFn(_object_spread_props(_object_spread({}, params), {
+              isDowngrade: !remoteInfo
+            }))
+          ];
+        case 8:
+          data = _state.sent();
+          logger.log("fetch data from server, loadDataFetchModule res: ", data);
+          return [
+            2,
+            ctx.json(data)
+          ];
+        case 9:
+          e = _state.sent();
+          logger.error("server plugin data fetch error: ", e);
+          ctx.status(500);
+          return [
+            2,
+            ctx.text("failed to fetch ".concat(remoteInfo.name, " data, error:\n ").concat(e))
+          ];
+        case 10:
+          return [
+            2
+          ];
+      }
+    });
+  });
+  return function middleware2(ctx, next) {
+    return _ref.apply(this, arguments);
+  };
+}();
+var dataFetchServePlugin = function() {
+  return {
+    name: "mf-data-fetch-server-plugin",
+    setup: function(api) {
+      api.onPrepare(function() {
+        var middlewares = api.getServerContext().middlewares;
+        middlewares.push({
+          name: "module-federation-serve-manifest",
+          // @ts-ignore type error
+          handler: middleware
+        });
+      });
+    }
+  };
+};
+var data_fetch_server_plugin_default = dataFetchServePlugin;
+export {
+  data_fetch_server_plugin_default as default
+};

package/dist/esm/cli/ssrPlugin.js

@@ -0,0 +1,219 @@
+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 logger from "../logger";
+import { isDev } from "./utils";
+import { updateStatsAndManifest } from "@module-federation/rsbuild-plugin/manifest";
+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;
+            var fetchServerQuery = pluginOptions.fetchServerQuery;
+            plugins.push({
+              name: "injectDataFetchFunction",
+              path: "@module-federation/modern-js/ssr-inject-data-fetch-function-plugin",
+              config: {
+                fetchServerQuery
+              }
+            });
+            if (!isDev()) {
+              return {
+                entrypoint,
+                plugins
+              };
+            }
+            plugins.push({
+              name: "mfSSRDev",
+              path: "@module-federation/modern-js/ssr-dev-plugin",
+              config: {}
+            });
+            return {
+              entrypoint,
+              plugins
+            };
+          });
+          if (pluginOptions.ssrConfig.remotes) {
+            api._internalServerPlugins(function(param) {
+              var plugins = param.plugins;
+              plugins.push({
+                name: "@module-federation/modern-js/data-fetch-server-plugin",
+                options: {}
+              });
+              return {
+                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,53 @@
+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;
+};
+function isDev() {
+  return process.env.NODE_ENV === "development";
+}
+export {
+  getIPV4,
+  isDev,
+  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
+};

package/dist/esm/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/runtime/index.js

@@ -0,0 +1,6 @@
+export * from "@module-federation/enhanced/runtime";
+import { kit, ERROR_TYPE } from "@module-federation/bridge-react";
+export {
+  ERROR_TYPE,
+  kit
+};

package/dist/esm/server/fileCache.js

@@ -0,0 +1,98 @@
+import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _class_call_check } from "@swc/helpers/_/_class_call_check";
+import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
+import fs from "fs-extra";
+import { LRUCache } from "lru-cache";
+var FileCache = /* @__PURE__ */ function() {
+  "use strict";
+  function FileCache2() {
+    _class_call_check(this, FileCache2);
+    this.cache = new LRUCache({
+      maxSize: 200 * 1024 * 1024
+    });
+  }
+  var _proto = FileCache2.prototype;
+  _proto.getFile = function getFile(filepath) {
+    var _this = this;
+    return _async_to_generator(function() {
+      var stat, currentModified, cachedEntry, content, newEntry, err;
+      return _ts_generator(this, function(_state) {
+        switch (_state.label) {
+          case 0:
+            return [
+              4,
+              fs.pathExists(filepath)
+            ];
+          case 1:
+            if (!_state.sent()) {
+              return [
+                2,
+                null
+              ];
+            }
+            _state.label = 2;
+          case 2:
+            _state.trys.push([
+              2,
+              5,
+              ,
+              6
+            ]);
+            return [
+              4,
+              fs.lstat(filepath)
+            ];
+          case 3:
+            stat = _state.sent();
+            currentModified = stat.mtimeMs;
+            cachedEntry = _this.cache.get(filepath);
+            if (cachedEntry && currentModified <= cachedEntry.lastModified) {
+              return [
+                2,
+                {
+                  content: cachedEntry.content,
+                  lastModified: cachedEntry.lastModified
+                }
+              ];
+            }
+            return [
+              4,
+              fs.readFile(filepath, "utf-8")
+            ];
+          case 4:
+            content = _state.sent();
+            newEntry = {
+              content,
+              lastModified: currentModified
+            };
+            _this.cache.set(filepath, newEntry, {
+              size: stat.size || content.length
+            });
+            return [
+              2,
+              {
+                content,
+                lastModified: currentModified
+              }
+            ];
+          case 5:
+            err = _state.sent();
+            return [
+              2,
+              null
+            ];
+          case 6:
+            return [
+              2
+            ];
+        }
+      });
+    })();
+  };
+  return FileCache2;
+}();
+var fileCache = new FileCache();
+export {
+  FileCache,
+  fileCache
+};