@modern-js/runtime 2.52.0 → 2.54.0

package/dist/cjs/router/cli/code/nestedRoutes.js

@@ -0,0 +1,294 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var nestedRoutes_exports = {};
+__export(nestedRoutes_exports, {
+  getRouteId: () => getRouteId,
+  optimizeRoute: () => optimizeRoute,
+  walk: () => walk
+});
+module.exports = __toCommonJS(nestedRoutes_exports);
+var path = __toESM(require("path"));
+var import_utils = require("@modern-js/utils");
+var import_constants = require("../constants");
+var import_utils2 = require("./utils");
+const conventionNames = Object.values(import_constants.NESTED_ROUTE);
+const replaceDynamicPath = (routePath) => {
+  return routePath.replace(/\[(.*?)\]/g, ":$1");
+};
+const getRouteId = (componentPath, routesDir, entryName, isMainEntry) => {
+  const relativePath = (0, import_utils.normalizeToPosixPath)(path.relative(routesDir, componentPath));
+  const pathWithoutExt = (0, import_utils2.getPathWithoutExt)(relativePath);
+  let id = ``;
+  if (isMainEntry) {
+    id = pathWithoutExt;
+  } else {
+    id = `${entryName}_${pathWithoutExt}`;
+  }
+  return id.replace(/\[(.*?)\]/g, "($1)");
+};
+const createIndexRoute = (routeInfo, rootDir, filename, entryName, isMainEntry) => {
+  return createRoute({
+    ...routeInfo,
+    index: true,
+    children: void 0
+  }, rootDir, filename, entryName, isMainEntry);
+};
+const createRoute = (routeInfo, rootDir, filename, entryName, isMainEntry) => {
+  const id = getRouteId(filename, rootDir, entryName, isMainEntry);
+  return {
+    ...routeInfo,
+    id,
+    type: "nested"
+  };
+};
+const optimizeRoute = (routeTree) => {
+  if (!routeTree.children || routeTree.children.length === 0) {
+    return [
+      routeTree
+    ];
+  }
+  const { children } = routeTree;
+  if (!routeTree._component && !routeTree.error && !routeTree.loading && !routeTree.config && !routeTree.clientData) {
+    const newRoutes = children.map((child) => {
+      const routePath = `${routeTree.path ? routeTree.path : ""}${child.path ? `/${child.path}` : ""}`;
+      const newRoute = {
+        ...child,
+        path: routePath.replace(/\/\//g, "/")
+      };
+      if (routePath.length > 0) {
+        delete newRoute.index;
+      } else {
+        delete newRoute.path;
+      }
+      return newRoute;
+    });
+    return Array.from(new Set(newRoutes)).flatMap(optimizeRoute);
+  } else {
+    const optimizedChildren = routeTree.children.flatMap(optimizeRoute);
+    return [
+      {
+        ...routeTree,
+        children: optimizedChildren
+      }
+    ];
+  }
+};
+const walk = async (dirname, rootDir, alias, entryName, isMainEntry, oldVersion) => {
+  var _finalRoute_children;
+  if (!await import_utils.fs.pathExists(dirname)) {
+    return null;
+  }
+  const isDirectory = (await import_utils.fs.stat(dirname)).isDirectory();
+  if (!isDirectory) {
+    return null;
+  }
+  const relativeDir = path.relative(rootDir, dirname);
+  const pathSegments = relativeDir.split(path.sep);
+  const lastSegment = pathSegments[pathSegments.length - 1];
+  const isRoot = lastSegment === "";
+  const isPathlessLayout = lastSegment.startsWith("__");
+  const isWithoutLayoutPath = lastSegment.includes(".");
+  let routePath = isRoot || isPathlessLayout ? "/" : `${lastSegment}`;
+  if (isWithoutLayoutPath) {
+    routePath = lastSegment.split(".").join("/");
+  }
+  routePath = replaceDynamicPath(routePath);
+  const route = {
+    path: routePath === null || routePath === void 0 ? void 0 : routePath.replace(/\$$/, "?"),
+    children: [],
+    isRoot
+  };
+  let pageLoaderFile = "";
+  let pageRoute = null;
+  let pageConfigFile = "";
+  let pageClientData = "";
+  let pageData = "";
+  let pageAction = "";
+  let splatLoaderFile = "";
+  let splatRoute = null;
+  let splatConfigFile = "";
+  let splatClientData = "";
+  let splatData = "";
+  let splatAction = "";
+  const items = await import_utils.fs.readdir(dirname);
+  for (const item of items) {
+    const itemPath = path.join(dirname, item);
+    const itemPathWithAlias = (0, import_utils2.getPathWithoutExt)((0, import_utils2.replaceWithAlias)(alias.basename, itemPath, alias.name));
+    const extname = path.extname(item);
+    const itemWithoutExt = item.slice(0, -extname.length);
+    const isDirectory2 = (await import_utils.fs.stat(itemPath)).isDirectory();
+    if (isDirectory2) {
+      const childRoute = await walk(itemPath, rootDir, alias, entryName, isMainEntry, oldVersion);
+      if (childRoute && !Array.isArray(childRoute)) {
+        var _route_children;
+        (_route_children = route.children) === null || _route_children === void 0 ? void 0 : _route_children.push(childRoute);
+      }
+    }
+    if (extname && (!import_utils.JS_EXTENSIONS.includes(extname) || !conventionNames.includes(itemWithoutExt))) {
+      continue;
+    }
+    if (itemWithoutExt === import_constants.NESTED_ROUTE.LAYOUT_LOADER_FILE) {
+      if (!route.loader) {
+        route.loader = itemPathWithAlias;
+      }
+    }
+    if (itemWithoutExt === import_constants.NESTED_ROUTE.LAYOUT_CLIENT_LOADER) {
+      route.clientData = itemPathWithAlias;
+    }
+    if (itemWithoutExt === import_constants.NESTED_ROUTE.LAYOUT_DATA_FILE) {
+      route.data = itemPathWithAlias;
+      if (await (0, import_utils2.hasAction)(itemPath)) {
+        route.action = itemPathWithAlias;
+      }
+    }
+    if (itemWithoutExt === import_constants.NESTED_ROUTE.LAYOUT_CONFIG_FILE) {
+      if (!route.config) {
+        route.config = itemPathWithAlias;
+      }
+    }
+    if (itemWithoutExt === import_constants.NESTED_ROUTE.LAYOUT_FILE) {
+      route._component = itemPathWithAlias;
+    }
+    if (itemWithoutExt === import_constants.NESTED_ROUTE.PAGE_LOADER_FILE) {
+      pageLoaderFile = itemPathWithAlias;
+    }
+    if (itemWithoutExt === import_constants.NESTED_ROUTE.PAGE_CLIENT_LOADER) {
+      pageClientData = itemPathWithAlias;
+    }
+    if (itemWithoutExt === import_constants.NESTED_ROUTE.PAGE_DATA_FILE) {
+      pageData = itemPathWithAlias;
+      if (await (0, import_utils2.hasAction)(itemPath)) {
+        pageAction = itemPathWithAlias;
+      }
+    }
+    if (itemWithoutExt === import_constants.NESTED_ROUTE.PAGE_CONFIG_FILE) {
+      pageConfigFile = itemPathWithAlias;
+    }
+    if (itemWithoutExt === import_constants.NESTED_ROUTE.PAGE_FILE) {
+      var _route_children1;
+      pageRoute = createIndexRoute({
+        _component: itemPathWithAlias
+      }, rootDir, itemPath, entryName, isMainEntry);
+      if (pageLoaderFile) {
+        pageRoute.loader = pageLoaderFile;
+      }
+      if (pageConfigFile) {
+        pageRoute.config = pageConfigFile;
+      }
+      if (pageData) {
+        pageRoute.data = pageData;
+      }
+      if (pageClientData) {
+        pageRoute.clientData = pageClientData;
+      }
+      if (pageAction) {
+        pageRoute.action = pageAction;
+      }
+      (_route_children1 = route.children) === null || _route_children1 === void 0 ? void 0 : _route_children1.push(pageRoute);
+    }
+    if (itemWithoutExt === import_constants.NESTED_ROUTE.SPLATE_LOADER_FILE) {
+      splatLoaderFile = itemPathWithAlias;
+    }
+    if (itemWithoutExt === import_constants.NESTED_ROUTE.SPLATE_CLIENT_DATA) {
+      splatClientData = itemPathWithAlias;
+    }
+    if (itemWithoutExt === import_constants.NESTED_ROUTE.SPLATE_CONFIG_FILE) {
+      if (!route.config) {
+        splatConfigFile = (0, import_utils2.replaceWithAlias)(alias.basename, itemPath, alias.name);
+      }
+    }
+    if (itemWithoutExt === import_constants.NESTED_ROUTE.SPLATE_DATA_FILE) {
+      splatData = itemPathWithAlias;
+      if (await (0, import_utils2.hasAction)(itemPath)) {
+        splatAction = itemPathWithAlias;
+      }
+    }
+    if (itemWithoutExt === import_constants.NESTED_ROUTE.SPLATE_FILE) {
+      var _route_children2;
+      splatRoute = createRoute({
+        _component: itemPathWithAlias,
+        path: "*"
+      }, rootDir, itemPath, entryName, isMainEntry);
+      if (splatLoaderFile) {
+        splatRoute.loader = splatLoaderFile;
+      }
+      if (splatClientData) {
+        splatRoute.clientData = splatClientData;
+      }
+      if (splatData) {
+        splatRoute.data = splatData;
+      }
+      if (splatConfigFile) {
+        splatRoute.config = splatConfigFile;
+      }
+      if (splatAction) {
+        splatRoute.action = splatAction;
+      }
+      (_route_children2 = route.children) === null || _route_children2 === void 0 ? void 0 : _route_children2.push(splatRoute);
+    }
+    if (itemWithoutExt === import_constants.NESTED_ROUTE.LOADING_FILE) {
+      route.loading = itemPathWithAlias;
+    }
+    if (itemWithoutExt === import_constants.NESTED_ROUTE.ERROR_FILE) {
+      route.error = itemPathWithAlias;
+    }
+  }
+  let finalRoute = createRoute(route, rootDir, path.join(dirname, `${import_constants.NESTED_ROUTE.LAYOUT_FILE}.ts`), entryName, isMainEntry);
+  if (isPathlessLayout) {
+    delete finalRoute.path;
+  }
+  const childRoutes = finalRoute.children = (_finalRoute_children = finalRoute.children) === null || _finalRoute_children === void 0 ? void 0 : _finalRoute_children.filter((childRoute) => childRoute);
+  if (childRoutes && childRoutes.length === 0 && !finalRoute.index && !finalRoute._component) {
+    return null;
+  }
+  if (childRoutes && childRoutes.length === 1 && !finalRoute._component) {
+    const childRoute = childRoutes[0];
+    if (childRoute.path === "*") {
+      const path2 = `${finalRoute.path || ""}/${childRoute.path || ""}`;
+      finalRoute = {
+        ...childRoute,
+        path: path2
+      };
+    }
+  }
+  if (isRoot && !finalRoute._component) {
+    throw new Error("The root layout component is required, make sure the routes/layout.tsx file exists.");
+  }
+  if (isRoot && !oldVersion) {
+    const optimizedRoutes = optimizeRoute(finalRoute);
+    return optimizedRoutes;
+  }
+  return finalRoute;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getRouteId,
+  optimizeRoute,
+  walk
+});

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

@@ -0,0 +1,371 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var templates_exports = {};
+__export(templates_exports, {
+  fileSystemRoutes: () => fileSystemRoutes,
+  routesForServer: () => routesForServer,
+  ssrLoaderCombinedModule: () => ssrLoaderCombinedModule
+});
+module.exports = __toCommonJS(templates_exports);
+var import_path = __toESM(require("path"));
+var import_utils = require("@modern-js/utils");
+var import_constants = require("@modern-js/utils/universal/constants");
+var import_constants2 = require("../constants");
+var import_utils2 = require("./utils");
+const routesForServer = ({ routes }) => {
+  const loaders = [];
+  const actions = [];
+  const loadersMap = {};
+  const traverseRouteTree = (route) => {
+    let children;
+    if ("children" in route && route.children) {
+      var _route_children;
+      children = route === null || route === void 0 ? void 0 : (_route_children = route.children) === null || _route_children === void 0 ? void 0 : _route_children.map(traverseRouteTree);
+    }
+    let loader;
+    let action;
+    if (route.type === "nested") {
+      if (route.loader || route.data) {
+        loaders.push(route.loader);
+        const loaderId = loaders.length - 1;
+        loader = `loader_${loaderId}`;
+        const inline = Boolean(route.data);
+        loadersMap[loader] = {
+          loaderId,
+          routeId: route.id,
+          filePath: route.data || route.loader,
+          clientData: Boolean(route.clientData),
+          route,
+          inline
+        };
+        if (route.action) {
+          actions.push(route.action);
+          action = `action_${loaders.length - 1}`;
+        }
+      }
+    }
+    const finalRoute = {
+      ...route,
+      loader,
+      action,
+      children
+    };
+    return finalRoute;
+  };
+  let routesCode = `
+  export const routes = [
+  `;
+  for (const route of routes) {
+    if ("type" in route) {
+      const keywords = [
+        "loader",
+        "action"
+      ];
+      const regs = keywords.map(createMatchReg);
+      const newRoute = traverseRouteTree(route);
+      const routeStr = JSON.stringify(newRoute, null, 2);
+      routesCode += regs.reduce((acc, reg) => acc.replace(reg, "$1$2"), routeStr).replace(/\\"/g, '"');
+    } else {
+      routesCode += `${JSON.stringify(route, null, 2)}`;
+    }
+  }
+  routesCode += `
+];`;
+  let importLoadersCode = "";
+  for (const [key, loaderInfo] of Object.entries(loadersMap)) {
+    if (loaderInfo.inline) {
+      const { route } = loaderInfo;
+      if (route.action) {
+        importLoadersCode += `import { loader as ${key}, action as action_${loaderInfo.loaderId} } from "${(0, import_utils.slash)(loaderInfo.filePath)}";
+`;
+      } else {
+        importLoadersCode += `import { loader as ${key} } from "${(0, import_utils.slash)(loaderInfo.filePath)}";
+`;
+      }
+    } else {
+      importLoadersCode += `import ${key} from "${(0, import_utils.slash)(loaderInfo.filePath)}";
+`;
+    }
+  }
+  return `
+    ${importLoadersCode}
+    ${routesCode}
+  `;
+};
+const createMatchReg = (keyword) => new RegExp(`("${keyword}":\\s)"([^
+]+)"`, "g");
+const fileSystemRoutes = async ({ routes, ssrMode, nestedRoutesEntry, entryName, internalDirectory, splitRouteChunks = true }) => {
+  const components = [];
+  const loadings = [];
+  const errors = [];
+  const loaders = [];
+  const loadersMap = {};
+  const configs = [];
+  const configsMap = {};
+  const loadersMapFile = import_path.default.join(internalDirectory, entryName, import_constants2.TEMP_LOADERS_DIR, "map.json");
+  const importLazyCode = `
+    import { lazy } from "react";
+    import loadable, { lazy as loadableLazy } from "@modern-js/runtime/loadable"
+  `;
+  let rootLayoutCode = ``;
+  const getDataLoaderPath = ({ loaderId, clientData, action, inline, routeId }) => {
+    if (!ssrMode) {
+      return "";
+    }
+    const clientDataStr = clientData ? `&clientData=${clientData}` : "";
+    if (nestedRoutesEntry) {
+      return `?loaderId=${loaderId}${clientDataStr}&action=${action ? (0, import_utils.slash)(action) : action}&inline=${inline}&routeId=${routeId}`;
+    }
+    return "";
+  };
+  const traverseRouteTree = (route) => {
+    let children;
+    if ("children" in route && route.children) {
+      var _route_children;
+      children = route === null || route === void 0 ? void 0 : (_route_children = route.children) === null || _route_children === void 0 ? void 0 : _route_children.map(traverseRouteTree);
+    }
+    let loading;
+    let error;
+    let loader;
+    let action;
+    let config;
+    let component = "";
+    let lazyImport = null;
+    if (route.type === "nested") {
+      if (route.loading) {
+        loadings.push(route.loading);
+        loading = `loading_${loadings.length - 1}`;
+      }
+      if (route.error) {
+        errors.push(route.error);
+        error = `error_${errors.length - 1}`;
+      }
+      if (route.loader || route.data) {
+        loaders.push(route.loader);
+        const loaderId = loaders.length - 1;
+        loader = `loader_${loaderId}`;
+        const inline = Boolean(route.data);
+        loadersMap[loader] = {
+          loaderId,
+          routeId: route.id,
+          filePath: route.data || route.loader,
+          clientData: Boolean(route.clientData),
+          route,
+          inline
+        };
+        loader = `loader_${loaderId}`;
+        if (route.action) {
+          action = `action_${loaderId}`;
+        }
+      }
+      if (typeof route.config === "string") {
+        configs.push(route.config);
+        const configId = configs.length - 1;
+        config = `config_${configId}`;
+        configsMap[config] = route.config;
+      }
+      if (route._component) {
+        if (splitRouteChunks) {
+          if (route.isRoot) {
+            lazyImport = `() => import('${route._component}').then(routeModule => handleRouteModule(routeModule, "${route.id}")).catch(handleRouteModuleError) `;
+            rootLayoutCode = `import RootLayout from '${route._component}'`;
+            component = `RootLayout`;
+          } else if (ssrMode === "string") {
+            lazyImport = `() => import(/* webpackChunkName: "${route.id}" */  '${route._component}').then(routeModule => handleRouteModule(routeModule, "${route.id}")).catch(handleRouteModuleError) `;
+            component = `loadable(${lazyImport})`;
+          } else {
+            lazyImport = `() => import(/* webpackChunkName: "${route.id}" */  '${route._component}').then(routeModule => handleRouteModule(routeModule, "${route.id}")).catch(handleRouteModuleError) `;
+            component = `lazy(${lazyImport})`;
+          }
+        } else if (ssrMode === "string") {
+          components.push(route._component);
+          component = `component_${components.length - 1}`;
+        } else {
+          lazyImport = `() => import(/* webpackMode: "eager" */  '${route._component}').then(routeModule => handleRouteModule(routeModule, "${route.id}")).catch(handleRouteModuleError) `;
+          component = `lazy(${lazyImport})`;
+        }
+      }
+    } else if (route._component) {
+      if (splitRouteChunks) {
+        lazyImport = `() => import('${route._component}')`;
+        component = `loadable(${lazyImport})`;
+      } else {
+        components.push(route._component);
+        component = `component_${components.length - 1}`;
+      }
+    }
+    const finalRoute = {
+      ...route,
+      lazyImport,
+      loading,
+      loader,
+      action,
+      config,
+      error,
+      children
+    };
+    if (route._component) {
+      finalRoute.component = component;
+    }
+    if (route.type === "nested" && route._component && (route.loader || route.data)) {
+      finalRoute.shouldRevalidate = `createShouldRevalidate("${route.id}")`;
+    }
+    return finalRoute;
+  };
+  let routeComponentsCode = `
+    export const routes = [
+  `;
+  for (const route of routes) {
+    if ("type" in route) {
+      const newRoute = traverseRouteTree(route);
+      const routeStr = JSON.stringify(newRoute, null, 2);
+      const keywords = [
+        "component",
+        "lazyImport",
+        "shouldRevalidate",
+        "loader",
+        "action",
+        "loading",
+        "error",
+        "config"
+      ];
+      const regs = keywords.map(createMatchReg);
+      const newRouteStr = regs.reduce((acc, reg) => acc.replace(reg, "$1$2"), routeStr).replace(/"(RootLayout)"/g, "$1").replace(/\\"/g, '"');
+      routeComponentsCode += `${newRouteStr},`;
+    } else {
+      const component = `loadable(() => import('${route._component}'))`;
+      const finalRoute = {
+        ...route,
+        component
+      };
+      const keywords = [
+        "component",
+        "lazyImport"
+      ];
+      const routeStr = JSON.stringify(finalRoute, null, 2);
+      const regs = keywords.map(createMatchReg);
+      const newRouteStr = regs.reduce((acc, reg) => acc.replace(reg, "$1$2"), routeStr).replace(/\\"/g, '"');
+      routeComponentsCode += `${newRouteStr},`;
+    }
+  }
+  routeComponentsCode += `
+];`;
+  const importLoadingCode = loadings.map((loading, index) => {
+    return `import loading_${index} from '${loading}';
+`;
+  }).join("");
+  const importComponentsCode = components.map((component, index) => {
+    return `import component_${index} from '${component}';
+`;
+  }).join("");
+  const importErrorComponentsCode = errors.map((error, index) => {
+    return `import error_${index} from '${error}';
+`;
+  }).join("");
+  let importLoadersCode = "";
+  for (const [key, loaderInfo] of Object.entries(loadersMap)) {
+    if (loaderInfo.inline) {
+      const { route } = loaderInfo;
+      if (route.action) {
+        importLoadersCode += `import { loader as ${key}, action as action_${loaderInfo.loaderId} } from "${(0, import_utils.slash)(loaderInfo.filePath)}${getDataLoaderPath({
+          loaderId: key,
+          clientData: loaderInfo.clientData,
+          action: route.action,
+          inline: loaderInfo.inline,
+          routeId: loaderInfo.routeId
+        })}";
+`;
+      } else {
+        importLoadersCode += `import { loader as ${key} } from "${(0, import_utils.slash)(loaderInfo.filePath)}${getDataLoaderPath({
+          loaderId: key,
+          clientData: loaderInfo.clientData,
+          action: false,
+          inline: loaderInfo.inline,
+          routeId: route.id
+        })}";
+`;
+      }
+    } else {
+      importLoadersCode += `import ${key} from "${(0, import_utils.slash)(loaderInfo.filePath)}${getDataLoaderPath({
+        loaderId: key,
+        clientData: loaderInfo.clientData,
+        action: false,
+        inline: loaderInfo.inline,
+        routeId: loaderInfo.routeId
+      })}";
+`;
+    }
+  }
+  let importConfigsCode = "";
+  for (const [key, configPath] of Object.entries(configsMap)) {
+    importConfigsCode += `import * as ${key} from "${(0, import_utils.slash)(configPath)}";
+`;
+  }
+  await import_utils.fs.ensureFile(loadersMapFile);
+  await import_utils.fs.writeJSON(loadersMapFile, loadersMap);
+  const importRuntimeRouterCode = `
+    import { createShouldRevalidate, handleRouteModule,  handleRouteModuleError} from '@modern-js/runtime/router';
+  `;
+  const routeModulesCode = `
+    if(typeof document !== 'undefined'){
+      window.${import_constants.ROUTE_MODULES} = {}
+    }
+  `;
+  return `
+    ${importLazyCode}
+    ${importComponentsCode}
+    ${importRuntimeRouterCode}
+    ${rootLayoutCode}
+    ${importLoadingCode}
+    ${importErrorComponentsCode}
+    ${importLoadersCode}
+    ${importConfigsCode}
+    ${routeModulesCode}
+    ${routeComponentsCode}
+  `;
+};
+function ssrLoaderCombinedModule(entrypoints, entrypoint, config, appContext) {
+  const { entryName, isMainEntry } = entrypoint;
+  const { packageName, internalDirectory } = appContext;
+  const ssr = (0, import_utils.getEntryOptions)(entryName, isMainEntry, config.server.ssr, config.server.ssrByEntries, packageName);
+  const ssg = (0, import_utils.isSSGEntry)(config, entryName, entrypoints);
+  if (entrypoint.nestedRoutesEntry && (ssr || ssg)) {
+    const serverLoaderRuntime = require.resolve("@modern-js/plugin-data-loader/runtime");
+    const serverLoadersFile = (0, import_utils2.getServerLoadersFile)(internalDirectory, entryName);
+    const combinedModule = `export * from "${(0, import_utils.slash)(serverLoaderRuntime)}"; export * from "${(0, import_utils.slash)(serverLoadersFile)}"`;
+    return combinedModule;
+  }
+  return null;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  fileSystemRoutes,
+  routesForServer,
+  ssrLoaderCombinedModule
+});