@module-federation/modern-js 0.0.0-next-20240911084000 → 0.0.0-next-20240911090730

package/dist/esm/cli/dataLoader/generateRouteFile.js

@@ -0,0 +1,293 @@
+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 { MF_JSON } from "../../constant";
+import { getRemoteLayoutId } from "../../runtime/dataLoader/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 generateRouteFile(options) {
+  return _generateRouteFile.apply(this, arguments);
+}
+function _generateRouteFile() {
+  _generateRouteFile = _async_to_generator(function(options) {
+    var appDirectory, entries, remotePathMap, srcPath, traverse, traverseRoutes, normalizedEntries;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          appDirectory = options.appDirectory;
+          entries = [];
+          remotePathMap = {};
+          srcPath = "".concat(appDirectory, "/src");
+          traverse = function() {
+            var _ref = _async_to_generator(function(filepath, rootDir, entry) {
+              var isDirectory, items, mfJson, mfJsonContent, remoteName, remoteLayoutId, writeFile, pathname;
+              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,
+                        5
+                      ];
+                    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(id)
+                              ];
+                              return [
+                                4,
+                                fs.writeFile(generatedFilePath, content.join("\n"))
+                              ];
+                            case 1:
+                              _state3.sent();
+                              return [
+                                2
+                              ];
+                          }
+                        });
+                      });
+                      return function writeFile2(id, type, pathname2) {
+                        return _ref2.apply(this, arguments);
+                      };
+                    }();
+                    if (remoteLayoutId) {
+                      pathname = calcPathName(filepath, rootDir, entry);
+                      writeFile(remoteLayoutId, "layout", pathname);
+                      remotePathMap[pathname] = remoteName;
+                    }
+                    return [
+                      2
+                    ];
+                  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,
+                                  traverse(normalizeToPosixPath(path.join(filepath, item)), rootDir, entry)
+                                ];
+                              case 1:
+                                _state3.sent();
+                                return [
+                                  2
+                                ];
+                            }
+                          });
+                        });
+                        return function(item) {
+                          return _ref2.apply(this, arguments);
+                        };
+                      }()))
+                    ];
+                  case 6:
+                    _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,
+                        4
+                      ];
+                    entry = path.relative(srcPath, dir);
+                    entries.push(entry);
+                    rootDir = "".concat(dir, "/").concat(ROUTES);
+                    return [
+                      4,
+                      traverse(rootDir, rootDir, entry)
+                    ];
+                  case 3:
+                    _state2.sent();
+                    return [
+                      3,
+                      6
+                    ];
+                  case 4:
+                    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 5:
+                    _state2.sent();
+                    _state2.label = 6;
+                  case 6:
+                    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 "main";
+            }
+            return entry;
+          });
+          return [
+            2,
+            {
+              entries: normalizedEntries,
+              remotePathMap
+            }
+          ];
+      }
+    });
+  });
+  return _generateRouteFile.apply(this, arguments);
+}
+export {
+  calcPathName,
+  generateRouteFile
+};

package/dist/esm/cli/dataLoader/patchMFConfig.js

@@ -0,0 +1,106 @@
+import { _ as _define_property } from "@swc/helpers/_/_define_property";
+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;
+  if (mfConfig.remotes && mfConfig.exposes) {
+    throw new Error("dataLoader only support for pure provider/consumer!");
+  }
+  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 metaName = options.metaName, mfConfig = options.mfConfig;
+  var alias = "@".concat(metaName, "/runtime/router");
+  if (!mfConfig.shared) {
+    mfConfig.shared = _define_property({}, alias, {
+      singleton: true
+    });
+  } else {
+    if (!Array.isArray(mfConfig.shared)) {
+      mfConfig.shared[alias] = {
+        singleton: true
+      };
+    } else {
+      mfConfig.shared.push(alias);
+    }
+  }
+}
+function patchMFConfig(options) {
+  addShared(options);
+  addExpose(options);
+}
+export {
+  patchMFConfig
+};

package/dist/esm/cli/dataLoader/plugin.js

@@ -0,0 +1,214 @@
+import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _sliced_to_array } from "@swc/helpers/_/_sliced_to_array";
+import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
+import { transformName2Prefix } from "../../runtime/dataLoader/utils";
+import { DEFAULT_ENTRY } from "../../constant";
+import { META_NAME } from "../../constant";
+import { generateRoutes } from "./ast";
+import { generateRouteFile } from "./generateRouteFile";
+import { patchMFConfig } from "./patchMFConfig";
+import path from "path";
+function _transformRuntimeOptions(buildOptions) {
+  var remotes = buildOptions.remotes || {};
+  var runtimeRemotes = Object.entries(remotes).map(function(remote) {
+    var _remote = _sliced_to_array(remote, 2), alias = _remote[0], nameAndEntry = _remote[1];
+    var _nameAndEntry_split = _sliced_to_array(nameAndEntry.split("@"), 2), name = _nameAndEntry_split[0], entry = _nameAndEntry_split[1];
+    return {
+      name,
+      entry,
+      alias
+    };
+  });
+  return {
+    name: buildOptions.name,
+    remotes: runtimeRemotes
+  };
+}
+var moduleFederationDataLoaderPlugin = function(enable, internalOptions, userConfig) {
+  return {
+    name: "@modern-js/plugin-module-federation-data-loader",
+    pre: [
+      "@modern-js/plugin-module-federation-config"
+    ],
+    post: [
+      "@modern-js/plugin-router",
+      "@modern-js/plugin-module-federation"
+    ],
+    setup: function() {
+      var _ref = _async_to_generator(function(param) {
+        var useAppContext, _userConfig_metaName, metaName, _userConfig_serverPlugin, serverPlugin, transformRuntimeOptions, appContext, name, internalDirectory, transformRuntimeFn, partialSSRRemotes, entries, remotePathMap, ssrByRouteIdsMap, serverPluginOptions, csrConfig, _ref2, scanEntries, scanRemotePathMap;
+        return _ts_generator(this, function(_state) {
+          switch (_state.label) {
+            case 0:
+              useAppContext = param.useAppContext;
+              if (!enable) {
+                return [
+                  2
+                ];
+              }
+              _userConfig_metaName = userConfig.metaName, metaName = _userConfig_metaName === void 0 ? META_NAME : _userConfig_metaName, _userConfig_serverPlugin = userConfig.serverPlugin, serverPlugin = _userConfig_serverPlugin === void 0 ? "@module-federation/modern-js/data-loader-server" : _userConfig_serverPlugin, transformRuntimeOptions = userConfig.transformRuntimeOptions;
+              appContext = useAppContext();
+              name = internalOptions.csrConfig.name;
+              internalDirectory = appContext.internalDirectory.replace(META_NAME, metaName || META_NAME);
+              transformRuntimeFn = transformRuntimeOptions || _transformRuntimeOptions;
+              partialSSRRemotes = [];
+              entries = /* @__PURE__ */ new Set();
+              remotePathMap = {};
+              ssrByRouteIdsMap = {};
+              serverPluginOptions = {
+                runtimeOptions: transformRuntimeFn(internalOptions.csrConfig),
+                partialSSRRemotes,
+                ssrByRouteIdsMap
+              };
+              csrConfig = internalOptions.csrConfig;
+              if (!(typeof csrConfig.remotes === "object" && Object.keys(csrConfig.remotes).length))
+                return [
+                  3,
+                  2
+                ];
+              return [
+                4,
+                generateRouteFile({
+                  appDirectory: appContext.appDirectory
+                })
+              ];
+            case 1:
+              _ref2 = _state.sent(), scanEntries = _ref2.entries, scanRemotePathMap = _ref2.remotePathMap;
+              scanEntries.forEach(function(e) {
+                return entries.add(e);
+              });
+              remotePathMap = scanRemotePathMap;
+              return [
+                3,
+                3
+              ];
+            case 2:
+              entries.add(DEFAULT_ENTRY);
+              _state.label = 3;
+            case 3:
+              return [
+                2,
+                {
+                  _internalRuntimePlugins: function(param2) {
+                    var entrypoint = param2.entrypoint, plugins = param2.plugins;
+                    plugins.push({
+                      name: "ssrDataLoader",
+                      path: "@module-federation/modern-js/data-loader",
+                      config: {}
+                    });
+                    plugins.push({
+                      name: "ssrDataLoaderInjectAssets",
+                      path: "@module-federation/modern-js/data-loader-inject-assets",
+                      config: {}
+                    });
+                    return {
+                      entrypoint,
+                      plugins
+                    };
+                  },
+                  _internalServerPlugins: function _internalServerPlugins(param2) {
+                    var plugins = param2.plugins;
+                    plugins.push({
+                      name: serverPlugin,
+                      options: serverPluginOptions
+                    });
+                    return {
+                      plugins
+                    };
+                  },
+                  modifyFileSystemRoutes: function modifyFileSystemRoutes(options) {
+                    return _async_to_generator(function() {
+                      var routes, entrypoint, entryName, prefix, modifyRouteIds;
+                      return _ts_generator(this, function(_state2) {
+                        routes = options.routes, entrypoint = options.entrypoint;
+                        entryName = entrypoint.entryName;
+                        prefix = transformName2Prefix(internalOptions.csrConfig.name);
+                        modifyRouteIds = function(route, pathName) {
+                          var currentPathName = route.path ? path.join(pathName, route.path) : pathName;
+                          if (route.id) {
+                            var _route_children;
+                            var originalId = route.id;
+                            route.originalId = originalId;
+                            var remoteName = remotePathMap[currentPathName];
+                            if (remoteName) {
+                              var remoteIdPrefix = transformName2Prefix(remoteName);
+                              var isLayout = Boolean(route.children);
+                              var newId = "".concat(remoteIdPrefix).concat(isLayout ? "layout" : "page");
+                              ssrByRouteIdsMap[originalId] = newId;
+                              route.id = newId;
+                              if (!partialSSRRemotes.includes(remoteName)) {
+                                partialSSRRemotes.push(remoteName);
+                              }
+                            } else {
+                              route.id = "".concat(prefix).concat(route.id);
+                            }
+                            (_route_children = route.children) === null || _route_children === void 0 ? void 0 : _route_children.forEach(function(r) {
+                              modifyRouteIds(r, currentPathName);
+                            });
+                          }
+                        };
+                        routes.forEach(function(route) {
+                          modifyRouteIds(route, entryName);
+                        });
+                        return [
+                          2,
+                          options
+                        ];
+                      });
+                    })();
+                  },
+                  config: /* @__PURE__ */ _async_to_generator(function() {
+                    return _ts_generator(this, function(_state2) {
+                      return [
+                        2,
+                        {
+                          tools: {
+                            // bundlerChain can not keep target order
+                            rspack: function rspack(_config, param2) {
+                              var isServer = param2.isServer;
+                              patchMFConfig({
+                                mfConfig: isServer ? internalOptions.ssrConfig : internalOptions.csrConfig,
+                                metaName,
+                                isServer,
+                                internalDirectory,
+                                entries
+                              });
+                            },
+                            // bundlerChain can not keep target order
+                            webpack: function webpack(_config, param2) {
+                              var isServer = param2.isServer;
+                              patchMFConfig({
+                                mfConfig: isServer ? internalOptions.ssrConfig : internalOptions.csrConfig,
+                                metaName,
+                                isServer,
+                                internalDirectory,
+                                entries
+                              });
+                            }
+                          },
+                          source: {
+                            define: {
+                              MODERN_ROUTER_ID_PREFIX: JSON.stringify(transformName2Prefix(name))
+                            }
+                          }
+                        }
+                      ];
+                    });
+                  })
+                }
+              ];
+          }
+        });
+      });
+      return function(_) {
+        return _ref.apply(this, arguments);
+      };
+    }()
+  };
+};
+var plugin_default = moduleFederationDataLoaderPlugin;
+export {
+  plugin_default as default,
+  generateRoutes,
+  moduleFederationDataLoaderPlugin
+};

package/dist/esm/cli/index.js

@@ -1,9 +1,11 @@
 import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _object_spread } from "@swc/helpers/_/_object_spread";
 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 { moduleFederationDataLoaderPlugin } from "./dataLoader/plugin";
 var moduleFederationPlugin = function() {
   var userConfig = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
   var internalModernPluginOptions = {
@@ -79,7 +81,8 @@ var moduleFederationPlugin = function() {
     }(),
     usePlugins: [
       moduleFederationConfigPlugin(internalModernPluginOptions),
-      moduleFederationSSRPlugin(internalModernPluginOptions)
+      moduleFederationSSRPlugin(internalModernPluginOptions),
+      moduleFederationDataLoaderPlugin(Boolean(userConfig.dataLoader), internalModernPluginOptions, _object_spread({}, typeof userConfig.dataLoader === "boolean" ? {} : userConfig.dataLoader))
     ]
   };
 };

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

@@ -1,7 +1,7 @@
 import nodeFetch from "node-fetch";
 var injectNodeFetchPlugin = function() {
   return {
-    name: "inject-node-fetch-plugin",
+    name: "node-fetch-plugin",
     beforeInit: function beforeInit(args) {
       if (!globalThis.fetch) {
         globalThis.fetch = nodeFetch;
@@ -10,7 +10,7 @@ var injectNodeFetchPlugin = function() {
     }
   };
 };
-var inject_node_fetch_default = injectNodeFetchPlugin;
+var node_fetch_default = injectNodeFetchPlugin;
 export {
-  inject_node_fetch_default as default
+  node_fetch_default as default
 };

package/dist/esm/cli/mfRuntimePlugins/node.js

@@ -0,0 +1,13 @@
+import nodeRuntimePlugin from "@module-federation/node/runtimePlugin";
+var isContainer = typeof __filename === "string" ? __filename.includes("remote") ? true : false : false;
+var pluginName = "node-plugin-".concat(isContainer);
+var nodePlugin = function() {
+  return {
+    name: pluginName,
+    beforeInit: nodeRuntimePlugin().beforeInit
+  };
+};
+var node_default = nodePlugin;
+export {
+  node_default as default
+};