@modern-js/runtime 2.53.0 → 2.54.0

package/dist/esm/router/cli/code/templates.js

@@ -0,0 +1,417 @@
+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 _sliced_to_array } from "@swc/helpers/_/_sliced_to_array";
+import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
+import path from "path";
+import { fs, getEntryOptions, isSSGEntry, slash } from "@modern-js/utils";
+import { ROUTE_MODULES } from "@modern-js/utils/universal/constants";
+import { TEMP_LOADERS_DIR } from "../constants";
+import { getServerLoadersFile } from "./utils";
+var routesForServer = function(param) {
+  var routes = param.routes;
+  var loaders = [];
+  var actions = [];
+  var loadersMap = {};
+  var traverseRouteTree = function(route2) {
+    var children;
+    if ("children" in route2 && route2.children) {
+      var _route_children;
+      children = route2 === null || route2 === void 0 ? void 0 : (_route_children = route2.children) === null || _route_children === void 0 ? void 0 : _route_children.map(traverseRouteTree);
+    }
+    var loader;
+    var action;
+    if (route2.type === "nested") {
+      if (route2.loader || route2.data) {
+        loaders.push(route2.loader);
+        var loaderId = loaders.length - 1;
+        loader = "loader_".concat(loaderId);
+        var inline = Boolean(route2.data);
+        loadersMap[loader] = {
+          loaderId,
+          routeId: route2.id,
+          filePath: route2.data || route2.loader,
+          clientData: Boolean(route2.clientData),
+          route: route2,
+          inline
+        };
+        if (route2.action) {
+          actions.push(route2.action);
+          action = "action_".concat(loaders.length - 1);
+        }
+      }
+    }
+    var finalRoute = _object_spread_props(_object_spread({}, route2), {
+      loader,
+      action,
+      children
+    });
+    return finalRoute;
+  };
+  var routesCode = "\n  export const routes = [\n  ";
+  var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
+  try {
+    for (var _iterator = routes[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+      var route = _step.value;
+      if ("type" in route) {
+        var keywords = [
+          "loader",
+          "action"
+        ];
+        var regs = keywords.map(createMatchReg);
+        var newRoute = traverseRouteTree(route);
+        var routeStr = JSON.stringify(newRoute, null, 2);
+        routesCode += regs.reduce(function(acc, reg) {
+          return acc.replace(reg, "$1$2");
+        }, routeStr).replace(/\\"/g, '"');
+      } else {
+        routesCode += "".concat(JSON.stringify(route, null, 2));
+      }
+    }
+  } catch (err) {
+    _didIteratorError = true;
+    _iteratorError = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion && _iterator.return != null) {
+        _iterator.return();
+      }
+    } finally {
+      if (_didIteratorError) {
+        throw _iteratorError;
+      }
+    }
+  }
+  routesCode += "\n];";
+  var importLoadersCode = "";
+  var _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = void 0;
+  try {
+    for (var _iterator1 = Object.entries(loadersMap)[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true) {
+      var _step_value = _sliced_to_array(_step1.value, 2), key = _step_value[0], loaderInfo = _step_value[1];
+      if (loaderInfo.inline) {
+        var route1 = loaderInfo.route;
+        if (route1.action) {
+          importLoadersCode += "import { loader as ".concat(key, ", action as action_").concat(loaderInfo.loaderId, ' } from "').concat(slash(loaderInfo.filePath), '";\n');
+        } else {
+          importLoadersCode += "import { loader as ".concat(key, ' } from "').concat(slash(loaderInfo.filePath), '";\n');
+        }
+      } else {
+        importLoadersCode += "import ".concat(key, ' from "').concat(slash(loaderInfo.filePath), '";\n');
+      }
+    }
+  } catch (err) {
+    _didIteratorError1 = true;
+    _iteratorError1 = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+        _iterator1.return();
+      }
+    } finally {
+      if (_didIteratorError1) {
+        throw _iteratorError1;
+      }
+    }
+  }
+  return "\n    ".concat(importLoadersCode, "\n    ").concat(routesCode, "\n  ");
+};
+var createMatchReg = function(keyword) {
+  return new RegExp('("'.concat(keyword, '":\\s)"([^\n]+)"'), "g");
+};
+var fileSystemRoutes = function() {
+  var _ref = _async_to_generator(function(param) {
+    var routes, ssrMode, nestedRoutesEntry, entryName, internalDirectory, _param_splitRouteChunks, splitRouteChunks, components, loadings, errors, loaders, loadersMap, configs, configsMap, loadersMapFile, importLazyCode, rootLayoutCode, getDataLoaderPath, traverseRouteTree, routeComponentsCode, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, route, newRoute, routeStr, keywords, regs, newRouteStr, component, finalRoute, keywords1, routeStr1, regs1, newRouteStr1, importLoadingCode, importComponentsCode, importErrorComponentsCode, importLoadersCode, _iteratorNormalCompletion1, _didIteratorError1, _iteratorError1, _iterator1, _step1, _step_value, key, loaderInfo, route1, importConfigsCode, _iteratorNormalCompletion2, _didIteratorError2, _iteratorError2, _iterator2, _step2, _step_value1, key1, configPath, importRuntimeRouterCode, routeModulesCode;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          routes = param.routes, ssrMode = param.ssrMode, nestedRoutesEntry = param.nestedRoutesEntry, entryName = param.entryName, internalDirectory = param.internalDirectory, _param_splitRouteChunks = param.splitRouteChunks, splitRouteChunks = _param_splitRouteChunks === void 0 ? true : _param_splitRouteChunks;
+          components = [];
+          loadings = [];
+          errors = [];
+          loaders = [];
+          loadersMap = {};
+          configs = [];
+          configsMap = {};
+          loadersMapFile = path.join(internalDirectory, entryName, TEMP_LOADERS_DIR, "map.json");
+          importLazyCode = '\n    import { lazy } from "react";\n    import loadable, { lazy as loadableLazy } from "@modern-js/runtime/loadable"\n  ';
+          rootLayoutCode = "";
+          getDataLoaderPath = function(param2) {
+            var loaderId = param2.loaderId, clientData = param2.clientData, action = param2.action, inline = param2.inline, routeId = param2.routeId;
+            if (!ssrMode) {
+              return "";
+            }
+            var clientDataStr = clientData ? "&clientData=".concat(clientData) : "";
+            if (nestedRoutesEntry) {
+              return "?loaderId=".concat(loaderId).concat(clientDataStr, "&action=").concat(action ? slash(action) : action, "&inline=").concat(inline, "&routeId=").concat(routeId);
+            }
+            return "";
+          };
+          traverseRouteTree = function(route2) {
+            var children;
+            if ("children" in route2 && route2.children) {
+              var _route_children;
+              children = route2 === null || route2 === void 0 ? void 0 : (_route_children = route2.children) === null || _route_children === void 0 ? void 0 : _route_children.map(traverseRouteTree);
+            }
+            var loading;
+            var error;
+            var loader;
+            var action;
+            var config;
+            var component2 = "";
+            var lazyImport = null;
+            if (route2.type === "nested") {
+              if (route2.loading) {
+                loadings.push(route2.loading);
+                loading = "loading_".concat(loadings.length - 1);
+              }
+              if (route2.error) {
+                errors.push(route2.error);
+                error = "error_".concat(errors.length - 1);
+              }
+              if (route2.loader || route2.data) {
+                loaders.push(route2.loader);
+                var loaderId = loaders.length - 1;
+                loader = "loader_".concat(loaderId);
+                var inline = Boolean(route2.data);
+                loadersMap[loader] = {
+                  loaderId,
+                  routeId: route2.id,
+                  filePath: route2.data || route2.loader,
+                  clientData: Boolean(route2.clientData),
+                  route: route2,
+                  inline
+                };
+                loader = "loader_".concat(loaderId);
+                if (route2.action) {
+                  action = "action_".concat(loaderId);
+                }
+              }
+              if (typeof route2.config === "string") {
+                configs.push(route2.config);
+                var configId = configs.length - 1;
+                config = "config_".concat(configId);
+                configsMap[config] = route2.config;
+              }
+              if (route2._component) {
+                if (splitRouteChunks) {
+                  if (route2.isRoot) {
+                    lazyImport = "() => import('".concat(route2._component, `').then(routeModule => handleRouteModule(routeModule, "`).concat(route2.id, '")).catch(handleRouteModuleError) ');
+                    rootLayoutCode = "import RootLayout from '".concat(route2._component, "'");
+                    component2 = "RootLayout";
+                  } else if (ssrMode === "string") {
+                    lazyImport = '() => import(/* webpackChunkName: "'.concat(route2.id, `" */  '`).concat(route2._component, `').then(routeModule => handleRouteModule(routeModule, "`).concat(route2.id, '")).catch(handleRouteModuleError) ');
+                    component2 = "loadable(".concat(lazyImport, ")");
+                  } else {
+                    lazyImport = '() => import(/* webpackChunkName: "'.concat(route2.id, `" */  '`).concat(route2._component, `').then(routeModule => handleRouteModule(routeModule, "`).concat(route2.id, '")).catch(handleRouteModuleError) ');
+                    component2 = "lazy(".concat(lazyImport, ")");
+                  }
+                } else if (ssrMode === "string") {
+                  components.push(route2._component);
+                  component2 = "component_".concat(components.length - 1);
+                } else {
+                  lazyImport = `() => import(/* webpackMode: "eager" */  '`.concat(route2._component, `').then(routeModule => handleRouteModule(routeModule, "`).concat(route2.id, '")).catch(handleRouteModuleError) ');
+                  component2 = "lazy(".concat(lazyImport, ")");
+                }
+              }
+            } else if (route2._component) {
+              if (splitRouteChunks) {
+                lazyImport = "() => import('".concat(route2._component, "')");
+                component2 = "loadable(".concat(lazyImport, ")");
+              } else {
+                components.push(route2._component);
+                component2 = "component_".concat(components.length - 1);
+              }
+            }
+            var finalRoute2 = _object_spread_props(_object_spread({}, route2), {
+              lazyImport,
+              loading,
+              loader,
+              action,
+              config,
+              error,
+              children
+            });
+            if (route2._component) {
+              finalRoute2.component = component2;
+            }
+            if (route2.type === "nested" && route2._component && (route2.loader || route2.data)) {
+              finalRoute2.shouldRevalidate = 'createShouldRevalidate("'.concat(route2.id, '")');
+            }
+            return finalRoute2;
+          };
+          routeComponentsCode = "\n    export const routes = [\n  ";
+          _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
+          try {
+            for (_iterator = routes[Symbol.iterator](); !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+              route = _step.value;
+              if ("type" in route) {
+                newRoute = traverseRouteTree(route);
+                routeStr = JSON.stringify(newRoute, null, 2);
+                keywords = [
+                  "component",
+                  "lazyImport",
+                  "shouldRevalidate",
+                  "loader",
+                  "action",
+                  "loading",
+                  "error",
+                  "config"
+                ];
+                regs = keywords.map(createMatchReg);
+                newRouteStr = regs.reduce(function(acc, reg) {
+                  return acc.replace(reg, "$1$2");
+                }, routeStr).replace(/"(RootLayout)"/g, "$1").replace(/\\"/g, '"');
+                routeComponentsCode += "".concat(newRouteStr, ",");
+              } else {
+                component = "loadable(() => import('".concat(route._component, "'))");
+                finalRoute = _object_spread_props(_object_spread({}, route), {
+                  component
+                });
+                keywords1 = [
+                  "component",
+                  "lazyImport"
+                ];
+                routeStr1 = JSON.stringify(finalRoute, null, 2);
+                regs1 = keywords1.map(createMatchReg);
+                newRouteStr1 = regs1.reduce(function(acc, reg) {
+                  return acc.replace(reg, "$1$2");
+                }, routeStr1).replace(/\\"/g, '"');
+                routeComponentsCode += "".concat(newRouteStr1, ",");
+              }
+            }
+          } catch (err) {
+            _didIteratorError = true;
+            _iteratorError = err;
+          } finally {
+            try {
+              if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+              }
+            } finally {
+              if (_didIteratorError) {
+                throw _iteratorError;
+              }
+            }
+          }
+          routeComponentsCode += "\n];";
+          importLoadingCode = loadings.map(function(loading, index) {
+            return "import loading_".concat(index, " from '").concat(loading, "';\n");
+          }).join("");
+          importComponentsCode = components.map(function(component2, index) {
+            return "import component_".concat(index, " from '").concat(component2, "';\n");
+          }).join("");
+          importErrorComponentsCode = errors.map(function(error, index) {
+            return "import error_".concat(index, " from '").concat(error, "';\n");
+          }).join("");
+          importLoadersCode = "";
+          _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = void 0;
+          try {
+            for (_iterator1 = Object.entries(loadersMap)[Symbol.iterator](); !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true) {
+              _step_value = _sliced_to_array(_step1.value, 2), key = _step_value[0], loaderInfo = _step_value[1];
+              if (loaderInfo.inline) {
+                route1 = loaderInfo.route;
+                if (route1.action) {
+                  importLoadersCode += "import { loader as ".concat(key, ", action as action_").concat(loaderInfo.loaderId, ' } from "').concat(slash(loaderInfo.filePath)).concat(getDataLoaderPath({
+                    loaderId: key,
+                    clientData: loaderInfo.clientData,
+                    action: route1.action,
+                    inline: loaderInfo.inline,
+                    routeId: loaderInfo.routeId
+                  }), '";\n');
+                } else {
+                  importLoadersCode += "import { loader as ".concat(key, ' } from "').concat(slash(loaderInfo.filePath)).concat(getDataLoaderPath({
+                    loaderId: key,
+                    clientData: loaderInfo.clientData,
+                    action: false,
+                    inline: loaderInfo.inline,
+                    routeId: route1.id
+                  }), '";\n');
+                }
+              } else {
+                importLoadersCode += "import ".concat(key, ' from "').concat(slash(loaderInfo.filePath)).concat(getDataLoaderPath({
+                  loaderId: key,
+                  clientData: loaderInfo.clientData,
+                  action: false,
+                  inline: loaderInfo.inline,
+                  routeId: loaderInfo.routeId
+                }), '";\n');
+              }
+            }
+          } catch (err) {
+            _didIteratorError1 = true;
+            _iteratorError1 = err;
+          } finally {
+            try {
+              if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+                _iterator1.return();
+              }
+            } finally {
+              if (_didIteratorError1) {
+                throw _iteratorError1;
+              }
+            }
+          }
+          importConfigsCode = "";
+          _iteratorNormalCompletion2 = true, _didIteratorError2 = false, _iteratorError2 = void 0;
+          try {
+            for (_iterator2 = Object.entries(configsMap)[Symbol.iterator](); !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
+              _step_value1 = _sliced_to_array(_step2.value, 2), key1 = _step_value1[0], configPath = _step_value1[1];
+              importConfigsCode += "import * as ".concat(key1, ' from "').concat(slash(configPath), '";\n');
+            }
+          } catch (err) {
+            _didIteratorError2 = true;
+            _iteratorError2 = err;
+          } finally {
+            try {
+              if (!_iteratorNormalCompletion2 && _iterator2.return != null) {
+                _iterator2.return();
+              }
+            } finally {
+              if (_didIteratorError2) {
+                throw _iteratorError2;
+              }
+            }
+          }
+          return [
+            4,
+            fs.ensureFile(loadersMapFile)
+          ];
+        case 1:
+          _state.sent();
+          return [
+            4,
+            fs.writeJSON(loadersMapFile, loadersMap)
+          ];
+        case 2:
+          _state.sent();
+          importRuntimeRouterCode = "\n    import { createShouldRevalidate, handleRouteModule,  handleRouteModuleError} from '@modern-js/runtime/router';\n  ";
+          routeModulesCode = "\n    if(typeof document !== 'undefined'){\n      window.".concat(ROUTE_MODULES, " = {}\n    }\n  ");
+          return [
+            2,
+            "\n    ".concat(importLazyCode, "\n    ").concat(importComponentsCode, "\n    ").concat(importRuntimeRouterCode, "\n    ").concat(rootLayoutCode, "\n    ").concat(importLoadingCode, "\n    ").concat(importErrorComponentsCode, "\n    ").concat(importLoadersCode, "\n    ").concat(importConfigsCode, "\n    ").concat(routeModulesCode, "\n    ").concat(routeComponentsCode, "\n  ")
+          ];
+      }
+    });
+  });
+  return function fileSystemRoutes2(_) {
+    return _ref.apply(this, arguments);
+  };
+}();
+function ssrLoaderCombinedModule(entrypoints, entrypoint, config, appContext) {
+  var entryName = entrypoint.entryName, isMainEntry = entrypoint.isMainEntry;
+  var packageName = appContext.packageName, internalDirectory = appContext.internalDirectory;
+  var ssr = getEntryOptions(entryName, isMainEntry, config.server.ssr, config.server.ssrByEntries, packageName);
+  var ssg = isSSGEntry(config, entryName, entrypoints);
+  if (entrypoint.nestedRoutesEntry && (ssr || ssg)) {
+    var serverLoaderRuntime = require.resolve("@modern-js/plugin-data-loader/runtime");
+    var serverLoadersFile = getServerLoadersFile(internalDirectory, entryName);
+    var combinedModule = 'export * from "'.concat(slash(serverLoaderRuntime), '"; export * from "').concat(slash(serverLoadersFile), '"');
+    return combinedModule;
+  }
+  return null;
+}
+export {
+  fileSystemRoutes,
+  routesForServer,
+  ssrLoaderCombinedModule
+};

package/dist/esm/router/cli/code/utils.js

@@ -0,0 +1,212 @@
+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 fs from "fs";
+import path from "path";
+import { normalizeToPosixPath, fs as fse, JS_EXTENSIONS } from "@modern-js/utils";
+import { transform } from "esbuild";
+import { parse } from "es-module-lexer";
+import { ACTION_EXPORT_NAME, LOADER_EXPORT_NAME } from "../constants";
+var walkDirectory = function(dir) {
+  return fs.readdirSync(dir).reduce(function(previous, filename) {
+    var filePath = path.join(dir, filename);
+    if (fs.statSync(filePath).isDirectory()) {
+      return _to_consumable_array(previous).concat(_to_consumable_array(walkDirectory(filePath)));
+    } else {
+      return _to_consumable_array(previous).concat([
+        filePath
+      ]);
+    }
+  }, []);
+};
+var isPageComponentFile = function(filePath) {
+  if (/\.(d|test|spec|e2e)\.(js|jsx|ts|tsx)$/.test(filePath)) {
+    return false;
+  }
+  if ([
+    ".js",
+    ".jsx",
+    ".ts",
+    ".tsx"
+  ].includes(path.extname(filePath))) {
+    return true;
+  }
+  return false;
+};
+var replaceWithAlias = function(base, filePath, alias) {
+  if (filePath.includes(base)) {
+    return normalizeToPosixPath(path.join(alias, path.relative(base, filePath)));
+  } else {
+    return filePath;
+  }
+};
+var parseModule = function() {
+  var _ref = _async_to_generator(function(param) {
+    var source, filename, content, result;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          source = param.source, filename = param.filename;
+          content = source;
+          if (!JS_EXTENSIONS.some(function(ext) {
+            return filename.endsWith(ext);
+          }))
+            return [
+              3,
+              2
+            ];
+          return [
+            4,
+            transform(content, {
+              loader: path.extname(filename).slice(1),
+              format: "esm"
+            })
+          ];
+        case 1:
+          result = _state.sent();
+          content = result.code;
+          _state.label = 2;
+        case 2:
+          return [
+            2,
+            parse(content)
+          ];
+      }
+    });
+  });
+  return function parseModule2(_) {
+    return _ref.apply(this, arguments);
+  };
+}();
+var hasLoader = function() {
+  var _ref = _async_to_generator(function(filename, source) {
+    var content, _ref2, moduleExports;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          content = source;
+          if (!!source)
+            return [
+              3,
+              2
+            ];
+          return [
+            4,
+            fse.readFile(filename, "utf-8")
+          ];
+        case 1:
+          content = _state.sent().toString();
+          _state.label = 2;
+        case 2:
+          if (!content)
+            return [
+              3,
+              4
+            ];
+          return [
+            4,
+            parseModule({
+              source: content.toString(),
+              filename
+            })
+          ];
+        case 3:
+          _ref2 = _sliced_to_array.apply(void 0, [
+            _state.sent(),
+            2
+          ]), moduleExports = _ref2[1];
+          return [
+            2,
+            moduleExports.some(function(e) {
+              return e.n === LOADER_EXPORT_NAME;
+            })
+          ];
+        case 4:
+          return [
+            2,
+            false
+          ];
+      }
+    });
+  });
+  return function hasLoader2(filename, source) {
+    return _ref.apply(this, arguments);
+  };
+}();
+var hasAction = function() {
+  var _ref = _async_to_generator(function(filename, source) {
+    var content, _ref2, moduleExports;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          content = source;
+          if (!!source)
+            return [
+              3,
+              2
+            ];
+          return [
+            4,
+            fse.readFile(filename, "utf-8")
+          ];
+        case 1:
+          content = _state.sent().toString();
+          _state.label = 2;
+        case 2:
+          if (!content)
+            return [
+              3,
+              4
+            ];
+          return [
+            4,
+            parseModule({
+              source: content.toString(),
+              filename
+            })
+          ];
+        case 3:
+          _ref2 = _sliced_to_array.apply(void 0, [
+            _state.sent(),
+            2
+          ]), moduleExports = _ref2[1];
+          return [
+            2,
+            moduleExports.some(function(e) {
+              return e.n === ACTION_EXPORT_NAME;
+            })
+          ];
+        case 4:
+          return [
+            2,
+            false
+          ];
+      }
+    });
+  });
+  return function hasAction2(filename, source) {
+    return _ref.apply(this, arguments);
+  };
+}();
+var getServerLoadersFile = function(internalDirectory, entryName) {
+  return path.join(internalDirectory, entryName, "route-server-loaders.js");
+};
+var getServerCombinedModueFile = function(internalDirectory, entryName) {
+  return path.join(internalDirectory, entryName, "server-loader-combined.js");
+};
+var getPathWithoutExt = function(filename) {
+  var extname = path.extname(filename);
+  return filename.slice(0, -extname.length);
+};
+export {
+  getPathWithoutExt,
+  getServerCombinedModueFile,
+  getServerLoadersFile,
+  hasAction,
+  hasLoader,
+  isPageComponentFile,
+  parseModule,
+  replaceWithAlias,
+  walkDirectory
+};

package/dist/esm/router/cli/constants.js

@@ -0,0 +1,47 @@
+var PAGES_DIR_NAME = "pages";
+var NESTED_ROUTES_DIR = "routes";
+var FILE_SYSTEM_ROUTES_FILE_NAME = "routes.js";
+var LOADER_EXPORT_NAME = "loader";
+var ACTION_EXPORT_NAME = "action";
+var TEMP_LOADERS_DIR = "__loaders__";
+var FILE_SYSTEM_ROUTES_LAYOUT = "_layout";
+var FILE_SYSTEM_ROUTES_GLOBAL_LAYOUT = "_app";
+var FILE_SYSTEM_ROUTES_INDEX = "index";
+var FILE_SYSTEM_ROUTES_IGNORED_REGEX = /\.(d|test|spec|e2e)\.(js|jsx|ts|tsx)$/;
+var FILE_SYSTEM_ROUTES_DYNAMIC_REGEXP = /^\[(\S+)\]([*+?]?)$/;
+var FILE_SYSTEM_ROUTES_COMPONENTS_DIR = "internal_components";
+var NESTED_ROUTE = {
+  LAYOUT_FILE: "layout",
+  LAYOUT_CONFIG_FILE: "layout.config",
+  LAYOUT_LOADER_FILE: "layout.loader",
+  LAYOUT_DATA_FILE: "layout.data",
+  LAYOUT_CLIENT_LOADER: "layout.data.client",
+  PAGE_FILE: "page",
+  PAGE_CONFIG_FILE: "page.config",
+  PAGE_LOADER_FILE: "page.loader",
+  PAGE_DATA_FILE: "page.data",
+  PAGE_CLIENT_LOADER: "page.data.client",
+  SPLATE_FILE: "$",
+  SPLATE_CONFIG_FILE: "$.config",
+  SPLATE_LOADER_FILE: "$.loader",
+  SPLATE_DATA_FILE: "$.data",
+  SPLATE_CLIENT_DATA: "$.data.client",
+  LOADING_FILE: "loading",
+  ERROR_FILE: "error",
+  LOADER_FILE: "loader"
+};
+export {
+  ACTION_EXPORT_NAME,
+  FILE_SYSTEM_ROUTES_COMPONENTS_DIR,
+  FILE_SYSTEM_ROUTES_DYNAMIC_REGEXP,
+  FILE_SYSTEM_ROUTES_FILE_NAME,
+  FILE_SYSTEM_ROUTES_GLOBAL_LAYOUT,
+  FILE_SYSTEM_ROUTES_IGNORED_REGEX,
+  FILE_SYSTEM_ROUTES_INDEX,
+  FILE_SYSTEM_ROUTES_LAYOUT,
+  LOADER_EXPORT_NAME,
+  NESTED_ROUTE,
+  NESTED_ROUTES_DIR,
+  PAGES_DIR_NAME,
+  TEMP_LOADERS_DIR
+};