@module-federation/modern-js 0.0.0-next-20241106033151 → 0.0.0-next-20241106063644

package/dist/cjs/cli/routes/plugin.js

@@ -0,0 +1,157 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var plugin_exports = {};
+__export(plugin_exports, {
+  default: () => plugin_default,
+  moduleFederationRoutesPlugin: () => moduleFederationRoutesPlugin
+});
+module.exports = __toCommonJS(plugin_exports);
+var import_path = __toESM(require("path"));
+var import_utils = require("@modern-js/utils");
+var import_utils2 = require("../../runtime/routes/utils");
+var import_constant = require("../../constant");
+var import_traverseRouteFiles = require("./traverseRouteFiles");
+var import_exportRoutePlugin = require("./exportRoutePlugin");
+var import_importRoutesPlugin = require("./importRoutesPlugin");
+var import_utils3 = require("./utils");
+var import_constant2 = require("../../constant");
+const moduleFederationRoutesPlugin = ({ userConfig, internalOptions, serverPlugin, transformRuntimeOptions }) => {
+  const entries = /* @__PURE__ */ new Set();
+  const remotePathMap = {};
+  const ssrByRouteIdsMap = {};
+  const internalRoutesPluginOptions = {
+    userConfig,
+    internalOptions,
+    entries,
+    remotePathMap,
+    ssrByRouteIdsMap,
+    serverPlugin,
+    transformRuntimeOptions
+  };
+  return {
+    name: "@modern-js/plugin-module-federation-route",
+    pre: [
+      "@modern-js/plugin-module-federation-config"
+    ],
+    setup: async ({ useAppContext }) => {
+      if (!userConfig.exportRoutes && !userConfig.importRoutes) {
+        return;
+      }
+      const appContext = useAppContext();
+      const name = internalOptions.csrConfig.name;
+      const { metaName = import_constant.META_NAME } = internalOptions;
+      const internalDirectory = appContext.internalDirectory.replace(import_constant.META_NAME, metaName || import_constant.META_NAME);
+      const csrConfig = internalOptions.csrConfig;
+      if (typeof csrConfig.remotes === "object" && Object.keys(csrConfig.remotes).length) {
+        const { entries: scanEntries } = await (0, import_traverseRouteFiles.traverseRouteFiles)({
+          appDirectory: appContext.appDirectory,
+          generateRouteFile: userConfig.importRoutes,
+          remotePathMap
+        });
+        scanEntries.forEach((e) => entries.add(e));
+      } else {
+        entries.add(import_constant2.DEFAULT_ENTRY);
+      }
+      return {
+        config: async () => {
+          return {
+            tools: {
+              // bundlerChain can not keep target order
+              rspack(_config, { isServer }) {
+                (0, import_utils3.addShared)({
+                  mfConfig: isServer ? internalOptions.ssrConfig : internalOptions.csrConfig,
+                  metaName,
+                  isServer,
+                  internalDirectory,
+                  entries
+                });
+              },
+              // bundlerChain can not keep target order
+              webpack(_config, { isServer }) {
+                (0, import_utils3.addShared)({
+                  mfConfig: isServer ? internalOptions.ssrConfig : internalOptions.csrConfig,
+                  metaName,
+                  isServer,
+                  internalDirectory,
+                  entries
+                });
+              }
+            },
+            source: {
+              define: {
+                MODERN_ROUTER_ID_PREFIX: JSON.stringify((0, import_utils2.transformName2Prefix)(name))
+              }
+            }
+          };
+        },
+        async modifyFileSystemRoutes(options) {
+          const { routes, entrypoint } = options;
+          const { entryName } = entrypoint;
+          const prefix = (0, import_utils2.transformName2Prefix)(internalOptions.csrConfig.name);
+          const modifyRouteIds = async (route, pathName) => {
+            const currentPathName = route.path ? import_path.default.join("/", pathName, route.path) : pathName;
+            if (route.id) {
+              const originalId = route.id;
+              route.originalId = originalId;
+              const remoteInfo = remotePathMap[currentPathName];
+              if (remoteInfo) {
+                const { path: path2, name: name2 } = remoteInfo;
+                const remoteIdPrefix = (0, import_utils2.transformName2Prefix)(name2);
+                const isLayout = Boolean(route.children);
+                const newId = `${remoteIdPrefix}${isLayout ? "layout" : "page"}`;
+                ssrByRouteIdsMap[originalId] = newId;
+                const content = import_utils.fs.readFileSync(path2, "utf-8");
+                await import_utils.fs.writeFile(path2, content.replace(import_constant2.ROUTE_ID, originalId));
+                route.id = newId;
+              } else {
+                route.id = `${prefix}${route.id}`;
+              }
+              route.children && await Promise.all(route.children.map(async (r) => {
+                return await modifyRouteIds(r, currentPathName);
+              }));
+            }
+          };
+          await Promise.all(routes.map(async (route) => {
+            await modifyRouteIds(route, entryName === import_constant2.DEFAULT_ENTRY ? "" : entryName);
+          }));
+          return options;
+        }
+      };
+    },
+    usePlugins: [
+      (0, import_exportRoutePlugin.moduleFederationExportRoutePlugin)(internalRoutesPluginOptions),
+      (0, import_importRoutesPlugin.moduleFederationImportRoutePlugin)(internalRoutesPluginOptions)
+    ]
+  };
+};
+var plugin_default = moduleFederationRoutesPlugin;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  moduleFederationRoutesPlugin
+});

package/dist/cjs/cli/routes/traverseRouteFiles.js

@@ -0,0 +1,148 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var traverseRouteFiles_exports = {};
+__export(traverseRouteFiles_exports, {
+  calcPathName: () => calcPathName,
+  traverseRouteFiles: () => traverseRouteFiles
+});
+module.exports = __toCommonJS(traverseRouteFiles_exports);
+var import_utils = require("@modern-js/utils");
+var import_path = __toESM(require("path"));
+var import_os = __toESM(require("os"));
+var import_constant = require("../../constant");
+var import_utils2 = require("../../runtime/routes/utils");
+const ROUTES = "routes";
+function calcPathName(filePath, rootDir, entry) {
+  const relativePath = import_path.default.relative(rootDir, filePath);
+  const conditionalReg = /^\[(.*)\]$/;
+  const splitPaths = relativePath.split("/").reduce((sum, cur) => {
+    if (cur.includes(".")) {
+      const split = cur.split(".").map((i) => {
+        const match = i.match(conditionalReg);
+        if (match) {
+          return `:${match[1]}`;
+        }
+        return i.startsWith("__") ? "" : i;
+      });
+      sum.push(...split);
+    } else {
+      const match = cur.match(conditionalReg);
+      if (match) {
+        sum.push(`:${match[1]}`);
+      } else {
+        if (!cur.startsWith("__")) {
+          sum.push(cur);
+        }
+      }
+    }
+    return sum;
+  }, []);
+  return import_path.default.join("/", entry, splitPaths.filter((p) => !!p).join("/"));
+}
+async function traverseRouteFiles(options) {
+  const { appDirectory, generateRouteFile, remotePathMap } = options;
+  const entries = [];
+  const srcPath = `${appDirectory}/src`;
+  const traverse = async (filepath, rootDir, entry) => {
+    if (!await import_utils.fs.pathExists(filepath)) {
+      return null;
+    }
+    const isDirectory = (await import_utils.fs.stat(filepath)).isDirectory();
+    if (!isDirectory) {
+      return null;
+    }
+    const items = await import_utils.fs.readdir(filepath);
+    const mfJson = items.find((i) => i === import_constant.MF_JSON);
+    if (mfJson) {
+      const mfJsonContent = await import_utils.fs.readJSON((0, import_utils.normalizeToPosixPath)(import_path.default.join(filepath, mfJson)));
+      const { remoteName } = mfJsonContent;
+      const remoteLayoutId = (0, import_utils2.getRemoteLayoutId)(remoteName);
+      const writeFile = async (id, type, pathname) => {
+        const generatedFilePath = (0, import_utils.normalizeToPosixPath)(import_path.default.join(filepath, `${type}.tsx`));
+        const content = [
+          "// Do not edit this file. It is a auto generated.",
+          `// It will render ${remoteName}'s ${type}.`,
+          `// The ${type} pathname is: ${pathname}`,
+          `// The ${type} route id is: ${import_constant.ROUTE_ID}`
+        ];
+        await import_utils.fs.writeFile(generatedFilePath, content.join(import_os.default.EOL));
+        return generatedFilePath;
+      };
+      if (remoteLayoutId) {
+        const pathname = calcPathName(filepath, rootDir, entry);
+        const filePath = await writeFile(remoteLayoutId, "layout", pathname);
+        remotePathMap[pathname] = {
+          name: remoteName,
+          path: filePath
+        };
+      }
+      return;
+    }
+    await Promise.all(items.map(async (item) => {
+      await traverse((0, import_utils.normalizeToPosixPath)(import_path.default.join(filepath, item)), rootDir, entry);
+    }));
+  };
+  const traverseRoutes = async (dir, level = 1) => {
+    if (level > 3) {
+      return;
+    }
+    const isDirectory = (await import_utils.fs.stat(dir)).isDirectory();
+    if (!isDirectory) {
+      return;
+    }
+    const items = await import_utils.fs.readdir(dir);
+    if (items.find((i) => i === ROUTES)) {
+      const entry = import_path.default.relative(srcPath, dir);
+      entries.push(entry);
+      const rootDir = `${dir}/${ROUTES}`;
+      if (generateRouteFile) {
+        await traverse(rootDir, rootDir, entry);
+      }
+    } else {
+      await Promise.all(items.map(async (item) => {
+        await traverseRoutes(import_path.default.join(dir, item), level++);
+      }));
+    }
+  };
+  await traverseRoutes(srcPath);
+  const normalizedEntries = entries.map((entry) => {
+    if (entry === "") {
+      return import_constant.DEFAULT_ENTRY;
+    }
+    return entry;
+  });
+  return {
+    entries: normalizedEntries
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  calcPathName,
+  traverseRouteFiles
+});

package/dist/cjs/cli/routes/utils.js

@@ -0,0 +1,168 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var utils_exports = {};
+__export(utils_exports, {
+  addExpose: () => addExpose,
+  addShared: () => addShared
+});
+module.exports = __toCommonJS(utils_exports);
+var import_path = __toESM(require("path"));
+var import_utils = require("@modern-js/utils");
+var import_constant = require("../../constant");
+var import_constant2 = require("../../constant");
+var import_ast = require("./ast");
+function generateExtraExposeFiles(options) {
+  const { internalDirectory, mfConfig, isServer, entries } = options;
+  const entryMap = {};
+  const outputDir = import_path.default.resolve(process.cwd(), "node_modules/.federation/data-loader");
+  import_utils.fs.ensureDirSync(outputDir);
+  const addSuffix = (fileName, ext = ".jsx") => {
+    if (!isServer) {
+      return `${fileName}${ext}`;
+    }
+    return `${fileName}.server${ext}`;
+  };
+  const generateEntryRoutes = (entry) => {
+    const outputEntryDir = import_path.default.resolve(outputDir, entry);
+    import_utils.fs.ensureDirSync(outputEntryDir);
+    const sourceDir = import_path.default.resolve(internalDirectory, entry);
+    const routesFilePath = import_path.default.resolve(sourceDir, addSuffix(import_constant2.MODERN_JS_FILE_SYSTEM_ROUTES_FILE_NAME, ".js"));
+    const routesFileContent = import_utils.fs.readFileSync(routesFilePath, "utf-8");
+    const outputFullRoutesPath = import_path.default.resolve(outputEntryDir, addSuffix(import_constant2.MF_ROUTES));
+    (0, import_ast.generateRoutes)({
+      sourceCode: routesFileContent,
+      filePath: outputFullRoutesPath
+    });
+    const routeServerLoaderPath = import_path.default.resolve(sourceDir, `${import_constant.MODERN_JS_ROUTE_SERVER_LOADER}.js`);
+    const outputRouteServerLoaderPath = import_path.default.resolve(outputEntryDir, `${import_constant.MODERN_JS_ROUTE_SERVER_LOADER}.js`);
+    const clientRouteServerLoaderPath = outputRouteServerLoaderPath.replace(import_constant.MODERN_JS_ROUTE_SERVER_LOADER, `${import_constant.MODERN_JS_ROUTE_SERVER_LOADER}-client`);
+    if (isServer) {
+      const routeServerLoaderContent = import_utils.fs.readFileSync(routeServerLoaderPath, "utf-8");
+      (0, import_ast.generateRoutes)({
+        sourceCode: routeServerLoaderContent,
+        filePath: outputRouteServerLoaderPath
+      });
+    } else {
+      import_utils.fs.writeFileSync(clientRouteServerLoaderPath, `export const routes = []`);
+    }
+    entryMap[entry] = {
+      routesPath: outputFullRoutesPath,
+      routeServerLoaderPath: outputRouteServerLoaderPath,
+      clientRouteServerLoaderPath
+    };
+  };
+  entries.forEach((entry) => {
+    generateEntryRoutes(entry);
+  });
+  return {
+    entryMap
+  };
+}
+function addExpose(options) {
+  const { mfConfig, isServer } = options;
+  const { entryMap } = generateExtraExposeFiles(options);
+  const addExposeByEntry = (entry, routesPath, routeServerLoaderPath, clientRouteServerLoaderPath) => {
+    if (!mfConfig.exposes) {
+      mfConfig.exposes = {};
+    }
+    const routesKey = `./${entry}/${import_constant2.MF_ROUTES}`;
+    if (!mfConfig.exposes[routesKey]) {
+      mfConfig.exposes[routesKey] = routesPath;
+    }
+    const routeServerLoaderKey = `./${entry}/${import_constant.MODERN_JS_ROUTE_SERVER_LOADER}`;
+    if (!mfConfig.exposes[routeServerLoaderKey]) {
+      if (isServer) {
+        mfConfig.exposes[routeServerLoaderKey] = routeServerLoaderPath;
+      } else {
+        mfConfig.exposes[routeServerLoaderKey] = clientRouteServerLoaderPath;
+      }
+    }
+  };
+  Object.keys(entryMap).forEach((entry) => {
+    const { routesPath, routeServerLoaderPath, clientRouteServerLoaderPath } = entryMap[entry];
+    addExposeByEntry(entry, routesPath, routeServerLoaderPath, clientRouteServerLoaderPath);
+  });
+}
+function addShared(options) {
+  const { mfConfig } = options;
+  const styledComponents = `styled-components`;
+  const reactRouterDom = `react-router-dom`;
+  const reactRouterDomServer = `react-router-dom/server`;
+  if (!mfConfig.shared) {
+    mfConfig.shared = {
+      [reactRouterDom]: {
+        singleton: true
+      },
+      [reactRouterDomServer]: {
+        singleton: true
+      },
+      [styledComponents]: {
+        singleton: true
+      }
+    };
+  } else {
+    if (!Array.isArray(mfConfig.shared)) {
+      mfConfig.shared[reactRouterDom] = {
+        singleton: true
+      };
+      mfConfig.shared[reactRouterDomServer] = {
+        singleton: true
+      };
+      mfConfig.shared[styledComponents] = {
+        singleton: true
+      };
+    } else {
+      mfConfig.shared = mfConfig.shared.reduce((sum, cur) => {
+        if (typeof cur === "string") {
+          sum[cur] = {};
+        } else {
+          sum = {
+            ...sum,
+            ...cur
+          };
+        }
+        return sum;
+      }, {});
+      mfConfig.shared[reactRouterDom] = {
+        singleton: true
+      };
+      mfConfig.shared[reactRouterDomServer] = {
+        singleton: true
+      };
+      mfConfig.shared[styledComponents] = {
+        singleton: true
+      };
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  addExpose,
+  addShared
+});

package/dist/cjs/cli/server/fetchRemoteFullRoutesMap.js

@@ -0,0 +1,72 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var fetchRemoteFullRoutesMap_exports = {};
+__export(fetchRemoteFullRoutesMap_exports, {
+  fetchRemoteFullRoutesMap: () => fetchRemoteFullRoutesMap,
+  getSSRByRouteIds: () => getSSRByRouteIds
+});
+module.exports = __toCommonJS(fetchRemoteFullRoutesMap_exports);
+async function fetchRemoteFullRoutesMap(options) {
+  const { instance, remotePath, dataLoaderRemotes } = options;
+  const { remotes } = instance.options;
+  const remoteRoutesMap = {};
+  if (!remotes.length) {
+    return remoteRoutesMap;
+  }
+  await Promise.all(remotes.map(async (remote) => {
+    if (!dataLoaderRemotes.includes(remote.name)) {
+      return;
+    }
+    const remoteId = `${remote.name}/${remotePath}`;
+    const { routes } = await instance.loadRemote(remoteId);
+    remoteRoutesMap[remote.name] = {
+      routes
+    };
+  }));
+  return remoteRoutesMap;
+}
+function getSSRByRouteIds(dataLoaderRemotes, remoteRoutesMap) {
+  const remoteProviderRouteIds = /* @__PURE__ */ new Set();
+  const collectIds = (route) => {
+    remoteProviderRouteIds.add(route.id);
+    if (route.children) {
+      route.children.forEach((r) => {
+        collectIds(r);
+      });
+    }
+  };
+  Object.entries(remoteRoutesMap).forEach((item) => {
+    const [remoteName, routesObj] = item;
+    if (!dataLoaderRemotes.includes(remoteName)) {
+      return;
+    }
+    const { routes } = routesObj;
+    routes.forEach((route) => {
+      collectIds(route);
+    });
+  });
+  return [
+    ...remoteProviderRouteIds
+  ];
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  fetchRemoteFullRoutesMap,
+  getSSRByRouteIds
+});

package/dist/cjs/cli/server/fetchRoutePlugin.js

@@ -0,0 +1,82 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var fetchRoutePlugin_exports = {};
+__export(fetchRoutePlugin_exports, {
+  default: () => fetchRoutePlugin_default
+});
+module.exports = __toCommonJS(fetchRoutePlugin_exports);
+var import_runtime = require("@module-federation/enhanced/runtime");
+var import_sdk = require("@module-federation/sdk");
+var import_fetchRemoteFullRoutesMap = require("./fetchRemoteFullRoutesMap");
+var import_utils = require("../../runtime/routes/utils");
+var import_constant = require("../../constant");
+var fetchRoutePlugin_default = ({ runtimeOptions, dataLoaderRemotes, ssrByRouteIdsMap }) => ({
+  name: "@module-federation/modern-js-fetch-route",
+  pre: [
+    "@modern-js/plugin-inject-resource"
+  ],
+  setup(api) {
+    const { remotes, name } = runtimeOptions;
+    let isHandled = false;
+    return {
+      prepare() {
+        const { middlewares } = api.useAppContext();
+        middlewares.push({
+          name: "MFPatchRouteMiddleWare",
+          handler: async (c, next) => {
+            console.log("MFPatchRouteMiddleWare apply");
+            const serverManifest = c.get("serverManifest");
+            const { loaderBundles, nestedRoutesJson } = serverManifest;
+            if (isHandled && !globalThis.FORCE_MF_REFRESH) {
+              await next();
+            } else {
+              var _api_useConfigContext_server;
+              const instance = (0, import_runtime.init)({
+                name,
+                remotes
+              });
+              const remoteFullRoutesMap = await (0, import_fetchRemoteFullRoutesMap.fetchRemoteFullRoutesMap)({
+                instance,
+                remotePath: (0, import_sdk.isBrowserEnv)() ? `${import_constant.DEFAULT_ENTRY}/${import_constant.MF_ROUTES}` : `${import_constant.DEFAULT_ENTRY}/${import_constant.MODERN_JS_ROUTE_SERVER_LOADER}`,
+                dataLoaderRemotes
+              });
+              const originalSSRByRouteIds = (_api_useConfigContext_server = api.useConfigContext().server) === null || _api_useConfigContext_server === void 0 ? void 0 : _api_useConfigContext_server.ssrByRouteIds;
+              if (originalSSRByRouteIds && dataLoaderRemotes.length) {
+                const remoteSSRByRouteIds = (0, import_fetchRemoteFullRoutesMap.getSSRByRouteIds)(dataLoaderRemotes, remoteFullRoutesMap) || [];
+                const ssrByRouteIds = /* @__PURE__ */ new Set([
+                  ...originalSSRByRouteIds,
+                  ...remoteSSRByRouteIds.map((id) => ssrByRouteIdsMap[id] || id)
+                ]);
+                api.useConfigContext().server.ssrByRouteIds = Array.from(ssrByRouteIds);
+              }
+              (0, import_utils.injectRemoteRoutes)(loaderBundles, remoteFullRoutesMap);
+              (0, import_utils.injectRemoteRoutes)(nestedRoutesJson, remoteFullRoutesMap);
+              isHandled = true;
+              globalThis.FORCE_MF_REFRESH = false;
+              await next();
+            }
+          },
+          before: [
+            "render"
+          ]
+        });
+      }
+    };
+  }
+});

package/dist/cjs/cli/ssrPlugin.js

@@ -39,8 +39,8 @@ var import_webpack = require("@module-federation/enhanced/webpack");
 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_logger = __toESM(require("./logger"));
+var import_constant = require("../constant");
 function setEnv() {
   process.env["MF_DISABLE_EMIT_STATS"] = "true";
   process.env["MF_SSR_PRJ"] = "true";
@@ -54,6 +54,7 @@ const moduleFederationSSRPlugin = (userConfig) => ({
   setup: async ({ useConfigContext, useAppContext }) => {
     var _modernjsConfig_server;
     const modernjsConfig = useConfigContext();
+    const { metaName = import_constant.META_NAME } = userConfig;
     const enableSSR = 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 {};
@@ -70,7 +71,9 @@ const moduleFederationSSRPlugin = (userConfig) => ({
         plugins.push({
           name: "mfSSR",
           path: "@module-federation/modern-js/ssr-runtime",
-          config: {}
+          config: {
+            metaName
+          }
         });
         return {
           entrypoint,