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

package/dist/esm/cli/routes/ast/generateRoutes.js

@@ -0,0 +1,110 @@
+import { _ as _to_consumable_array } from "@swc/helpers/_/_to_consumable_array";
+import fs from "fs";
+import traverse from "@babel/traverse";
+import * as babelParser from "@babel/parser";
+import generate from "@babel/generator";
+import * as t from "@babel/types";
+function findTargetKeyNode(nodeProperties, key) {
+  return nodeProperties.find(function(p) {
+    return t.isObjectProperty(p) && t.isStringLiteral(p.key) && p.key.value === key;
+  });
+}
+function generateRoutes(param) {
+  var sourceCode = param.sourceCode, filePath = param.filePath;
+  var ast = babelParser.parse(sourceCode, {
+    sourceType: "module"
+  });
+  var lazyComponentDeclarations = [];
+  var componentDeclarations = [];
+  var componentId = 0;
+  traverse(ast, {
+    // ImportDeclaration(path) {
+    //   const source = path.node.source.value;
+    //   const routeIdMatch = source.match(/routeId=([^&]+)/);
+    //   if (routeIdMatch) {
+    //     const originalRouteId = routeIdMatch[1];
+    //     const newRouteId = `${prefix}${originalRouteId}`;
+    //     const newSource = source.replace(
+    //       /routeId=[^&]+/,
+    //       `routeId=${newRouteId}`,
+    //     );
+    //     path.node.source = t.stringLiteral(newSource);
+    //   }
+    // },
+    ObjectExpression: function ObjectExpression(path) {
+      var componentName = "";
+      var lazyComponentName = "";
+      if (!Array.isArray(path.node.properties)) {
+        return;
+      }
+      var idNode = findTargetKeyNode(path.node.properties, "id");
+      if (idNode && t.isObjectProperty(idNode) && t.isStringLiteral(idNode.value)) {
+      }
+      var isRootNode = findTargetKeyNode(path.node.properties, "isRoot");
+      if (isRootNode && t.isObjectProperty(isRootNode) && t.isBooleanLiteral(isRootNode.value)) {
+        isRootNode.value.value = false;
+      }
+      var lazyComponentNode = findTargetKeyNode(path.node.properties, "lazyImport");
+      if (lazyComponentNode && t.isObjectProperty(lazyComponentNode) && t.isArrowFunctionExpression(lazyComponentNode.value)) {
+        lazyComponentName = "LazyComponent_".concat(componentId);
+        var lazyDeclaration = t.variableDeclaration("const", [
+          t.variableDeclarator(t.identifier(lazyComponentName), lazyComponentNode.value)
+        ]);
+        lazyComponentNode.value = t.identifier(lazyComponentName);
+        var componentNode = findTargetKeyNode(path.node.properties, "component");
+        if (componentNode && t.isObjectProperty(componentNode) && t.isCallExpression(componentNode.value) && t.isIdentifier(componentNode.value.callee)) {
+          componentNode.value = t.callExpression(t.identifier("lazy"), [
+            t.identifier(lazyComponentName)
+          ]);
+        }
+        lazyComponentDeclarations.push(lazyDeclaration);
+      }
+      var componentNode1 = findTargetKeyNode(path.node.properties, "component");
+      if (componentNode1 && t.isObjectProperty(componentNode1) && t.isCallExpression(componentNode1.value) && t.isIdentifier(componentNode1.value.callee)) {
+        componentName = "Component_".concat(componentId);
+        var componentDeclaration = t.variableDeclaration("const", [
+          t.variableDeclarator(t.identifier(componentName), lazyComponentName ? t.callExpression(t.identifier("lazy"), [
+            t.identifier(lazyComponentName)
+          ]) : componentNode1.value)
+        ]);
+        componentDeclarations.push(componentDeclaration);
+        componentNode1.value = t.identifier(componentName);
+      }
+      if (lazyComponentName || componentName) {
+        componentId++;
+        if (componentName) {
+          var upperFirstName = componentName.slice(0, 1).toUpperCase() + componentName.slice(1);
+          var jsxElement = t.jsxElement(t.jsxOpeningElement(t.jsxIdentifier(upperFirstName), [], true), null, [], true);
+          path.node.properties.push(t.objectProperty(t.identifier("element"), jsxElement));
+        } else {
+          path.node.properties.push(t.objectProperty(t.identifier("Component"), t.callExpression(t.identifier("lazy"), [
+            t.identifier(lazyComponentName)
+          ])));
+        }
+      }
+    }
+  });
+  traverse(ast, {
+    Program: function Program(path) {
+      var lastImportIndex = path.get("body").reduce(function(lastIndex, p, index) {
+        if (t.isImportDeclaration(p.node)) {
+          lastIndex = index;
+        }
+        return lastIndex;
+      }, -1);
+      if (lastImportIndex >= 0) {
+        var lastImport = path.get("body.".concat(lastImportIndex));
+        _to_consumable_array(componentDeclarations).concat(_to_consumable_array(lazyComponentDeclarations)).forEach(function(declaration) {
+          if ("insertAfter" in lastImport) {
+            lastImport.insertAfter(declaration);
+          }
+        });
+      }
+    }
+  });
+  var code = generate(ast).code;
+  fs.writeFileSync(filePath, code);
+}
+export {
+  generateRoutes
+};

package/dist/esm/cli/routes/ast/index.js

@@ -0,0 +1,4 @@
+import { generateRoutes } from "./generateRoutes";
+export {
+  generateRoutes
+};

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

@@ -0,0 +1,34 @@
+import { _ as _type_of } from "@swc/helpers/_/_type_of";
+function clearMFCache() {
+  if (!globalThis.__FEDERATION__) {
+    console.log("clearMFCache no globalThis.__FEDERATION__");
+    return;
+  }
+  globalThis.__FEDERATION__.__INSTANCES__.map(function(i) {
+    i.moduleCache.forEach(function(mc) {
+      if (mc.remoteInfo && mc.remoteInfo.entryGlobalName) {
+        delete globalThis[mc.remoteInfo.entryGlobalName];
+      }
+    });
+    i.moduleCache.clear();
+    if (globalThis[i.name]) {
+      delete globalThis[i.name];
+    }
+  });
+  Object.keys(globalThis.__FEDERATION__).forEach(function(key) {
+    if (Array.isArray(globalThis.__FEDERATION__[key])) {
+      globalThis.__FEDERATION__[key] = [];
+    } else if (key === "__PRELOADED_MAP__") {
+      globalThis.__FEDERATION__[key] = /* @__PURE__ */ new Map();
+    } else if (_type_of(globalThis.__FEDERATION__[key]) === "object") {
+      globalThis.__FEDERATION__[key] = {};
+    }
+  });
+  if (globalThis.__GLOBAL_LOADING_REMOTE_ENTRY__) {
+    globalThis.__GLOBAL_LOADING_REMOTE_ENTRY__ = {};
+  }
+  globalThis.FORCE_MF_REFRESH = true;
+}
+export {
+  clearMFCache
+};

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

@@ -0,0 +1,79 @@
+import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
+import { META_NAME } from "../../constant";
+import { addExpose } from "./utils";
+var moduleFederationExportRoutePlugin = function(param) {
+  var userConfig = param.userConfig, internalOptions = param.internalOptions, entries = param.entries;
+  return {
+    name: "@modern-js/plugin-module-federation-export-routes",
+    pre: [
+      "@modern-js/plugin-module-federation-route"
+    ],
+    post: [
+      "@modern-js/plugin-router",
+      "@modern-js/plugin-module-federation"
+    ],
+    setup: function() {
+      var _ref = _async_to_generator(function(param2) {
+        var useAppContext, appContext, _internalOptions_metaName, metaName, internalDirectory;
+        return _ts_generator(this, function(_state) {
+          useAppContext = param2.useAppContext;
+          if (!userConfig.exportRoutes) {
+            return [
+              2
+            ];
+          }
+          appContext = useAppContext();
+          _internalOptions_metaName = internalOptions.metaName, metaName = _internalOptions_metaName === void 0 ? META_NAME : _internalOptions_metaName;
+          internalDirectory = appContext.internalDirectory.replace(META_NAME, metaName || META_NAME);
+          return [
+            2,
+            {
+              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, param3) {
+                          var isServer = param3.isServer;
+                          addExpose({
+                            mfConfig: isServer ? internalOptions.ssrConfig : internalOptions.csrConfig,
+                            metaName,
+                            isServer,
+                            internalDirectory,
+                            entries
+                          });
+                        },
+                        // bundlerChain can not keep target order
+                        webpack: function webpack(_config, param3) {
+                          var isServer = param3.isServer;
+                          addExpose({
+                            mfConfig: isServer ? internalOptions.ssrConfig : internalOptions.csrConfig,
+                            metaName,
+                            isServer,
+                            internalDirectory,
+                            entries
+                          });
+                        }
+                      }
+                    }
+                  ];
+                });
+              })
+            }
+          ];
+        });
+      });
+      return function(_) {
+        return _ref.apply(this, arguments);
+      };
+    }()
+  };
+};
+var exportRoutePlugin_default = moduleFederationExportRoutePlugin;
+export {
+  exportRoutePlugin_default as default,
+  moduleFederationExportRoutePlugin
+};

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

@@ -0,0 +1,122 @@
+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";
+import { META_NAME } from "../../constant";
+import { clearMFCache } from "./clearMFCache";
+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 moduleFederationImportRoutePlugin = function(param) {
+  var userConfig = param.userConfig, internalOptions = param.internalOptions, remotePathMap = param.remotePathMap, _param_serverPlugin = param.serverPlugin, serverPlugin = _param_serverPlugin === void 0 ? "@module-federation/modern-js/fetch-router-server-plugin" : _param_serverPlugin, ssrByRouteIdsMap = param.ssrByRouteIdsMap, transformRuntimeOptions = param.transformRuntimeOptions;
+  return {
+    name: "@modern-js/plugin-module-federation-import-routes",
+    pre: [
+      "@modern-js/plugin-module-federation-route"
+    ],
+    post: [
+      "@modern-js/plugin-router",
+      "@modern-js/plugin-module-federation"
+    ],
+    setup: /* @__PURE__ */ _async_to_generator(function() {
+      var _internalOptions_metaName, metaName, transformRuntimeFn, dataLoaderRemotes, serverPluginOptions, hasDataLoaderRemotes;
+      return _ts_generator(this, function(_state) {
+        if (!userConfig.importRoutes) {
+          return [
+            2
+          ];
+        }
+        _internalOptions_metaName = internalOptions.metaName, metaName = _internalOptions_metaName === void 0 ? META_NAME : _internalOptions_metaName;
+        transformRuntimeFn = transformRuntimeOptions || _transformRuntimeOptions;
+        dataLoaderRemotes = _to_consumable_array(new Set(Object.values(remotePathMap).map(function(i) {
+          return i.name;
+        })));
+        serverPluginOptions = {
+          runtimeOptions: transformRuntimeFn(internalOptions.csrConfig),
+          dataLoaderRemotes,
+          ssrByRouteIdsMap
+        };
+        hasDataLoaderRemotes = function() {
+          return Boolean(serverPluginOptions.dataLoaderRemotes.length);
+        };
+        return [
+          2,
+          {
+            _internalRuntimePlugins: function(param2) {
+              var entrypoint = param2.entrypoint, plugins = param2.plugins;
+              if (!hasDataLoaderRemotes()) {
+                return {
+                  entrypoint,
+                  plugins
+                };
+              }
+              plugins.push({
+                name: "ssrDataLoader",
+                path: "@module-federation/modern-js/routes",
+                config: {
+                  metaName,
+                  dataLoaderRemotes
+                }
+              });
+              plugins.push({
+                name: "ssrDataLoaderInjectAssets",
+                path: "@module-federation/modern-js/routes-inject-assets",
+                config: {
+                  metaName,
+                  dataLoaderRemotes
+                }
+              });
+              return {
+                entrypoint,
+                plugins
+              };
+            },
+            _internalServerPlugins: function _internalServerPlugins(param2) {
+              var plugins = param2.plugins;
+              if (!hasDataLoaderRemotes()) {
+                return {
+                  plugins
+                };
+              }
+              plugins.push({
+                name: serverPlugin,
+                options: serverPluginOptions
+              });
+              return {
+                plugins
+              };
+            },
+            afterDev: function afterDev() {
+              return _async_to_generator(function() {
+                return _ts_generator(this, function(_state2) {
+                  clearMFCache();
+                  return [
+                    2
+                  ];
+                });
+              })();
+            }
+          }
+        ];
+      });
+    })
+  };
+};
+var importRoutesPlugin_default = moduleFederationImportRoutePlugin;
+export {
+  importRoutesPlugin_default as default,
+  moduleFederationImportRoutePlugin
+};

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

@@ -0,0 +1,266 @@
+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 "@modern-js/utils";
+import { transformName2Prefix } from "../../runtime/routes/utils";
+import { META_NAME } from "../../constant";
+import { traverseRouteFiles } from "./traverseRouteFiles";
+import { moduleFederationExportRoutePlugin } from "./exportRoutePlugin";
+import { moduleFederationImportRoutePlugin } from "./importRoutesPlugin";
+import { addShared } from "./utils";
+import { DEFAULT_ENTRY, ROUTE_ID } from "../../constant";
+var moduleFederationRoutesPlugin = function(param) {
+  var userConfig = param.userConfig, internalOptions = param.internalOptions, serverPlugin = param.serverPlugin, transformRuntimeOptions = param.transformRuntimeOptions;
+  var entries = /* @__PURE__ */ new Set();
+  var remotePathMap = {};
+  var ssrByRouteIdsMap = {};
+  var internalRoutesPluginOptions = {
+    userConfig,
+    internalOptions,
+    entries,
+    remotePathMap,
+    ssrByRouteIdsMap,
+    serverPlugin,
+    transformRuntimeOptions
+  };
+  return {
+    name: "@modern-js/plugin-module-federation-route",
+    pre: [
+      "@modern-js/plugin-module-federation-config"
+    ],
+    setup: function() {
+      var _ref = _async_to_generator(function(param2) {
+        var useAppContext, appContext, name, _internalOptions_metaName, metaName, internalDirectory, csrConfig, _ref2, scanEntries;
+        return _ts_generator(this, function(_state) {
+          switch (_state.label) {
+            case 0:
+              useAppContext = param2.useAppContext;
+              if (!userConfig.exportRoutes && !userConfig.importRoutes) {
+                return [
+                  2
+                ];
+              }
+              appContext = useAppContext();
+              name = internalOptions.csrConfig.name;
+              _internalOptions_metaName = internalOptions.metaName, metaName = _internalOptions_metaName === void 0 ? META_NAME : _internalOptions_metaName;
+              internalDirectory = appContext.internalDirectory.replace(META_NAME, metaName || META_NAME);
+              csrConfig = internalOptions.csrConfig;
+              if (!(_type_of(csrConfig.remotes) === "object" && Object.keys(csrConfig.remotes).length))
+                return [
+                  3,
+                  2
+                ];
+              return [
+                4,
+                traverseRouteFiles({
+                  appDirectory: appContext.appDirectory,
+                  generateRouteFile: userConfig.importRoutes,
+                  remotePathMap
+                })
+              ];
+            case 1:
+              _ref2 = _state.sent(), scanEntries = _ref2.entries;
+              scanEntries.forEach(function(e) {
+                return entries.add(e);
+              });
+              return [
+                3,
+                3
+              ];
+            case 2:
+              entries.add(DEFAULT_ENTRY);
+              _state.label = 3;
+            case 3:
+              return [
+                2,
+                {
+                  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, param3) {
+                              var isServer = param3.isServer;
+                              addShared({
+                                mfConfig: isServer ? internalOptions.ssrConfig : internalOptions.csrConfig,
+                                metaName,
+                                isServer,
+                                internalDirectory,
+                                entries
+                              });
+                            },
+                            // bundlerChain can not keep target order
+                            webpack: function webpack(_config, param3) {
+                              var isServer = param3.isServer;
+                              addShared({
+                                mfConfig: isServer ? internalOptions.ssrConfig : internalOptions.csrConfig,
+                                metaName,
+                                isServer,
+                                internalDirectory,
+                                entries
+                              });
+                            }
+                          },
+                          source: {
+                            define: {
+                              MODERN_ROUTER_ID_PREFIX: JSON.stringify(transformName2Prefix(name))
+                            }
+                          }
+                        }
+                      ];
+                    });
+                  }),
+                  modifyFileSystemRoutes: function modifyFileSystemRoutes(options) {
+                    return _async_to_generator(function() {
+                      var routes, entrypoint, entryName, prefix, modifyRouteIds;
+                      return _ts_generator(this, function(_state2) {
+                        switch (_state2.label) {
+                          case 0:
+                            routes = options.routes, entrypoint = options.entrypoint;
+                            entryName = entrypoint.entryName;
+                            prefix = transformName2Prefix(internalOptions.csrConfig.name);
+                            modifyRouteIds = function() {
+                              var _ref3 = _async_to_generator(function(route, pathName) {
+                                var currentPathName, originalId, remoteInfo, _$path, name2, remoteIdPrefix, isLayout, newId, content, _tmp;
+                                return _ts_generator(this, function(_state3) {
+                                  switch (_state3.label) {
+                                    case 0:
+                                      currentPathName = route.path ? path.join("/", pathName, route.path) : pathName;
+                                      if (!route.id)
+                                        return [
+                                          3,
+                                          6
+                                        ];
+                                      originalId = route.id;
+                                      route.originalId = originalId;
+                                      remoteInfo = remotePathMap[currentPathName];
+                                      if (!remoteInfo)
+                                        return [
+                                          3,
+                                          2
+                                        ];
+                                      _$path = remoteInfo.path, name2 = remoteInfo.name;
+                                      remoteIdPrefix = transformName2Prefix(name2);
+                                      isLayout = Boolean(route.children);
+                                      newId = "".concat(remoteIdPrefix).concat(isLayout ? "layout" : "page");
+                                      ssrByRouteIdsMap[originalId] = newId;
+                                      content = fs.readFileSync(_$path, "utf-8");
+                                      return [
+                                        4,
+                                        fs.writeFile(_$path, content.replace(ROUTE_ID, originalId))
+                                      ];
+                                    case 1:
+                                      _state3.sent();
+                                      route.id = newId;
+                                      return [
+                                        3,
+                                        3
+                                      ];
+                                    case 2:
+                                      route.id = "".concat(prefix).concat(route.id);
+                                      _state3.label = 3;
+                                    case 3:
+                                      _tmp = route.children;
+                                      if (!_tmp)
+                                        return [
+                                          3,
+                                          5
+                                        ];
+                                      return [
+                                        4,
+                                        Promise.all(route.children.map(function() {
+                                          var _ref4 = _async_to_generator(function(r) {
+                                            return _ts_generator(this, function(_state4) {
+                                              switch (_state4.label) {
+                                                case 0:
+                                                  return [
+                                                    4,
+                                                    modifyRouteIds(r, currentPathName)
+                                                  ];
+                                                case 1:
+                                                  return [
+                                                    2,
+                                                    _state4.sent()
+                                                  ];
+                                              }
+                                            });
+                                          });
+                                          return function(r) {
+                                            return _ref4.apply(this, arguments);
+                                          };
+                                        }()))
+                                      ];
+                                    case 4:
+                                      _tmp = _state3.sent();
+                                      _state3.label = 5;
+                                    case 5:
+                                      _tmp;
+                                      _state3.label = 6;
+                                    case 6:
+                                      return [
+                                        2
+                                      ];
+                                  }
+                                });
+                              });
+                              return function modifyRouteIds2(route, pathName) {
+                                return _ref3.apply(this, arguments);
+                              };
+                            }();
+                            return [
+                              4,
+                              Promise.all(routes.map(function() {
+                                var _ref3 = _async_to_generator(function(route) {
+                                  return _ts_generator(this, function(_state3) {
+                                    switch (_state3.label) {
+                                      case 0:
+                                        return [
+                                          4,
+                                          modifyRouteIds(route, entryName === DEFAULT_ENTRY ? "" : entryName)
+                                        ];
+                                      case 1:
+                                        _state3.sent();
+                                        return [
+                                          2
+                                        ];
+                                    }
+                                  });
+                                });
+                                return function(route) {
+                                  return _ref3.apply(this, arguments);
+                                };
+                              }()))
+                            ];
+                          case 1:
+                            _state2.sent();
+                            return [
+                              2,
+                              options
+                            ];
+                        }
+                      });
+                    })();
+                  }
+                }
+              ];
+          }
+        });
+      });
+      return function(_) {
+        return _ref.apply(this, arguments);
+      };
+    }(),
+    usePlugins: [
+      moduleFederationExportRoutePlugin(internalRoutesPluginOptions),
+      moduleFederationImportRoutePlugin(internalRoutesPluginOptions)
+    ]
+  };
+};
+var plugin_default = moduleFederationRoutesPlugin;
+export {
+  plugin_default as default,
+  moduleFederationRoutesPlugin
+};