@modern-js/app-tools 2.58.2 → 2.59.0

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

@@ -0,0 +1,266 @@
+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 { JS_EXTENSIONS, ensureAbsolutePath, findExists } from "@modern-js/utils";
+import { ENTRY_FILE_NAME, 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 hasEntry = function(dir) {
+  return findExists(JS_EXTENSIONS.map(function(ext) {
+    return path.resolve(dir, "".concat(ENTRY_FILE_NAME).concat(ext));
+  }));
+};
+var hasServerEntry = function(dir) {
+  return findExists(JS_EXTENSIONS.map(function(ext) {
+    return path.resolve(dir, "".concat(ENTRY_FILE_NAME, ".server").concat(ext));
+  }));
+};
+var isBundleEntry = function() {
+  var _ref = _async_to_generator(function(hookRunners, dir, enableCustomEntry) {
+    var entry, customEntry;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          return [
+            4,
+            hookRunners.checkEntryPoint({
+              path: dir,
+              entry: false
+            })
+          ];
+        case 1:
+          entry = _state.sent().entry;
+          if (entry) {
+            return [
+              2,
+              entry
+            ];
+          }
+          customEntry = hasEntry(dir);
+          if (enableCustomEntry && customEntry) {
+            return [
+              2,
+              customEntry
+            ];
+          }
+          return [
+            2,
+            hasIndex(dir)
+          ];
+      }
+    });
+  });
+  return function isBundleEntry2(hookRunners, dir, enableCustomEntry) {
+    return _ref.apply(this, arguments);
+  };
+}();
+var scanDir = function() {
+  var _ref = _async_to_generator(function(hookRunners, dirs, enableCustomEntry) {
+    var entries;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          return [
+            4,
+            Promise.all(dirs.map(function() {
+              var _ref2 = _async_to_generator(function(dir) {
+                var indexFile, customBootstrap, entryName, customEntryFile, customServerEntry, entryFile;
+                return _ts_generator(this, function(_state2) {
+                  switch (_state2.label) {
+                    case 0:
+                      indexFile = hasIndex(dir);
+                      customBootstrap = isDefaultExportFunction(indexFile) ? indexFile : false;
+                      entryName = path.basename(dir);
+                      customEntryFile = hasEntry(dir);
+                      customServerEntry = hasServerEntry(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 = _state2.sent().entry;
+                      if (entryFile) {
+                        return [
+                          2,
+                          {
+                            entryName,
+                            isMainEntry: false,
+                            entry: enableCustomEntry ? customEntryFile || entryFile : entryFile,
+                            customServerEntry,
+                            absoluteEntryDir: path.resolve(dir),
+                            isAutoMount: true,
+                            customBootstrap,
+                            customEntry: enableCustomEntry ? Boolean(customEntryFile) : false
+                          }
+                        ];
+                      }
+                      if (enableCustomEntry && customEntryFile) {
+                        return [
+                          2,
+                          {
+                            entryName,
+                            isMainEntry: false,
+                            entry: customEntryFile,
+                            customServerEntry,
+                            absoluteEntryDir: path.resolve(dir),
+                            isAutoMount: false,
+                            customEntry: Boolean(customEntryFile)
+                          }
+                        ];
+                      }
+                      return [
+                        2,
+                        false
+                      ];
+                  }
+                });
+              });
+              return function(dir) {
+                return _ref2.apply(this, arguments);
+              };
+            }())).then(function(entries2) {
+              return entries2.filter(Boolean);
+            })
+          ];
+        case 1:
+          entries = _state.sent();
+          if (entries.length === 0) {
+            throw Error("There is no valid entry point in the current project!");
+          }
+          return [
+            2,
+            entries
+          ];
+      }
+    });
+  });
+  return function scanDir2(hookRunners, dirs, enableCustomEntry) {
+    return _ref.apply(this, arguments);
+  };
+}();
+var getFileSystemEntry = function() {
+  var _ref = _async_to_generator(function(hookRunners, appContext, config) {
+    var appDirectory, _config_source, entriesDir, disableEntryDirs, enableCustomEntry, 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, enableCustomEntry = _config_source.enableCustomEntry;
+          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, enableCustomEntry)
+          ];
+        case 1:
+          if (_state.sent()) {
+            return [
+              2,
+              scanDir(hookRunners, [
+                src
+              ], enableCustomEntry)
+            ];
+          }
+          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, enableCustomEntry)
+                      ];
+                    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, enableCustomEntry)
+          ];
+        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/plugins/analyze/getHtmlTemplate.js

@@ -0,0 +1,178 @@
+import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _object_spread } from "@swc/helpers/_/_object_spread";
+import { _ as _object_spread_props } from "@swc/helpers/_/_object_spread_props";
+import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
+import { _ as _ts_values } from "@swc/helpers/_/_ts_values";
+import path from "path";
+import { fs, findExists } from "@modern-js/utils";
+import { HTML_PARTIALS_EXTENSIONS, HTML_PARTIALS_FOLDER } from "./constants";
+import * as templates from "./templates";
+var PartialPosition;
+(function(PartialPosition2) {
+  PartialPosition2["TOP"] = "top";
+  PartialPosition2["HEAD"] = "head";
+  PartialPosition2["BODY"] = "body";
+  PartialPosition2["BOTTOM"] = "bottom";
+  PartialPosition2["INDEX"] = "index";
+})(PartialPosition || (PartialPosition = {}));
+var findPartials = function(dir, entryName, position) {
+  if (fs.existsSync(dir)) {
+    var base = findExists(HTML_PARTIALS_EXTENSIONS.map(function(ext) {
+      return path.resolve(dir, "".concat(position).concat(ext));
+    }));
+    var file = entryName ? findExists(HTML_PARTIALS_EXTENSIONS.map(function(ext) {
+      return path.resolve(dir, entryName, "".concat(position).concat(ext));
+    })) || base : base;
+    return file ? {
+      file,
+      content: fs.readFileSync(file, "utf8")
+    } : null;
+  }
+  return null;
+};
+var getHtmlTemplate = function() {
+  var _ref = _async_to_generator(function(entrypoints, api, param) {
+    var appContext, config, appDirectory, internalDirectory, configDir, htmlDir, htmlTemplates, partialsByEntrypoint, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _loop, _iterator, _step, err;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          appContext = param.appContext, config = param.config;
+          appDirectory = appContext.appDirectory, internalDirectory = appContext.internalDirectory;
+          configDir = config.source.configDir;
+          htmlDir = path.resolve(appDirectory, configDir || "", HTML_PARTIALS_FOLDER);
+          htmlTemplates = {};
+          partialsByEntrypoint = {};
+          _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
+          _state.label = 1;
+        case 1:
+          _state.trys.push([
+            1,
+            6,
+            7,
+            8
+          ]);
+          _loop = function() {
+            var entrypoint, entryName, isMainEntry, name, customIndexTemplate, hookRunners, partials, templatePath, bottomTemplate;
+            return _ts_generator(this, function(_state2) {
+              switch (_state2.label) {
+                case 0:
+                  entrypoint = _step.value;
+                  entryName = entrypoint.entryName, isMainEntry = entrypoint.isMainEntry;
+                  name = entrypoints.length === 1 && isMainEntry ? "" : entryName;
+                  customIndexTemplate = findPartials(htmlDir, name, "index");
+                  if (!customIndexTemplate)
+                    return [
+                      3,
+                      1
+                    ];
+                  htmlTemplates[entryName] = customIndexTemplate.file;
+                  return [
+                    3,
+                    3
+                  ];
+                case 1:
+                  hookRunners = api.useHookRunners();
+                  return [
+                    4,
+                    hookRunners.htmlPartials({
+                      entrypoint,
+                      partials: [
+                        "top",
+                        "head",
+                        "body"
+                      ].reduce(function(previous, position) {
+                        var found = findPartials(htmlDir, name, position);
+                        previous[position] = found ? [
+                          found.content
+                        ] : [];
+                        return previous;
+                      }, {
+                        top: [],
+                        head: [],
+                        body: []
+                      })
+                    })
+                  ];
+                case 2:
+                  partials = _state2.sent().partials;
+                  templatePath = path.resolve(internalDirectory, entryName, "index.html");
+                  fs.outputFileSync(templatePath, templates.html(partials), "utf8");
+                  htmlTemplates[entryName] = templatePath;
+                  partialsByEntrypoint[entryName] = partials;
+                  bottomTemplate = findPartials(htmlDir, name, "bottom");
+                  if (bottomTemplate) {
+                    htmlTemplates["__".concat(entryName, "-bottom__")] = bottomTemplate.content;
+                  }
+                  _state2.label = 3;
+                case 3:
+                  return [
+                    2
+                  ];
+              }
+            });
+          };
+          _iterator = entrypoints[Symbol.iterator]();
+          _state.label = 2;
+        case 2:
+          if (!!(_iteratorNormalCompletion = (_step = _iterator.next()).done))
+            return [
+              3,
+              5
+            ];
+          return [
+            5,
+            _ts_values(_loop())
+          ];
+        case 3:
+          _state.sent();
+          _state.label = 4;
+        case 4:
+          _iteratorNormalCompletion = true;
+          return [
+            3,
+            2
+          ];
+        case 5:
+          return [
+            3,
+            8
+          ];
+        case 6:
+          err = _state.sent();
+          _didIteratorError = true;
+          _iteratorError = err;
+          return [
+            3,
+            8
+          ];
+        case 7:
+          try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+              _iterator.return();
+            }
+          } finally {
+            if (_didIteratorError) {
+              throw _iteratorError;
+            }
+          }
+          return [
+            7
+          ];
+        case 8:
+          api.setAppContext(_object_spread_props(_object_spread({}, api.useAppContext()), {
+            partialsByEntrypoint
+          }));
+          return [
+            2,
+            htmlTemplates
+          ];
+      }
+    });
+  });
+  return function getHtmlTemplate2(entrypoints, api, _) {
+    return _ref.apply(this, arguments);
+  };
+}();
+export {
+  getHtmlTemplate
+};

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

@@ -0,0 +1,132 @@
+import { _ as _object_spread } from "@swc/helpers/_/_object_spread";
+import { _ as _object_spread_props } from "@swc/helpers/_/_object_spread_props";
+import { _ as _object_without_properties } from "@swc/helpers/_/_object_without_properties";
+import { _ as _to_consumable_array } from "@swc/helpers/_/_to_consumable_array";
+import fs from "fs";
+import path from "path";
+import { SERVER_BUNDLE_DIRECTORY, SERVER_WORKER_BUNDLE_DIRECTORY, getEntryOptions, isPlainObject, removeLeadingSlash, removeTailSlash, urlJoin } from "@modern-js/utils";
+import { isMainEntry } from "../../utils/routes";
+import { walkDirectory } from "./utils";
+var applyBaseUrl = function(baseUrl, routes) {
+  if (baseUrl) {
+    if (Array.isArray(baseUrl)) {
+      return baseUrl.reduce(function(previous, current) {
+        return _to_consumable_array(previous).concat(_to_consumable_array(applyBaseUrl(current, routes)));
+      }, []);
+    } else {
+      return routes.map(function(route) {
+        var urlPath = urlJoin(baseUrl, route.urlPath);
+        return _object_spread_props(_object_spread({}, route), {
+          urlPath: urlPath === "/" ? urlPath : removeTailSlash(urlPath)
+        });
+      });
+    }
+  }
+  return routes;
+};
+var applyRouteOptions = function(original, routeOptions) {
+  var route = routeOptions.route, disableSpa = routeOptions.disableSpa;
+  original.isSPA = !disableSpa;
+  !original.isSPA && (original.entryPath = path.dirname(original.entryPath));
+  var routes;
+  if (route) {
+    if (Array.isArray(route)) {
+      var _route_map;
+      _route_map = route.map(function(url) {
+        if (isPlainObject(url)) {
+          var urlPath2 = url.path, other2 = _object_without_properties(url, [
+            "path"
+          ]);
+          return _object_spread_props(_object_spread({}, original, other2), {
+            urlPath: urlPath2
+          });
+        } else {
+          return _object_spread_props(_object_spread({}, original), {
+            urlPath: url
+          });
+        }
+      }), routes = _route_map, _route_map;
+    } else if (isPlainObject(route)) {
+      var urlPath = route.path, other = _object_without_properties(route, [
+        "path"
+      ]);
+      routes = [
+        _object_spread_props(_object_spread({}, original, other), {
+          urlPath
+        })
+      ];
+    } else {
+      routes = [
+        _object_spread_props(_object_spread({}, original), {
+          urlPath: route
+        })
+      ];
+    }
+  } else {
+    routes = [
+      original
+    ];
+  }
+  return routes;
+};
+var collectHtmlRoutes = function(entrypoints, appContext, config) {
+  var _deploy_worker;
+  var mainEntryName = config.source.mainEntryName, disableHtmlFolder = config.html.disableHtmlFolder, _config_output = config.output, tmp = _config_output.distPath, _ref = tmp === void 0 ? {} : tmp, htmlPath = _ref.html, _config_server = config.server, baseUrl = _config_server.baseUrl, routes = _config_server.routes, ssr = _config_server.ssr, ssrByEntries = _config_server.ssrByEntries, deploy = config.deploy;
+  var packageName = appContext.packageName;
+  var workerSSR = deploy === null || deploy === void 0 ? void 0 : (_deploy_worker = deploy.worker) === null || _deploy_worker === void 0 ? void 0 : _deploy_worker.ssr;
+  var htmlRoutes = entrypoints.reduce(function(previous, param) {
+    var entryName = param.entryName;
+    var isMain = isMainEntry(entryName, mainEntryName);
+    var entryOptions = getEntryOptions(entryName, isMain, ssr, ssrByEntries, packageName);
+    var isSSR = Boolean(entryOptions);
+    var isWorker = Boolean(workerSSR);
+    var isStream = typeof entryOptions === "object" && entryOptions.mode === "stream";
+    var resHeaders = ((routes === null || routes === void 0 ? void 0 : routes[entryName]) || {}).resHeaders;
+    var route = {
+      urlPath: "/".concat(isMain ? "" : entryName),
+      entryName,
+      entryPath: removeLeadingSlash(path.posix.normalize("".concat(htmlPath, "/").concat(entryName).concat(disableHtmlFolder ? ".html" : "/index.html"))),
+      isSPA: true,
+      isStream,
+      isSSR,
+      responseHeaders: resHeaders,
+      worker: isWorker ? "".concat(SERVER_WORKER_BUNDLE_DIRECTORY, "/").concat(entryName, ".js") : void 0,
+      bundle: isSSR ? "".concat(SERVER_BUNDLE_DIRECTORY, "/").concat(entryName, ".js") : void 0
+    };
+    if (routes === null || routes === void 0 ? void 0 : routes.hasOwnProperty(entryName)) {
+      var routeOptions = isPlainObject(routes[entryName]) ? routes[entryName] : {
+        route: routes[entryName]
+      };
+      route = applyRouteOptions(route, routeOptions);
+    }
+    return Array.isArray(route) ? _to_consumable_array(previous).concat(_to_consumable_array(route)) : _to_consumable_array(previous).concat([
+      route
+    ]);
+  }, []);
+  htmlRoutes = applyBaseUrl(baseUrl, htmlRoutes);
+  return htmlRoutes;
+};
+var collectStaticRoutes = function(appContext, config) {
+  var appDirectory = appContext.appDirectory;
+  var configDir = config.source.configDir, _config_server = config.server, _config_server_publicRoutes = _config_server.publicRoutes, publicRoutes = _config_server_publicRoutes === void 0 ? {} : _config_server_publicRoutes;
+  var publicFolder = path.resolve(appDirectory, configDir || "", "public");
+  return fs.existsSync(publicFolder) ? walkDirectory(publicFolder).map(function(filePath) {
+    var urlPath = "".concat(urlJoin(toPosix(filePath).slice(toPosix(publicFolder).length)));
+    return {
+      urlPath: publicRoutes[removeLeadingSlash(urlPath)] || urlPath,
+      isSPA: true,
+      isSSR: false,
+      entryPath: toPosix(path.relative(path.resolve(appDirectory, configDir || ""), filePath))
+    };
+  }) : [];
+};
+var getServerRoutes = function(entrypoints, param) {
+  var appContext = param.appContext, config = param.config;
+  return _to_consumable_array(collectHtmlRoutes(entrypoints, appContext, config)).concat(_to_consumable_array(collectStaticRoutes(appContext, config)));
+};
+var toPosix = function(pathStr) {
+  return pathStr.split(path.sep).join(path.posix.sep);
+};
+export {
+  getServerRoutes
+};