@modern-js/app-tools 1.21.2 → 2.0.0-beta.0

package/dist/js/treeshaking/analyze/getClientRoutes/getRoutesLegacy.js

@@ -0,0 +1,211 @@
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import _createForOfIteratorHelper from "@babel/runtime/helpers/esm/createForOfIteratorHelper";
+import path from 'path';
+import { fs } from '@modern-js/utils';
+import { makeLegalIdentifier } from "../makeLegalIdentifier";
+import { FILE_SYSTEM_ROUTES_COMPONENTS_DIR, FILE_SYSTEM_ROUTES_DYNAMIC_REGEXP, FILE_SYSTEM_ROUTES_INDEX, FILE_SYSTEM_ROUTES_LAYOUT } from "../constants";
+import { replaceWithAlias } from "../utils";
+import { debug, findLayout, shouldSkip, getRouteWeight } from "./utils";
+
+var compName = function compName(srcDirectory, filePath) {
+  var legalCompName = makeLegalIdentifier(path.relative(srcDirectory, filePath));
+  return "Comp_".concat(legalCompName);
+};
+
+var layoutNameAbbr = function layoutNameAbbr(filePath) {
+  var prefix = 'L_';
+  var dirName = path.dirname(filePath).split('/').pop() || '';
+  return "".concat(prefix).concat(makeLegalIdentifier(dirName));
+};
+
+var parents = [];
+/* eslint-disable no-param-reassign */
+
+var recursiveReadDirLegacy = function recursiveReadDirLegacy(_ref) {
+  var dir = _ref.dir,
+      routes = _ref.routes,
+      _ref$basePath = _ref.basePath,
+      basePath = _ref$basePath === void 0 ? '/' : _ref$basePath,
+      srcDirectory = _ref.srcDirectory,
+      srcAlias = _ref.srcAlias;
+  var hasDynamicRoute = false;
+  var resetParent = false;
+  var parent = parents[parents.length - 1];
+  var layout = findLayout(dir);
+
+  if (layout) {
+    if (basePath === '/') {
+      throw new Error("should use _app instead of _layout in ".concat(dir));
+    } else {
+      var alias = replaceWithAlias(srcDirectory, layout, srcAlias);
+      var componentName = compName(srcDirectory, layout);
+      var route = {
+        path: "".concat(basePath.substring(0, basePath.length - 1)),
+        exact: false,
+        routes: [],
+        _component: alias,
+        component: componentName,
+        parent: parent
+      };
+      parent = route;
+      resetParent = true;
+      routes.push(route);
+      parents.push(route);
+      routes = route.routes;
+    }
+  }
+
+  var _iterator = _createForOfIteratorHelper(fs.readdirSync(dir)),
+      _step;
+
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var relative = _step.value;
+      var filePath = path.join(dir, relative);
+
+      if (!shouldSkip(filePath)) {
+        var filename = path.basename(filePath, path.extname(filePath));
+
+        var _alias = replaceWithAlias(srcDirectory, filePath, srcAlias);
+
+        var _componentName = compName(srcDirectory, filePath);
+
+        var dynamicRouteMatched = FILE_SYSTEM_ROUTES_DYNAMIC_REGEXP.exec(filename);
+
+        if (dynamicRouteMatched) {
+          if (hasDynamicRoute) {
+            throw new Error("Can't set two dynamic route in one directory: ".concat(dir));
+          } else {
+            hasDynamicRoute = true;
+          }
+        }
+
+        var _route = {
+          path: "".concat(basePath).concat(dynamicRouteMatched ? ":".concat(dynamicRouteMatched[1]).concat(dynamicRouteMatched[2]) : filename),
+          _component: _alias,
+          component: _componentName,
+          exact: true,
+          parent: parent
+        };
+
+        if (fs.statSync(filePath).isDirectory()) {
+          recursiveReadDirLegacy({
+            dir: filePath,
+            routes: routes,
+            basePath: "".concat(_route.path, "/"),
+            srcDirectory: srcDirectory,
+            srcAlias: srcAlias
+          });
+          continue;
+        }
+
+        if (filename === FILE_SYSTEM_ROUTES_LAYOUT) {
+          continue;
+        }
+
+        if (filename === FILE_SYSTEM_ROUTES_INDEX) {
+          _route.path = basePath === '/' ? basePath : "".concat(basePath.substring(0, basePath.length - 1));
+        }
+
+        if (filename === '404' && basePath === '/') {
+          _route.path = '*';
+          _route.exact = false;
+        }
+
+        routes.push(_route);
+      }
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+
+  if (resetParent) {
+    parents.pop();
+  }
+};
+/* eslint-enable  no-param-reassign */
+
+
+var normalizeNestedRoutes = function normalizeNestedRoutes(nested, internalComponentsDir, internalDirectory, internalDirAlias) {
+  var flat = function flat(routes) {
+    return routes.reduce(function (memo, route) {
+      return memo.concat(Array.isArray(route.routes) ? flat(route.routes) : [route]);
+    }, []);
+  };
+
+  var generate = function generate(route) {
+    var codes = [];
+    var lastComponent = route.component;
+    var imports = ["import React from 'react';", "import ".concat(lastComponent, " from '").concat(route._component, "'")]; // eslint-disable-next-line no-param-reassign, no-cond-assign
+
+    while (route = route.parent) {
+      var layoutComponent = route.component;
+      var layoutComponentAbbr = layoutNameAbbr(route._component);
+      imports.push("import ".concat(layoutComponent, " from '").concat(route._component, "';"));
+      var currentComponent = "".concat(layoutComponentAbbr, "_").concat(lastComponent);
+      codes.push("const ".concat(currentComponent, " = props => <").concat(layoutComponent, " Component={").concat(lastComponent, "} {...props} />;"));
+      lastComponent = currentComponent;
+    }
+
+    var file = path.resolve(internalComponentsDir, "".concat(lastComponent, ".jsx"));
+    fs.outputFileSync(file, "".concat(imports.join('\n'), "\n").concat(codes.join('\n'), "\nexport default ").concat(lastComponent));
+    return {
+      component: lastComponent,
+      _component: replaceWithAlias(internalDirectory, file, internalDirAlias)
+    };
+  };
+
+  var normalized = flat(nested).map(function (route) {
+    return route.parent ? _objectSpread(_objectSpread(_objectSpread({}, route), generate(route)), {}, {
+      parent: undefined
+    }) : _objectSpread(_objectSpread({}, route), {}, {
+      parent: undefined
+    });
+  });
+  return normalized;
+};
+
+export var getClientRoutes = function getClientRoutes(_ref2) {
+  var entrypoint = _ref2.entrypoint,
+      srcDirectory = _ref2.srcDirectory,
+      srcAlias = _ref2.srcAlias,
+      internalDirectory = _ref2.internalDirectory,
+      internalDirAlias = _ref2.internalDirAlias;
+  var entry = entrypoint.entry,
+      entryName = entrypoint.entryName;
+
+  if (!fs.existsSync(entry)) {
+    throw new Error("generate file system routes error, ".concat(entry, " directory not found."));
+  }
+
+  if (!(fs.existsSync(entry) && fs.statSync(entry).isDirectory())) {
+    throw new Error("generate file system routes error, ".concat(entry, " should be directory."));
+  }
+
+  var routes = [];
+  recursiveReadDirLegacy({
+    dir: entry,
+    routes: routes,
+    basePath: '/',
+    srcDirectory: srcDirectory,
+    srcAlias: srcAlias
+  });
+  var internalComponentsDir = path.resolve(internalDirectory, "".concat(entryName, "/").concat(FILE_SYSTEM_ROUTES_COMPONENTS_DIR));
+  fs.emptyDirSync(internalComponentsDir);
+  routes = normalizeNestedRoutes(routes, internalComponentsDir, internalDirectory, internalDirAlias);
+  parents.length = 0; // FIXME: support more situations
+
+  routes.sort(function (a, b) {
+    var delta = getRouteWeight(a.path) - getRouteWeight(b.path);
+
+    if (delta === 0) {
+      return a.path.length - b.path.length;
+    }
+
+    return delta;
+  });
+  debug("fileSystem routes: %o", routes);
+  return routes;
+};

package/dist/js/treeshaking/analyze/getClientRoutes/index.js

@@ -0,0 +1,2 @@
+export { getClientRoutes } from "./getRoutes";
+export { getClientRoutes as getClientRoutesLegacy } from "./getRoutesLegacy";

package/dist/js/treeshaking/analyze/getClientRoutes/utils.js

@@ -0,0 +1,27 @@
+import path from 'path';
+import { createDebugger, findExists, fs } from '@modern-js/utils';
+import { JS_EXTENSIONS, FILE_SYSTEM_ROUTES_LAYOUT, FILE_SYSTEM_ROUTES_GLOBAL_LAYOUT, FILE_SYSTEM_ROUTES_IGNORED_REGEX } from "../constants";
+var debug = createDebugger('get-client-routes');
+export { debug };
+export var findLayout = function findLayout(dir) {
+  return findExists(JS_EXTENSIONS.map(function (ext) {
+    return path.resolve(dir, "".concat(FILE_SYSTEM_ROUTES_LAYOUT).concat(ext));
+  }));
+};
+export var getRouteWeight = function getRouteWeight(route) {
+  return route === '*' ? 999 : route.split(':').length - 1;
+};
+export var shouldSkip = function shouldSkip(file) {
+  // should not skip directory.
+  if (fs.statSync(file).isDirectory()) {
+    return false;
+  }
+
+  var ext = path.extname(file);
+
+  if (FILE_SYSTEM_ROUTES_IGNORED_REGEX.test(file) || !JS_EXTENSIONS.includes(ext) || FILE_SYSTEM_ROUTES_GLOBAL_LAYOUT === path.basename(file, ext)) {
+    return true;
+  }
+
+  return false;
+};

package/dist/js/treeshaking/analyze/getFileSystemEntry.js

@@ -0,0 +1,109 @@
+import fs from 'fs';
+import path from 'path';
+import { findExists, ensureAbsolutePath } from '@modern-js/utils';
+import { isDefaultExportFunction } from "./isDefaultExportFunction";
+import { JS_EXTENSIONS, INDEX_FILE_NAME, APP_FILE_NAME, PAGES_DIR_NAME, FILE_SYSTEM_ROUTES_GLOBAL_LAYOUT, NESTED_ROUTES_DIR } from "./constants";
+
+var hasIndex = function hasIndex(dir) {
+  return findExists(JS_EXTENSIONS.map(function (ext) {
+    return path.resolve(dir, "".concat(INDEX_FILE_NAME).concat(ext));
+  }));
+};
+
+var hasApp = function hasApp(dir) {
+  return findExists(JS_EXTENSIONS.map(function (ext) {
+    return path.resolve(dir, "".concat(APP_FILE_NAME).concat(ext));
+  }));
+};
+
+var hasPages = function hasPages(dir) {
+  return fs.existsSync(path.join(dir, PAGES_DIR_NAME));
+};
+
+var hasNestedRoutes = function hasNestedRoutes(dir) {
+  return fs.existsSync(path.join(dir, NESTED_ROUTES_DIR));
+};
+
+var isBundleEntry = function isBundleEntry(dir) {
+  return hasApp(dir) || hasPages(dir) || hasIndex(dir) || hasNestedRoutes(dir);
+};
+
+var scanDir = function scanDir(dirs) {
+  return dirs.map(function (dir) {
+    var indexFile = hasIndex(dir);
+    var customBootstrap = isDefaultExportFunction(indexFile) ? indexFile : false;
+    var entryName = path.basename(dir);
+
+    if (indexFile && !customBootstrap) {
+      return {
+        entryName: entryName,
+        entry: indexFile,
+        isAutoMount: false
+      };
+    }
+
+    var isHasApp = hasApp(dir);
+
+    if (isHasApp) {
+      return {
+        entryName: entryName,
+        entry: path.join(dir, APP_FILE_NAME),
+        isAutoMount: true,
+        customBootstrap: customBootstrap
+      };
+    }
+
+    var isHasNestedRoutes = hasNestedRoutes(dir);
+    var isHasPages = hasPages(dir);
+
+    if (isHasNestedRoutes || isHasPages) {
+      var entrypoint = {
+        entryName: entryName,
+        entry: '',
+        fileSystemRoutes: {
+          globalApp: findExists(JS_EXTENSIONS.map(function (ext) {
+            return path.resolve(dir, "./".concat(PAGES_DIR_NAME, "/").concat(FILE_SYSTEM_ROUTES_GLOBAL_LAYOUT).concat(ext));
+          }))
+        },
+        isAutoMount: true,
+        customBootstrap: customBootstrap
+      };
+
+      if (isHasPages) {
+        entrypoint.entry = path.join(dir, PAGES_DIR_NAME);
+      }
+
+      if (isHasNestedRoutes) {
+        entrypoint.nestedRoutesEntry = path.join(dir, NESTED_ROUTES_DIR);
+      }
+
+      return entrypoint;
+    }
+
+    return {
+      entryName: entryName,
+      entry: indexFile,
+      isAutoMount: false
+    };
+  });
+};
+
+export var getFileSystemEntry = function getFileSystemEntry(appContext, config) {
+  var appDirectory = appContext.appDirectory;
+  var entriesDir = config.source.entriesDir;
+  var src = ensureAbsolutePath(appDirectory, entriesDir);
+
+  if (fs.existsSync(src)) {
+    if (fs.statSync(src).isDirectory()) {
+      return scanDir(isBundleEntry(src) ? [src] : fs.readdirSync(src).map(function (file) {
+        return path.join(src, file);
+      }).filter(function (file) {
+        return fs.statSync(file).isDirectory() && isBundleEntry(file);
+      }));
+    } else {
+      throw Error("source.entriesDir accept a directory.");
+    }
+  } else {
+    throw Error("src dir ".concat(entriesDir, " not found."));
+  }
+};

package/dist/js/treeshaking/analyze/getHtmlTemplate.js

@@ -0,0 +1,153 @@
+import _regeneratorRuntime from "@babel/runtime/helpers/esm/regeneratorRuntime";
+import _createForOfIteratorHelper from "@babel/runtime/helpers/esm/createForOfIteratorHelper";
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+import path from 'path';
+import { fs, findExists, MAIN_ENTRY_NAME } from '@modern-js/utils';
+import { HTML_PARTIALS_EXTENSIONS, HTML_PARTIALS_FOLDER } from "./constants";
+import * as templates from "./templates";
+var PartialPosition;
+
+(function (PartialPosition) {
+  PartialPosition["TOP"] = "top";
+  PartialPosition["HEAD"] = "head";
+  PartialPosition["BODY"] = "body";
+  PartialPosition["BOTTOM"] = "bottom";
+  PartialPosition["INDEX"] = "index";
+})(PartialPosition || (PartialPosition = {}));
+
+var findPartials = function findPartials(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: file,
+      content: fs.readFileSync(file, 'utf8')
+    } : null;
+  }
+
+  return null;
+}; // generate html template for
+
+
+export var getHtmlTemplate = /*#__PURE__*/function () {
+  var _ref2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(entrypoints, api, _ref) {
+    var appContext, config, appDirectory, internalDirectory, configDir, htmlDir, htmlTemplates, _iterator, _step, _loop;
+
+    return _regeneratorRuntime().wrap(function _callee$(_context2) {
+      while (1) {
+        switch (_context2.prev = _context2.next) {
+          case 0:
+            appContext = _ref.appContext, config = _ref.config;
+            appDirectory = appContext.appDirectory, internalDirectory = appContext.internalDirectory;
+            configDir = config.source.configDir;
+            htmlDir = path.resolve(appDirectory, configDir, HTML_PARTIALS_FOLDER);
+            htmlTemplates = {};
+            _iterator = _createForOfIteratorHelper(entrypoints);
+            _context2.prev = 6;
+            _loop = /*#__PURE__*/_regeneratorRuntime().mark(function _loop() {
+              var entrypoint, entryName, name, customIndexTemplate, hookRunners, _yield$hookRunners$ht, partials, templatePath, bottomTemplate;
+
+              return _regeneratorRuntime().wrap(function _loop$(_context) {
+                while (1) {
+                  switch (_context.prev = _context.next) {
+                    case 0:
+                      entrypoint = _step.value;
+                      entryName = entrypoint.entryName;
+                      name = entrypoints.length === 1 && entryName === MAIN_ENTRY_NAME ? '' : entryName;
+                      customIndexTemplate = findPartials(htmlDir, name, PartialPosition.INDEX);
+
+                      if (!customIndexTemplate) {
+                        _context.next = 8;
+                        break;
+                      }
+
+                      htmlTemplates[entryName] = customIndexTemplate.file;
+                      _context.next = 18;
+                      break;
+
+                    case 8:
+                      hookRunners = api.useHookRunners();
+                      _context.next = 11;
+                      return hookRunners.htmlPartials({
+                        entrypoint: entrypoint,
+                        partials: [PartialPosition.TOP, PartialPosition.HEAD, PartialPosition.BODY].reduce(function (previous, position) {
+                          var found = findPartials(htmlDir, name, position);
+                          previous[position] = found ? [found.content] : [];
+                          return previous;
+                        }, {
+                          top: [],
+                          head: [],
+                          body: []
+                        })
+                      });
+
+                    case 11:
+                      _yield$hookRunners$ht = _context.sent;
+                      partials = _yield$hookRunners$ht.partials;
+                      templatePath = path.resolve(internalDirectory, entryName, 'index.html');
+                      fs.outputFileSync(templatePath, templates.html(partials), 'utf8');
+                      htmlTemplates[entryName] = templatePath;
+                      bottomTemplate = findPartials(htmlDir, name, PartialPosition.BOTTOM);
+
+                      if (bottomTemplate) {
+                        htmlTemplates["__".concat(entryName, "-bottom__")] = bottomTemplate.content;
+                      }
+
+                    case 18:
+                    case "end":
+                      return _context.stop();
+                  }
+                }
+              }, _loop);
+            });
+
+            _iterator.s();
+
+          case 9:
+            if ((_step = _iterator.n()).done) {
+              _context2.next = 13;
+              break;
+            }
+
+            return _context2.delegateYield(_loop(), "t0", 11);
+
+          case 11:
+            _context2.next = 9;
+            break;
+
+          case 13:
+            _context2.next = 18;
+            break;
+
+          case 15:
+            _context2.prev = 15;
+            _context2.t1 = _context2["catch"](6);
+
+            _iterator.e(_context2.t1);
+
+          case 18:
+            _context2.prev = 18;
+
+            _iterator.f();
+
+            return _context2.finish(18);
+
+          case 21:
+            return _context2.abrupt("return", htmlTemplates);
+
+          case 22:
+          case "end":
+            return _context2.stop();
+        }
+      }
+    }, _callee, null, [[6, 15, 18, 21]]);
+  }));
+
+  return function getHtmlTemplate(_x, _x2, _x3) {
+    return _ref2.apply(this, arguments);
+  };
+}();

package/dist/js/treeshaking/analyze/getServerRoutes.js

@@ -0,0 +1,170 @@
+import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+var _excluded = ["path"],
+    _excluded2 = ["path"];
+import path from 'path';
+import fs from 'fs';
+import { urlJoin, isPlainObject, removeLeadingSlash, getEntryOptions, SERVER_BUNDLE_DIRECTORY, MAIN_ENTRY_NAME, removeTailSlash } from '@modern-js/utils';
+import { walkDirectory } from "./utils";
+/**
+ * Add base url for each server route.
+ * @param baseUrl - Base url from server.baseUrl
+ * @param routes - Server routes.
+ * @returns Server routes with baseUrl prefixed.
+ */
+
+var applyBaseUrl = function applyBaseUrl(baseUrl, routes) {
+  if (baseUrl) {
+    if (Array.isArray(baseUrl)) {
+      return baseUrl.reduce(function (previous, current) {
+        return [].concat(_toConsumableArray(previous), _toConsumableArray(applyBaseUrl(current, routes)));
+      }, []);
+    } else {
+      return routes.map(function (route) {
+        var urlPath = urlJoin(baseUrl, route.urlPath);
+        return _objectSpread(_objectSpread({}, route), {}, {
+          urlPath: urlPath === '/' ? urlPath : removeTailSlash(urlPath)
+        });
+      });
+    }
+  }
+
+  return routes;
+};
+/**
+ *
+ * @param original - Original entrypoint route info.
+ * @param routeOptions - Custom entrypoint route config from server.routes.
+ * @returns
+ */
+
+
+var applyRouteOptions = function applyRouteOptions(original, routeOptions) {
+  var route = routeOptions.route,
+      disableSpa = routeOptions.disableSpa;
+  original.isSPA = !disableSpa; // set entryPath as dir
+
+  !original.isSPA && (original.entryPath = path.dirname(original.entryPath));
+  var routes;
+
+  if (route) {
+    if (Array.isArray(route)) {
+      routes = route.map(function (url) {
+        if (isPlainObject(url)) {
+          var _ref = url,
+              urlPath = _ref.path,
+              other = _objectWithoutProperties(_ref, _excluded);
+
+          return _objectSpread(_objectSpread(_objectSpread({}, original), other), {}, {
+            urlPath: urlPath
+          });
+        } else {
+          return _objectSpread(_objectSpread({}, original), {}, {
+            urlPath: url
+          });
+        }
+      });
+    } else if (isPlainObject(route)) {
+      var _ref2 = route,
+          urlPath = _ref2.path,
+          other = _objectWithoutProperties(_ref2, _excluded2);
+
+      routes = [_objectSpread(_objectSpread(_objectSpread({}, original), other), {}, {
+        urlPath: urlPath
+      })];
+    } else {
+      routes = [_objectSpread(_objectSpread({}, original), {}, {
+        urlPath: route
+      })];
+    }
+  } else {
+    routes = [original];
+  }
+
+  return routes;
+};
+/**
+ * Collect routes from entrypoints.
+ * @param entrypoints - Bundle entrypoints.
+ * @param config - Normalized user config.
+ * @returns entrypoint Routes
+ */
+
+
+var collectHtmlRoutes = function collectHtmlRoutes(entrypoints, appContext, config) {
+  var _config$output = config.output,
+      htmlPath = _config$output.htmlPath,
+      disableHtmlFolder = _config$output.disableHtmlFolder,
+      enableModernMode = _config$output.enableModernMode,
+      _config$server = config.server,
+      baseUrl = _config$server.baseUrl,
+      routes = _config$server.routes,
+      ssr = _config$server.ssr,
+      ssrByEntries = _config$server.ssrByEntries;
+  var packageName = appContext.packageName;
+  var htmlRoutes = entrypoints.reduce(function (previous, _ref3) {
+    var entryName = _ref3.entryName;
+    var entryOptions = getEntryOptions(entryName, ssr, ssrByEntries, packageName);
+    var isSSR = Boolean(entryOptions);
+
+    var _ref4 = (routes === null || routes === void 0 ? void 0 : routes[entryName]) || {},
+        resHeaders = _ref4.resHeaders;
+
+    var route = {
+      urlPath: "/".concat(entryName === MAIN_ENTRY_NAME ? '' : entryName),
+      entryName: entryName,
+      entryPath: removeLeadingSlash(path.posix.normalize("".concat(htmlPath, "/").concat(entryName).concat(disableHtmlFolder ? '.html' : '/index.html'))),
+      isSPA: true,
+      isSSR: isSSR,
+      responseHeaders: resHeaders,
+      enableModernMode: Boolean(enableModernMode),
+      bundle: isSSR ? "".concat(SERVER_BUNDLE_DIRECTORY, "/").concat(entryName, ".js") : undefined
+    };
+
+    if (routes !== null && routes !== void 0 && routes.hasOwnProperty(entryName)) {
+      var routeOptions = isPlainObject(routes[entryName]) ? routes[entryName] : {
+        route: routes[entryName]
+      };
+      route = applyRouteOptions(route, routeOptions);
+    }
+
+    return Array.isArray(route) ? [].concat(_toConsumableArray(previous), _toConsumableArray(route)) : [].concat(_toConsumableArray(previous), [route]);
+  }, []);
+  htmlRoutes = applyBaseUrl(baseUrl, htmlRoutes);
+  return htmlRoutes;
+};
+/**
+ * Collect static public file routes from config/public folder.
+ * @param appContext - App context info.
+ * @param config - normalized user config.
+ * @returns Static public file routes.
+ */
+
+
+var collectStaticRoutes = function collectStaticRoutes(appContext, config) {
+  var appDirectory = appContext.appDirectory;
+  var configDir = config.source.configDir,
+      _config$server$public = config.server.publicRoutes,
+      publicRoutes = _config$server$public === void 0 ? {} : _config$server$public;
+  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))
+    };
+  }) : [];
+};
+
+export var getServerRoutes = function getServerRoutes(entrypoints, _ref5) {
+  var appContext = _ref5.appContext,
+      config = _ref5.config;
+  return [].concat(_toConsumableArray(collectHtmlRoutes(entrypoints, appContext, config)), _toConsumableArray(collectStaticRoutes(appContext, config)));
+};
+
+var toPosix = function toPosix(pathStr) {
+  return pathStr.split(path.sep).join(path.posix.sep);
+};