@module-federation/modern-js 0.0.0-next-20241010084324 → 0.0.0-next-20241011105718

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

@@ -0,0 +1,308 @@
+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 { MF_JSON, ROUTE_ID } 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, 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,
+                        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,103 @@
+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;
+  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
+};