@modern-js/app-tools 2.53.1-alpha.3 → 2.54.0

package/dist/esm/{analyze → plugins/analyze}/generateCode.js

@@ -2,12 +2,10 @@ 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 path from "path";
-import { fs, getEntryOptions, isRouterV5, isSSGEntry, isUseSSRBundle, logger, SERVER_RENDER_FUNCTION_NAME } from "@modern-js/utils";
+import { findExists, fs, getEntryOptions, JS_EXTENSIONS, SERVER_RENDER_FUNCTION_NAME } from "@modern-js/utils";
 import * as templates from "./templates";
-import { getClientRoutes, getClientRoutesLegacy } from "./getClientRoutes";
-import { FILE_SYSTEM_ROUTES_FILE_NAME, ENTRY_POINT_FILE_NAME, ENTRY_BOOTSTRAP_FILE_NAME } from "./constants";
-import { getDefaultImports, getServerLoadersFile, getServerCombinedModueFile } from "./utils";
-import { walk } from "./nestedRoutes";
+import { ENTRY_POINT_FILE_NAME, ENTRY_BOOTSTRAP_FILE_NAME } from "./constants";
+import { getDefaultImports } from "./utils";
 var createImportSpecifier = function(specifiers) {
   var defaults = "";
   var named = [];
@@ -94,170 +92,22 @@ var createImportStatements = function(statements) {
 };
 var generateCode = function() {
   var _ref = _async_to_generator(function(appContext, config, entrypoints, api) {
-    var internalDirectory, srcDirectory, appDirectory, internalDirAlias, internalSrcAlias, packageName, hookRunners, isV5, getRoutes, importsStatemets, oldVersion;
-    function generateEntryCode(entrypoint) {
+    var internalDirectory, srcDirectory, appDirectory, internalDirAlias, internalSrcAlias, runtimeConfigFile, hookRunners, customRuntimeConfig, importsStatemets;
+    function generateEntryCode(entrypoint, customRuntimeConfig2) {
       return _generateEntryCode.apply(this, arguments);
     }
     function _generateEntryCode() {
-      _generateEntryCode = _async_to_generator(function(entrypoint) {
-        var entryName, isMainEntry, isAutoMount, fileSystemRoutes, _config_output, initialRoutes, nestedRoutes, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, route, routes, _$config, ssr, useSSG, mode, hasPageRoute, code, _, _tmp, routesServerFile, code1, serverLoaderCombined, serverLoaderFile, imports, entryFile;
+      _generateEntryCode = _async_to_generator(function(entrypoint, customRuntimeConfig2) {
+        var entryName, isAutoMount, imports, entryFile;
         return _ts_generator(this, function(_state) {
           switch (_state.label) {
             case 0:
-              entryName = entrypoint.entryName, isMainEntry = entrypoint.isMainEntry, isAutoMount = entrypoint.isAutoMount, fileSystemRoutes = entrypoint.fileSystemRoutes;
+              entryName = entrypoint.entryName, isAutoMount = entrypoint.isAutoMount;
               if (!isAutoMount)
-                return [
-                  3,
-                  13
-                ];
-              if (!fileSystemRoutes)
-                return [
-                  3,
-                  11
-                ];
-              initialRoutes = [];
-              nestedRoutes = null;
-              if (entrypoint.entry) {
-                initialRoutes = getRoutes({
-                  entrypoint,
-                  srcDirectory,
-                  srcAlias: internalSrcAlias,
-                  internalDirectory,
-                  internalDirAlias
-                });
-              }
-              if (!(!isV5 && entrypoint.nestedRoutesEntry))
                 return [
                   3,
                   2
                 ];
-              return [
-                4,
-                walk(entrypoint.nestedRoutesEntry, entrypoint.nestedRoutesEntry, {
-                  name: internalSrcAlias,
-                  basename: srcDirectory
-                }, entrypoint.entryName, entrypoint.isMainEntry, oldVersion)
-              ];
-            case 1:
-              nestedRoutes = _state.sent();
-              if (nestedRoutes) {
-                if (!Array.isArray(nestedRoutes)) {
-                  nestedRoutes = [
-                    nestedRoutes
-                  ];
-                }
-                _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
-                try {
-                  for (_iterator = nestedRoutes[Symbol.iterator](); !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
-                    route = _step.value;
-                    initialRoutes.unshift(route);
-                  }
-                } catch (err) {
-                  _didIteratorError = true;
-                  _iteratorError = err;
-                } finally {
-                  try {
-                    if (!_iteratorNormalCompletion && _iterator.return != null) {
-                      _iterator.return();
-                    }
-                  } finally {
-                    if (_didIteratorError) {
-                      throw _iteratorError;
-                    }
-                  }
-                }
-              }
-              _state.label = 2;
-            case 2:
-              return [
-                4,
-                hookRunners.modifyFileSystemRoutes({
-                  entrypoint,
-                  routes: initialRoutes
-                })
-              ];
-            case 3:
-              routes = _state.sent().routes;
-              _$config = api.useResolvedConfigContext();
-              ssr = getEntryOptions(entryName, isMainEntry, _$config.server.ssr, _$config.server.ssrByEntries, packageName);
-              useSSG = isSSGEntry(_$config, entryName, entrypoints);
-              if (ssr) {
-                mode = typeof ssr === "object" ? ssr.mode || "string" : "string";
-              }
-              if (mode === "stream") {
-                hasPageRoute = routes.some(function(route2) {
-                  return "type" in route2 && route2.type === "page";
-                });
-                if (hasPageRoute) {
-                  logger.error("Streaming ssr is not supported when pages dir exists");
-                  process.exit(1);
-                }
-              }
-              _ = hookRunners.beforeGenerateRoutes;
-              _tmp = {
-                entrypoint
-              };
-              return [
-                4,
-                templates.fileSystemRoutes({
-                  routes,
-                  ssrMode: useSSG ? "string" : mode,
-                  nestedRoutesEntry: entrypoint.nestedRoutesEntry,
-                  entryName: entrypoint.entryName,
-                  internalDirectory,
-                  splitRouteChunks: _$config === null || _$config === void 0 ? void 0 : (_config_output = _$config.output) === null || _config_output === void 0 ? void 0 : _config_output.splitRouteChunks
-                })
-              ];
-            case 4:
-              return [
-                4,
-                _.apply(hookRunners, [
-                  (_tmp.code = _state.sent(), _tmp)
-                ])
-              ];
-            case 5:
-              code = _state.sent().code;
-              if (!(entrypoint.nestedRoutesEntry && isUseSSRBundle(_$config)))
-                return [
-                  3,
-                  8
-                ];
-              routesServerFile = getServerLoadersFile(internalDirectory, entryName);
-              code1 = templates.routesForServer({
-                routes
-              });
-              return [
-                4,
-                fs.ensureFile(routesServerFile)
-              ];
-            case 6:
-              _state.sent();
-              return [
-                4,
-                fs.writeFile(routesServerFile, code1)
-              ];
-            case 7:
-              _state.sent();
-              _state.label = 8;
-            case 8:
-              serverLoaderCombined = templates.ssrLoaderCombinedModule(entrypoints, entrypoint, _$config, appContext);
-              if (!serverLoaderCombined)
-                return [
-                  3,
-                  10
-                ];
-              serverLoaderFile = getServerCombinedModueFile(internalDirectory, entryName);
-              return [
-                4,
-                fs.outputFile(serverLoaderFile, serverLoaderCombined)
-              ];
-            case 9:
-              _state.sent();
-              _state.label = 10;
-            case 10:
-              fs.outputFileSync(path.resolve(internalDirectory, "./".concat(entryName, "/").concat(FILE_SYSTEM_ROUTES_FILE_NAME)), code, "utf8");
-              _state.label = 11;
-            case 11:
               return [
                 4,
                 hookRunners.modifyEntryImports({
@@ -267,17 +117,19 @@ var generateCode = function() {
                     srcDirectory,
                     appDirectory,
                     internalSrcAlias,
-                    internalDirAlias
+                    internalDirAlias,
+                    runtimeConfigFile,
+                    customRuntimeConfig: customRuntimeConfig2
                   })
                 })
               ];
-            case 12:
+            case 1:
               imports = _state.sent().imports;
               importsStatemets.set(entryName, imports);
               entryFile = path.resolve(internalDirectory, "./".concat(entryName, "/").concat(ENTRY_POINT_FILE_NAME));
               entrypoint.internalEntry = entryFile;
-              _state.label = 13;
-            case 13:
+              _state.label = 2;
+            case 2:
               return [
                 2
               ];
@@ -289,15 +141,17 @@ var generateCode = function() {
     return _ts_generator(this, function(_state) {
       switch (_state.label) {
         case 0:
-          internalDirectory = appContext.internalDirectory, srcDirectory = appContext.srcDirectory, appDirectory = appContext.appDirectory, internalDirAlias = appContext.internalDirAlias, internalSrcAlias = appContext.internalSrcAlias, packageName = appContext.packageName;
+          internalDirectory = appContext.internalDirectory, srcDirectory = appContext.srcDirectory, appDirectory = appContext.appDirectory, internalDirAlias = appContext.internalDirAlias, internalSrcAlias = appContext.internalSrcAlias, runtimeConfigFile = appContext.runtimeConfigFile;
           hookRunners = api.useHookRunners();
-          isV5 = isRouterV5(config);
-          getRoutes = isV5 ? getClientRoutesLegacy : getClientRoutes;
+          customRuntimeConfig = findExists(JS_EXTENSIONS.map(function(ext) {
+            return path.resolve(srcDirectory, "".concat(runtimeConfigFile).concat(ext));
+          }));
           importsStatemets = /* @__PURE__ */ new Map();
-          oldVersion = typeof (config === null || config === void 0 ? void 0 : config.runtime.router) === "object" ? Boolean((config === null || config === void 0 ? void 0 : config.runtime.router).oldVersion) : false;
           return [
             4,
-            Promise.all(entrypoints.map(generateEntryCode))
+            Promise.all(entrypoints.map(function(entrypoint) {
+              return generateEntryCode(entrypoint, customRuntimeConfig);
+            }))
           ];
         case 1:
           _state.sent();
@@ -316,14 +170,17 @@ var generateCode = function() {
 }();
 var generateIndexCode = function() {
   var _ref = _async_to_generator(function(param) {
-    var appContext, api, entrypoints, config, importsStatemets, bundlerConfigs, hookRunners, mountId, internalDirectory, packageName;
+    var appContext, api, entrypoints, config, importsStatemets, bundlerConfigs, hookRunners, mountId, internalDirectory, packageName, srcDirectory, runtimeConfigFile, customRuntimeConfig;
     return _ts_generator(this, function(_state) {
       switch (_state.label) {
         case 0:
           appContext = param.appContext, api = param.api, entrypoints = param.entrypoints, config = param.config, importsStatemets = param.importsStatemets, bundlerConfigs = param.bundlerConfigs;
           hookRunners = api.useHookRunners();
           mountId = config.html.mountId;
-          internalDirectory = appContext.internalDirectory, packageName = appContext.packageName;
+          internalDirectory = appContext.internalDirectory, packageName = appContext.packageName, srcDirectory = appContext.srcDirectory, runtimeConfigFile = appContext.runtimeConfigFile;
+          customRuntimeConfig = findExists(JS_EXTENSIONS.map(function(ext) {
+            return path.resolve(srcDirectory, "".concat(runtimeConfigFile).concat(ext));
+          }));
           return [
             4,
             Promise.all(entrypoints.map(function() {
@@ -355,6 +212,7 @@ var generateIndexCode = function() {
                           code: templates.renderFunction({
                             plugins,
                             customBootstrap,
+                            customRuntimeConfig,
                             fileSystemRoutes
                           })
                         })

package/dist/esm/plugins/analyze/getBundleEntry.js

@@ -0,0 +1,101 @@
+import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
+import path from "path";
+import { ensureAbsolutePath, fs, findExists, MAIN_ENTRY_NAME, JS_EXTENSIONS } from "@modern-js/utils";
+import { getFileSystemEntry } from "./getFileSystemEntry";
+import { isSubDirOrEqual } from "./utils";
+var ensureExtensions = function(file) {
+  if (!path.extname(file)) {
+    return findExists(JS_EXTENSIONS.map(function(ext) {
+      return "".concat(file).concat(ext);
+    })) || file;
+  }
+  return file;
+};
+var isDirectory = function(file) {
+  return !path.extname(file);
+};
+var ifAlreadyExists = function(entrypoints, checked) {
+  return entrypoints.some(function(entrypoint) {
+    if (ensureExtensions(entrypoint.entry) === ensureExtensions(checked.entry)) {
+      checked.entryName = entrypoint.entryName;
+      return true;
+    }
+    if (isSubDirOrEqual(entrypoint.entry, checked.entry) || isSubDirOrEqual(checked.entry, entrypoint.entry)) {
+      throw new Error("Entry configuration conflicts\n Your configuration: ".concat(checked.entry, ".\n Default entrypoint: ").concat(entrypoint.entry, "\n Please reset source.entries or set source.disableDefaultEntries to disable the default entry rules."));
+    }
+    return false;
+  });
+};
+var getBundleEntry = function() {
+  var _ref = _async_to_generator(function(hookRunners, appContext, config) {
+    var appDirectory, packageName, _config_source, disableDefaultEntries, entries, entriesDir, mainEntryName, defaults, _tmp, entriesDirAbs, found;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          appDirectory = appContext.appDirectory, packageName = appContext.packageName;
+          _config_source = config.source, disableDefaultEntries = _config_source.disableDefaultEntries, entries = _config_source.entries, entriesDir = _config_source.entriesDir, mainEntryName = _config_source.mainEntryName;
+          if (!disableDefaultEntries)
+            return [
+              3,
+              1
+            ];
+          _tmp = [];
+          return [
+            3,
+            3
+          ];
+        case 1:
+          return [
+            4,
+            getFileSystemEntry(hookRunners, appContext, config)
+          ];
+        case 2:
+          _tmp = _state.sent();
+          _state.label = 3;
+        case 3:
+          defaults = _tmp;
+          if (entries) {
+            Object.keys(entries).forEach(function(name) {
+              var value = entries[name];
+              var entryName = typeof value === "string" ? value : value.entry;
+              var isAutoMount = typeof value === "string" ? true : !value.disableMount;
+              var entrypoint = {
+                entryName: name,
+                isMainEntry: false,
+                entry: ensureAbsolutePath(appDirectory, entryName),
+                absoluteEntryDir: isDirectory(ensureAbsolutePath(appDirectory, entryName)) ? ensureAbsolutePath(appDirectory, entryName) : path.dirname(ensureAbsolutePath(appDirectory, entryName)),
+                isAutoMount,
+                customBootstrap: typeof value === "string" ? false : value.customBootstrap && ensureAbsolutePath(appDirectory, value.customBootstrap),
+                fileSystemRoutes: fs.statSync(ensureAbsolutePath(appDirectory, entryName)).isDirectory() ? {} : void 0
+              };
+              if (!ifAlreadyExists(defaults, entrypoint)) {
+                defaults.push(entrypoint);
+              }
+            });
+          }
+          if (!disableDefaultEntries) {
+            entriesDirAbs = ensureAbsolutePath(appDirectory, entriesDir || "");
+            found = defaults.find(function(param) {
+              var entryName = param.entryName, entry = param.entry, _param_nestedRoutesEntry = param.nestedRoutesEntry, nestedRoutesEntry = _param_nestedRoutesEntry === void 0 ? "" : _param_nestedRoutesEntry;
+              return entryName === packageName || path.dirname(entry) === entriesDirAbs || path.dirname(nestedRoutesEntry) === entriesDirAbs;
+            });
+            if (found) {
+              found.entryName = mainEntryName || MAIN_ENTRY_NAME;
+              found.isMainEntry = true;
+            }
+          }
+          return [
+            2,
+            defaults
+          ];
+      }
+    });
+  });
+  return function getBundleEntry2(hookRunners, appContext, config) {
+    return _ref.apply(this, arguments);
+  };
+}();
+export {
+  getBundleEntry
+};

package/dist/esm/plugins/analyze/getFileSystemEntry.js

@@ -0,0 +1,195 @@
+import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
+import fs from "fs";
+import path from "path";
+import { findExists, ensureAbsolutePath, JS_EXTENSIONS } from "@modern-js/utils";
+import { INDEX_FILE_NAME } from "./constants";
+import { isDefaultExportFunction } from "./isDefaultExportFunction";
+var hasIndex = function(dir) {
+  return findExists(JS_EXTENSIONS.map(function(ext) {
+    return path.resolve(dir, "".concat(INDEX_FILE_NAME).concat(ext));
+  }));
+};
+var isBundleEntry = function() {
+  var _ref = _async_to_generator(function(hookRunners, dir) {
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          return [
+            4,
+            hookRunners.checkEntryPoint({
+              path: dir,
+              entry: false
+            })
+          ];
+        case 1:
+          return [
+            2,
+            _state.sent().entry || hasIndex(dir)
+          ];
+      }
+    });
+  });
+  return function isBundleEntry2(hookRunners, dir) {
+    return _ref.apply(this, arguments);
+  };
+}();
+var scanDir = function(hookRunners, dirs) {
+  return Promise.all(dirs.map(function() {
+    var _ref = _async_to_generator(function(dir) {
+      var indexFile, customBootstrap, entryName, entryFile;
+      return _ts_generator(this, function(_state) {
+        switch (_state.label) {
+          case 0:
+            indexFile = hasIndex(dir);
+            customBootstrap = isDefaultExportFunction(indexFile) ? indexFile : false;
+            entryName = path.basename(dir);
+            if (indexFile && !customBootstrap) {
+              return [
+                2,
+                {
+                  entryName,
+                  isMainEntry: false,
+                  entry: indexFile,
+                  absoluteEntryDir: path.resolve(dir),
+                  isAutoMount: false,
+                  customBootstrap
+                }
+              ];
+            }
+            return [
+              4,
+              hookRunners.checkEntryPoint({
+                path: dir,
+                entry: false
+              })
+            ];
+          case 1:
+            entryFile = _state.sent().entry;
+            if (entryFile) {
+              return [
+                2,
+                {
+                  entryName,
+                  isMainEntry: false,
+                  entry: entryFile,
+                  absoluteEntryDir: path.resolve(dir),
+                  isAutoMount: true,
+                  customBootstrap
+                }
+              ];
+            }
+            throw Error("There is no valid entry point in the current project!");
+        }
+      });
+    });
+    return function(dir) {
+      return _ref.apply(this, arguments);
+    };
+  }()));
+};
+var getFileSystemEntry = function() {
+  var _ref = _async_to_generator(function(hookRunners, appContext, config) {
+    var appDirectory, _config_source, entriesDir, disableEntryDirs, disabledDirs, src, dirs;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          appDirectory = appContext.appDirectory;
+          _config_source = config.source, entriesDir = _config_source.entriesDir, disableEntryDirs = _config_source.disableEntryDirs;
+          disabledDirs = [];
+          if (disableEntryDirs && Array.isArray(disableEntryDirs)) {
+            disabledDirs = disableEntryDirs === null || disableEntryDirs === void 0 ? void 0 : disableEntryDirs.map(function(dir) {
+              return ensureAbsolutePath(appDirectory, dir);
+            });
+          }
+          src = ensureAbsolutePath(appDirectory, entriesDir || "");
+          if (!fs.existsSync(src))
+            return [
+              3,
+              5
+            ];
+          if (!fs.statSync(src).isDirectory())
+            return [
+              3,
+              3
+            ];
+          return [
+            4,
+            isBundleEntry(hookRunners, src)
+          ];
+        case 1:
+          if (_state.sent()) {
+            return [
+              2,
+              scanDir(hookRunners, [
+                src
+              ])
+            ];
+          }
+          dirs = [];
+          return [
+            4,
+            Promise.all(fs.readdirSync(src).map(function() {
+              var _ref2 = _async_to_generator(function(filename) {
+                var file, _tmp;
+                return _ts_generator(this, function(_state2) {
+                  switch (_state2.label) {
+                    case 0:
+                      file = path.join(src, filename);
+                      _tmp = fs.statSync(file).isDirectory();
+                      if (!_tmp)
+                        return [
+                          3,
+                          2
+                        ];
+                      return [
+                        4,
+                        isBundleEntry(hookRunners, file)
+                      ];
+                    case 1:
+                      _tmp = _state2.sent();
+                      _state2.label = 2;
+                    case 2:
+                      if (_tmp && !disabledDirs.includes(file)) {
+                        dirs.push(file);
+                      }
+                      return [
+                        2
+                      ];
+                  }
+                });
+              });
+              return function(filename) {
+                return _ref2.apply(this, arguments);
+              };
+            }()))
+          ];
+        case 2:
+          _state.sent();
+          return [
+            2,
+            scanDir(hookRunners, dirs)
+          ];
+        case 3:
+          throw Error("source.entriesDir accept a directory.");
+        case 4:
+          return [
+            3,
+            6
+          ];
+        case 5:
+          throw Error("src dir ".concat(entriesDir, " not found."));
+        case 6:
+          return [
+            2
+          ];
+      }
+    });
+  });
+  return function getFileSystemEntry2(hookRunners, appContext, config) {
+    return _ref.apply(this, arguments);
+  };
+}();
+export {
+  getFileSystemEntry
+};

package/dist/esm/{analyze → plugins/analyze}/getServerRoutes.js

@@ -5,7 +5,7 @@ import { _ as _to_consumable_array } from "@swc/helpers/_/_to_consumable_array";
 import path from "path";
 import fs from "fs";
 import { urlJoin, isPlainObject, removeLeadingSlash, getEntryOptions, SERVER_BUNDLE_DIRECTORY, removeTailSlash, SERVER_WORKER_BUNDLE_DIRECTORY } from "@modern-js/utils";
-import { isMainEntry } from "../utils/routes";
+import { isMainEntry } from "../../utils/routes";
 import { walkDirectory } from "./utils";
 var applyBaseUrl = function(baseUrl, routes) {
   if (baseUrl) {