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

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

@@ -0,0 +1,313 @@
+import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _to_consumable_array } from "@swc/helpers/_/_to_consumable_array";
+import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
+import { fs, normalizeToPosixPath } from "@modern-js/utils";
+import path from "path";
+import os from "os";
+import { DEFAULT_ENTRY, MF_JSON, ROUTE_ID } from "../../constant";
+import { getRemoteLayoutId } from "../../runtime/routes/utils";
+var ROUTES = "routes";
+function calcPathName(filePath, rootDir, entry) {
+  var relativePath = path.relative(rootDir, filePath);
+  var conditionalReg = /^\[(.*)\]$/;
+  var splitPaths = relativePath.split("/").reduce(function(sum, cur) {
+    if (cur.includes(".")) {
+      var _sum;
+      var split = cur.split(".").map(function(i) {
+        var match2 = i.match(conditionalReg);
+        if (match2) {
+          return ":".concat(match2[1]);
+        }
+        return i.startsWith("__") ? "" : i;
+      });
+      (_sum = sum).push.apply(_sum, _to_consumable_array(split));
+    } else {
+      var match = cur.match(conditionalReg);
+      if (match) {
+        sum.push(":".concat(match[1]));
+      } else {
+        if (!cur.startsWith("__")) {
+          sum.push(cur);
+        }
+      }
+    }
+    return sum;
+  }, []);
+  return path.join("/", entry, splitPaths.filter(function(p) {
+    return !!p;
+  }).join("/"));
+}
+function traverseRouteFiles(options) {
+  return _traverseRouteFiles.apply(this, arguments);
+}
+function _traverseRouteFiles() {
+  _traverseRouteFiles = _async_to_generator(function(options) {
+    var appDirectory, generateRouteFile, remotePathMap, entries, srcPath, traverse, traverseRoutes, normalizedEntries;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          appDirectory = options.appDirectory, generateRouteFile = options.generateRouteFile, remotePathMap = options.remotePathMap;
+          entries = [];
+          srcPath = "".concat(appDirectory, "/src");
+          traverse = function() {
+            var _ref = _async_to_generator(function(filepath, rootDir, entry) {
+              var isDirectory, items, mfJson, mfJsonContent, remoteName, remoteLayoutId, writeFile, pathname, filePath;
+              return _ts_generator(this, function(_state2) {
+                switch (_state2.label) {
+                  case 0:
+                    return [
+                      4,
+                      fs.pathExists(filepath)
+                    ];
+                  case 1:
+                    if (!_state2.sent()) {
+                      return [
+                        2,
+                        null
+                      ];
+                    }
+                    return [
+                      4,
+                      fs.stat(filepath)
+                    ];
+                  case 2:
+                    isDirectory = _state2.sent().isDirectory();
+                    if (!isDirectory) {
+                      return [
+                        2,
+                        null
+                      ];
+                    }
+                    return [
+                      4,
+                      fs.readdir(filepath)
+                    ];
+                  case 3:
+                    items = _state2.sent();
+                    mfJson = items.find(function(i) {
+                      return i === MF_JSON;
+                    });
+                    if (!mfJson)
+                      return [
+                        3,
+                        7
+                      ];
+                    return [
+                      4,
+                      fs.readJSON(normalizeToPosixPath(path.join(filepath, mfJson)))
+                    ];
+                  case 4:
+                    mfJsonContent = _state2.sent();
+                    remoteName = mfJsonContent.remoteName;
+                    remoteLayoutId = getRemoteLayoutId(remoteName);
+                    writeFile = function() {
+                      var _ref2 = _async_to_generator(function(id, type, pathname2) {
+                        var generatedFilePath, content;
+                        return _ts_generator(this, function(_state3) {
+                          switch (_state3.label) {
+                            case 0:
+                              generatedFilePath = normalizeToPosixPath(path.join(filepath, "".concat(type, ".tsx")));
+                              content = [
+                                "// Do not edit this file. It is a auto generated.",
+                                "// It will render ".concat(remoteName, "'s ").concat(type, "."),
+                                "// The ".concat(type, " pathname is: ").concat(pathname2),
+                                "// The ".concat(type, " route id is: ").concat(ROUTE_ID)
+                              ];
+                              return [
+                                4,
+                                fs.writeFile(generatedFilePath, content.join(os.EOL))
+                              ];
+                            case 1:
+                              _state3.sent();
+                              return [
+                                2,
+                                generatedFilePath
+                              ];
+                          }
+                        });
+                      });
+                      return function writeFile2(id, type, pathname2) {
+                        return _ref2.apply(this, arguments);
+                      };
+                    }();
+                    if (!remoteLayoutId)
+                      return [
+                        3,
+                        6
+                      ];
+                    pathname = calcPathName(filepath, rootDir, entry);
+                    return [
+                      4,
+                      writeFile(remoteLayoutId, "layout", pathname)
+                    ];
+                  case 5:
+                    filePath = _state2.sent();
+                    remotePathMap[pathname] = {
+                      name: remoteName,
+                      path: filePath
+                    };
+                    _state2.label = 6;
+                  case 6:
+                    return [
+                      2
+                    ];
+                  case 7:
+                    return [
+                      4,
+                      Promise.all(items.map(function() {
+                        var _ref2 = _async_to_generator(function(item) {
+                          return _ts_generator(this, function(_state3) {
+                            switch (_state3.label) {
+                              case 0:
+                                return [
+                                  4,
+                                  traverse(normalizeToPosixPath(path.join(filepath, item)), rootDir, entry)
+                                ];
+                              case 1:
+                                _state3.sent();
+                                return [
+                                  2
+                                ];
+                            }
+                          });
+                        });
+                        return function(item) {
+                          return _ref2.apply(this, arguments);
+                        };
+                      }()))
+                    ];
+                  case 8:
+                    _state2.sent();
+                    return [
+                      2
+                    ];
+                }
+              });
+            });
+            return function traverse2(filepath, rootDir, entry) {
+              return _ref.apply(this, arguments);
+            };
+          }();
+          traverseRoutes = function() {
+            var _ref = _async_to_generator(function(dir) {
+              var level, isDirectory, items, entry, rootDir;
+              var _arguments = arguments;
+              return _ts_generator(this, function(_state2) {
+                switch (_state2.label) {
+                  case 0:
+                    level = _arguments.length > 1 && _arguments[1] !== void 0 ? _arguments[1] : 1;
+                    if (level > 3) {
+                      return [
+                        2
+                      ];
+                    }
+                    return [
+                      4,
+                      fs.stat(dir)
+                    ];
+                  case 1:
+                    isDirectory = _state2.sent().isDirectory();
+                    if (!isDirectory) {
+                      return [
+                        2
+                      ];
+                    }
+                    return [
+                      4,
+                      fs.readdir(dir)
+                    ];
+                  case 2:
+                    items = _state2.sent();
+                    if (!items.find(function(i) {
+                      return i === ROUTES;
+                    }))
+                      return [
+                        3,
+                        5
+                      ];
+                    entry = path.relative(srcPath, dir);
+                    entries.push(entry);
+                    rootDir = "".concat(dir, "/").concat(ROUTES);
+                    if (!generateRouteFile)
+                      return [
+                        3,
+                        4
+                      ];
+                    return [
+                      4,
+                      traverse(rootDir, rootDir, entry)
+                    ];
+                  case 3:
+                    _state2.sent();
+                    _state2.label = 4;
+                  case 4:
+                    return [
+                      3,
+                      7
+                    ];
+                  case 5:
+                    return [
+                      4,
+                      Promise.all(items.map(function() {
+                        var _ref2 = _async_to_generator(function(item) {
+                          return _ts_generator(this, function(_state3) {
+                            switch (_state3.label) {
+                              case 0:
+                                return [
+                                  4,
+                                  traverseRoutes(path.join(dir, item), level++)
+                                ];
+                              case 1:
+                                _state3.sent();
+                                return [
+                                  2
+                                ];
+                            }
+                          });
+                        });
+                        return function(item) {
+                          return _ref2.apply(this, arguments);
+                        };
+                      }()))
+                    ];
+                  case 6:
+                    _state2.sent();
+                    _state2.label = 7;
+                  case 7:
+                    return [
+                      2
+                    ];
+                }
+              });
+            });
+            return function traverseRoutes2(dir) {
+              return _ref.apply(this, arguments);
+            };
+          }();
+          return [
+            4,
+            traverseRoutes(srcPath)
+          ];
+        case 1:
+          _state.sent();
+          normalizedEntries = entries.map(function(entry) {
+            if (entry === "") {
+              return DEFAULT_ENTRY;
+            }
+            return entry;
+          });
+          return [
+            2,
+            {
+              entries: normalizedEntries
+            }
+          ];
+      }
+    });
+  });
+  return _traverseRouteFiles.apply(this, arguments);
+}
+export {
+  calcPathName,
+  traverseRouteFiles
+};

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

@@ -0,0 +1,130 @@
+import { _ as _define_property } from "@swc/helpers/_/_define_property";
+import { _ as _object_spread } from "@swc/helpers/_/_object_spread";
+import path from "path";
+import { fs } from "@modern-js/utils";
+import { MODERN_JS_ROUTE_SERVER_LOADER } from "../../constant";
+import { MF_ROUTES, MODERN_JS_FILE_SYSTEM_ROUTES_FILE_NAME } from "../../constant";
+import { generateRoutes } from "./ast";
+function generateExtraExposeFiles(options) {
+  var internalDirectory = options.internalDirectory, mfConfig = options.mfConfig, isServer = options.isServer, entries = options.entries;
+  var entryMap = {};
+  var outputDir = path.resolve(process.cwd(), "node_modules/.federation/data-loader");
+  fs.ensureDirSync(outputDir);
+  var addSuffix = function(fileName) {
+    var ext = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : ".jsx";
+    if (!isServer) {
+      return "".concat(fileName).concat(ext);
+    }
+    return "".concat(fileName, ".server").concat(ext);
+  };
+  var generateEntryRoutes = function(entry) {
+    var outputEntryDir = path.resolve(outputDir, entry);
+    fs.ensureDirSync(outputEntryDir);
+    var sourceDir = path.resolve(internalDirectory, entry);
+    var routesFilePath = path.resolve(sourceDir, addSuffix(MODERN_JS_FILE_SYSTEM_ROUTES_FILE_NAME, ".js"));
+    var routesFileContent = fs.readFileSync(routesFilePath, "utf-8");
+    var outputFullRoutesPath = path.resolve(outputEntryDir, addSuffix(MF_ROUTES));
+    generateRoutes({
+      sourceCode: routesFileContent,
+      filePath: outputFullRoutesPath
+    });
+    var routeServerLoaderPath = path.resolve(sourceDir, "".concat(MODERN_JS_ROUTE_SERVER_LOADER, ".js"));
+    var outputRouteServerLoaderPath = path.resolve(outputEntryDir, "".concat(MODERN_JS_ROUTE_SERVER_LOADER, ".js"));
+    var clientRouteServerLoaderPath = outputRouteServerLoaderPath.replace(MODERN_JS_ROUTE_SERVER_LOADER, "".concat(MODERN_JS_ROUTE_SERVER_LOADER, "-client"));
+    if (isServer) {
+      var routeServerLoaderContent = fs.readFileSync(routeServerLoaderPath, "utf-8");
+      generateRoutes({
+        sourceCode: routeServerLoaderContent,
+        filePath: outputRouteServerLoaderPath
+      });
+    } else {
+      fs.writeFileSync(clientRouteServerLoaderPath, "export const routes = []");
+    }
+    entryMap[entry] = {
+      routesPath: outputFullRoutesPath,
+      routeServerLoaderPath: outputRouteServerLoaderPath,
+      clientRouteServerLoaderPath
+    };
+  };
+  entries.forEach(function(entry) {
+    generateEntryRoutes(entry);
+  });
+  return {
+    entryMap
+  };
+}
+function addExpose(options) {
+  var mfConfig = options.mfConfig, isServer = options.isServer;
+  var entryMap = generateExtraExposeFiles(options).entryMap;
+  var addExposeByEntry = function(entry, routesPath, routeServerLoaderPath, clientRouteServerLoaderPath) {
+    if (!mfConfig.exposes) {
+      mfConfig.exposes = {};
+    }
+    var routesKey = "./".concat(entry, "/").concat(MF_ROUTES);
+    if (!mfConfig.exposes[routesKey]) {
+      mfConfig.exposes[routesKey] = routesPath;
+    }
+    var routeServerLoaderKey = "./".concat(entry, "/").concat(MODERN_JS_ROUTE_SERVER_LOADER);
+    if (!mfConfig.exposes[routeServerLoaderKey]) {
+      if (isServer) {
+        mfConfig.exposes[routeServerLoaderKey] = routeServerLoaderPath;
+      } else {
+        mfConfig.exposes[routeServerLoaderKey] = clientRouteServerLoaderPath;
+      }
+    }
+  };
+  Object.keys(entryMap).forEach(function(entry) {
+    var _entryMap_entry = entryMap[entry], routesPath = _entryMap_entry.routesPath, routeServerLoaderPath = _entryMap_entry.routeServerLoaderPath, clientRouteServerLoaderPath = _entryMap_entry.clientRouteServerLoaderPath;
+    addExposeByEntry(entry, routesPath, routeServerLoaderPath, clientRouteServerLoaderPath);
+  });
+}
+function addShared(options) {
+  var mfConfig = options.mfConfig;
+  var styledComponents = "styled-components";
+  var reactRouterDom = "react-router-dom";
+  var reactRouterDomServer = "react-router-dom/server";
+  if (!mfConfig.shared) {
+    var _obj;
+    mfConfig.shared = (_obj = {}, _define_property(_obj, reactRouterDom, {
+      singleton: true
+    }), _define_property(_obj, reactRouterDomServer, {
+      singleton: true
+    }), _define_property(_obj, styledComponents, {
+      singleton: true
+    }), _obj);
+  } 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(function(sum, cur) {
+        if (typeof cur === "string") {
+          sum[cur] = {};
+        } else {
+          sum = _object_spread({}, sum, cur);
+        }
+        return sum;
+      }, {});
+      mfConfig.shared[reactRouterDom] = {
+        singleton: true
+      };
+      mfConfig.shared[reactRouterDomServer] = {
+        singleton: true
+      };
+      mfConfig.shared[styledComponents] = {
+        singleton: true
+      };
+    }
+  }
+}
+export {
+  addExpose,
+  addShared
+};

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

@@ -0,0 +1,93 @@
+import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _sliced_to_array } from "@swc/helpers/_/_sliced_to_array";
+import { _ as _to_consumable_array } from "@swc/helpers/_/_to_consumable_array";
+import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
+function fetchRemoteFullRoutesMap(options) {
+  return _fetchRemoteFullRoutesMap.apply(this, arguments);
+}
+function _fetchRemoteFullRoutesMap() {
+  _fetchRemoteFullRoutesMap = _async_to_generator(function(options) {
+    var instance, remotePath, dataLoaderRemotes, remotes, remoteRoutesMap;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          instance = options.instance, remotePath = options.remotePath, dataLoaderRemotes = options.dataLoaderRemotes;
+          remotes = instance.options.remotes;
+          remoteRoutesMap = {};
+          if (!remotes.length) {
+            return [
+              2,
+              remoteRoutesMap
+            ];
+          }
+          return [
+            4,
+            Promise.all(remotes.map(function() {
+              var _ref = _async_to_generator(function(remote) {
+                var remoteId, routes;
+                return _ts_generator(this, function(_state2) {
+                  switch (_state2.label) {
+                    case 0:
+                      if (!dataLoaderRemotes.includes(remote.name)) {
+                        return [
+                          2
+                        ];
+                      }
+                      remoteId = "".concat(remote.name, "/").concat(remotePath);
+                      return [
+                        4,
+                        instance.loadRemote(remoteId)
+                      ];
+                    case 1:
+                      routes = _state2.sent().routes;
+                      remoteRoutesMap[remote.name] = {
+                        routes
+                      };
+                      return [
+                        2
+                      ];
+                  }
+                });
+              });
+              return function(remote) {
+                return _ref.apply(this, arguments);
+              };
+            }()))
+          ];
+        case 1:
+          _state.sent();
+          return [
+            2,
+            remoteRoutesMap
+          ];
+      }
+    });
+  });
+  return _fetchRemoteFullRoutesMap.apply(this, arguments);
+}
+function getSSRByRouteIds(dataLoaderRemotes, remoteRoutesMap) {
+  var remoteProviderRouteIds = /* @__PURE__ */ new Set();
+  var collectIds = function(route) {
+    remoteProviderRouteIds.add(route.id);
+    if (route.children) {
+      route.children.forEach(function(r) {
+        collectIds(r);
+      });
+    }
+  };
+  Object.entries(remoteRoutesMap).forEach(function(item) {
+    var _item = _sliced_to_array(item, 2), remoteName = _item[0], routesObj = _item[1];
+    if (!dataLoaderRemotes.includes(remoteName)) {
+      return;
+    }
+    var routes = routesObj.routes;
+    routes.forEach(function(route) {
+      collectIds(route);
+    });
+  });
+  return _to_consumable_array(remoteProviderRouteIds);
+}
+export {
+  fetchRemoteFullRoutesMap,
+  getSSRByRouteIds
+};

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

@@ -0,0 +1,105 @@
+import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _to_consumable_array } from "@swc/helpers/_/_to_consumable_array";
+import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
+import { init } from "@module-federation/enhanced/runtime";
+import { isBrowserEnv } from "@module-federation/sdk";
+import { fetchRemoteFullRoutesMap, getSSRByRouteIds } from "./fetchRemoteFullRoutesMap";
+import { injectRemoteRoutes } from "../../runtime/routes/utils";
+import { MF_ROUTES, DEFAULT_ENTRY, MODERN_JS_ROUTE_SERVER_LOADER } from "../../constant";
+function fetchRoutePlugin_default(param) {
+  var runtimeOptions = param.runtimeOptions, dataLoaderRemotes = param.dataLoaderRemotes, ssrByRouteIdsMap = param.ssrByRouteIdsMap;
+  return {
+    name: "@module-federation/modern-js-fetch-route",
+    pre: [
+      "@modern-js/plugin-inject-resource"
+    ],
+    setup: function setup(api) {
+      var remotes = runtimeOptions.remotes, name = runtimeOptions.name;
+      var isHandled = false;
+      return {
+        prepare: function prepare() {
+          var middlewares = api.useAppContext().middlewares;
+          middlewares.push({
+            name: "MFPatchRouteMiddleWare",
+            handler: function() {
+              var _ref = _async_to_generator(function(c, next) {
+                var serverManifest, loaderBundles, nestedRoutesJson, _api_useConfigContext_server, instance, remoteFullRoutesMap, originalSSRByRouteIds, remoteSSRByRouteIds, ssrByRouteIds;
+                return _ts_generator(this, function(_state) {
+                  switch (_state.label) {
+                    case 0:
+                      console.log("MFPatchRouteMiddleWare apply");
+                      serverManifest = c.get("serverManifest");
+                      loaderBundles = serverManifest.loaderBundles, nestedRoutesJson = serverManifest.nestedRoutesJson;
+                      if (!(isHandled && !globalThis.FORCE_MF_REFRESH))
+                        return [
+                          3,
+                          2
+                        ];
+                      return [
+                        4,
+                        next()
+                      ];
+                    case 1:
+                      _state.sent();
+                      return [
+                        3,
+                        5
+                      ];
+                    case 2:
+                      instance = init({
+                        name,
+                        remotes
+                      });
+                      return [
+                        4,
+                        fetchRemoteFullRoutesMap({
+                          instance,
+                          remotePath: isBrowserEnv() ? "".concat(DEFAULT_ENTRY, "/").concat(MF_ROUTES) : "".concat(DEFAULT_ENTRY, "/").concat(MODERN_JS_ROUTE_SERVER_LOADER),
+                          dataLoaderRemotes
+                        })
+                      ];
+                    case 3:
+                      remoteFullRoutesMap = _state.sent();
+                      originalSSRByRouteIds = (_api_useConfigContext_server = api.useConfigContext().server) === null || _api_useConfigContext_server === void 0 ? void 0 : _api_useConfigContext_server.ssrByRouteIds;
+                      if (originalSSRByRouteIds && dataLoaderRemotes.length) {
+                        remoteSSRByRouteIds = getSSRByRouteIds(dataLoaderRemotes, remoteFullRoutesMap) || [];
+                        ssrByRouteIds = new Set(_to_consumable_array(originalSSRByRouteIds).concat(_to_consumable_array(remoteSSRByRouteIds.map(function(id) {
+                          return ssrByRouteIdsMap[id] || id;
+                        }))));
+                        api.useConfigContext().server.ssrByRouteIds = Array.from(ssrByRouteIds);
+                      }
+                      injectRemoteRoutes(loaderBundles, remoteFullRoutesMap);
+                      injectRemoteRoutes(nestedRoutesJson, remoteFullRoutesMap);
+                      isHandled = true;
+                      globalThis.FORCE_MF_REFRESH = false;
+                      return [
+                        4,
+                        next()
+                      ];
+                    case 4:
+                      _state.sent();
+                      _state.label = 5;
+                    case 5:
+                      return [
+                        2
+                      ];
+                  }
+                });
+              });
+              return function(c, next) {
+                return _ref.apply(this, arguments);
+              };
+            }(),
+            before: [
+              "render"
+            ]
+          });
+        }
+      };
+    }
+  };
+}
+;
+export {
+  fetchRoutePlugin_default as default
+};

package/dist/esm/cli/ssrPlugin.js

@@ -6,8 +6,8 @@ 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 { isDev, META_NAME } from "../constant";
 function setEnv() {
   process.env["MF_DISABLE_EMIT_STATS"] = "true";
   process.env["MF_SSR_PRJ"] = "true";
@@ -21,10 +21,11 @@ var moduleFederationSSRPlugin = function(userConfig) {
     ],
     setup: function() {
       var _ref = _async_to_generator(function(param) {
-        var useConfigContext, useAppContext, _modernjsConfig_server, modernjsConfig, enableSSR;
+        var useConfigContext, useAppContext, _modernjsConfig_server, modernjsConfig, _userConfig_metaName, metaName, enableSSR;
         return _ts_generator(this, function(_state) {
           useConfigContext = param.useConfigContext, useAppContext = param.useAppContext;
           modernjsConfig = useConfigContext();
+          _userConfig_metaName = userConfig.metaName, metaName = _userConfig_metaName === void 0 ? META_NAME : _userConfig_metaName;
           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 [
@@ -47,7 +48,9 @@ var moduleFederationSSRPlugin = function(userConfig) {
                 plugins.push({
                   name: "mfSSR",
                   path: "@module-federation/modern-js/ssr-runtime",
-                  config: {}
+                  config: {
+                    metaName
+                  }
                 });
                 return {
                   entrypoint,