@modern-js/app-tools 2.35.1 → 2.35.2-alpha.0

package/dist/cjs/analyze/nestedRoutes.js

@@ -1,40 +1,52 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-function _export(target, all) {
+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)
-    Object.defineProperty(target, name, {
-      enumerable: true,
-      get: all[name]
-    });
-}
-_export(exports, {
-  getRouteId: function() {
-    return getRouteId;
-  },
-  optimizeRoute: function() {
-    return optimizeRoute;
-  },
-  walk: function() {
-    return walk;
+    __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
 });
-const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
-const _path = /* @__PURE__ */ _interop_require_wildcard._(require("path"));
-const _utils = require("@modern-js/utils");
-const _constants = require("./constants");
-const _utils1 = require("./utils");
-const conventionNames = Object.values(_constants.NESTED_ROUTE);
+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 getPathWithoutExt = (filename) => {
-  const extname = _path.extname(filename);
+  const extname = path.extname(filename);
   return filename.slice(0, -extname.length);
 };
 const getRouteId = (componentPath, routesDir, entryName, isMainEntry) => {
-  const relativePath = (0, _utils.normalizeToPosixPath)(_path.relative(routesDir, componentPath));
+  const relativePath = (0, import_utils.normalizeToPosixPath)(path.relative(routesDir, componentPath));
   const pathWithoutExt = getPathWithoutExt(relativePath);
   let id = ``;
   if (isMainEntry) {
@@ -94,15 +106,15 @@ const optimizeRoute = (routeTree) => {
 };
 const walk = async (dirname, rootDir, alias, entryName, isMainEntry, oldVersion) => {
   var _finalRoute_children;
-  if (!await _utils.fs.pathExists(dirname)) {
+  if (!await import_utils.fs.pathExists(dirname)) {
     return null;
   }
-  const isDirectory = (await _utils.fs.stat(dirname)).isDirectory();
+  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 relativeDir = path.relative(rootDir, dirname);
+  const pathSegments = relativeDir.split(path.sep);
   const lastSegment = pathSegments[pathSegments.length - 1];
   const isRoot = lastSegment === "";
   const isPathlessLayout = lastSegment.startsWith("__");
@@ -119,18 +131,22 @@ const walk = async (dirname, rootDir, alias, entryName, isMainEntry, oldVersion)
   };
   let pageLoaderFile = "";
   let pageRoute = null;
+  let pageConfigFile = "";
+  let pageClientData = "";
+  let pageData = "";
+  let pageAction = "";
   let splatLoaderFile = "";
-  let splatClientData = "";
-  let splatData = "";
   let splatRoute = null;
-  let pageConfigFile = "";
   let splatConfigFile = "";
-  const items = await _utils.fs.readdir(dirname);
+  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 extname = _path.extname(item);
+    const itemPath = path.join(dirname, item);
+    const extname = path.extname(item);
     const itemWithoutExt = item.slice(0, -extname.length);
-    const isDirectory2 = (await _utils.fs.stat(itemPath)).isDirectory();
+    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)) {
@@ -138,44 +154,50 @@ const walk = async (dirname, rootDir, alias, entryName, isMainEntry, oldVersion)
         (_route_children = route.children) === null || _route_children === void 0 ? void 0 : _route_children.push(childRoute);
       }
     }
-    if (extname && (!_constants.JS_EXTENSIONS.includes(extname) || !conventionNames.includes(itemWithoutExt))) {
+    if (extname && (!import_constants.JS_EXTENSIONS.includes(extname) || !conventionNames.includes(itemWithoutExt))) {
       continue;
     }
-    if (itemWithoutExt === _constants.NESTED_ROUTE.LAYOUT_LOADER_FILE) {
+    if (itemWithoutExt === import_constants.NESTED_ROUTE.LAYOUT_LOADER_FILE) {
       if (!route.loader) {
         route.loader = itemPath;
       }
     }
-    if (itemWithoutExt === _constants.NESTED_ROUTE.LAYOUT_CLIENT_LOADER) {
+    if (itemWithoutExt === import_constants.NESTED_ROUTE.LAYOUT_CLIENT_LOADER) {
       route.clientData = itemPath;
     }
-    if (itemWithoutExt === _constants.NESTED_ROUTE.LAYOUT_DATA_FILE) {
+    if (itemWithoutExt === import_constants.NESTED_ROUTE.LAYOUT_DATA_FILE) {
       route.data = itemPath;
+      if (await (0, import_utils2.hasAction)(itemPath)) {
+        route.action = itemPath;
+      }
     }
-    if (itemWithoutExt === _constants.NESTED_ROUTE.LAYOUT_CONFIG_FILE) {
+    if (itemWithoutExt === import_constants.NESTED_ROUTE.LAYOUT_CONFIG_FILE) {
       if (!route.config) {
         route.config = itemPath;
       }
     }
-    if (itemWithoutExt === _constants.NESTED_ROUTE.LAYOUT_FILE) {
-      route._component = (0, _utils1.replaceWithAlias)(alias.basename, itemPath, alias.name);
+    if (itemWithoutExt === import_constants.NESTED_ROUTE.LAYOUT_FILE) {
+      route._component = (0, import_utils2.replaceWithAlias)(alias.basename, itemPath, alias.name);
     }
-    if (itemWithoutExt === _constants.NESTED_ROUTE.PAGE_LOADER_FILE) {
+    if (itemWithoutExt === import_constants.NESTED_ROUTE.PAGE_LOADER_FILE) {
       pageLoaderFile = itemPath;
     }
-    if (itemWithoutExt === _constants.NESTED_ROUTE.PAGE_CLIENT_LOADER) {
-      route.clientData = itemPath;
+    if (itemWithoutExt === import_constants.NESTED_ROUTE.PAGE_CLIENT_LOADER) {
+      pageClientData = itemPath;
     }
-    if (itemWithoutExt === _constants.NESTED_ROUTE.PAGE_DATA_FILE) {
-      route.data = itemPath;
+    if (itemWithoutExt === import_constants.NESTED_ROUTE.PAGE_DATA_FILE) {
+      pageData = itemPath;
+      if (await (0, import_utils2.hasAction)(itemPath)) {
+        pageAction = itemPath;
+      }
     }
-    if (itemWithoutExt === _constants.NESTED_ROUTE.PAGE_CONFIG_FILE) {
+    if (itemWithoutExt === import_constants.NESTED_ROUTE.PAGE_CONFIG_FILE) {
       pageConfigFile = itemPath;
     }
-    if (itemWithoutExt === _constants.NESTED_ROUTE.PAGE_FILE) {
+    if (itemWithoutExt === import_constants.NESTED_ROUTE.PAGE_FILE) {
       var _route_children1;
       pageRoute = createIndexRoute({
-        _component: (0, _utils1.replaceWithAlias)(alias.basename, itemPath, alias.name)
+        _component: (0, import_utils2.replaceWithAlias)(alias.basename, itemPath, alias.name)
       }, rootDir, itemPath, entryName, isMainEntry);
       if (pageLoaderFile) {
         pageRoute.loader = pageLoaderFile;
@@ -183,26 +205,38 @@ const walk = async (dirname, rootDir, alias, entryName, isMainEntry, oldVersion)
       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 === _constants.NESTED_ROUTE.SPLATE_LOADER_FILE) {
+    if (itemWithoutExt === import_constants.NESTED_ROUTE.SPLATE_LOADER_FILE) {
       splatLoaderFile = itemPath;
     }
-    if (itemWithoutExt === _constants.NESTED_ROUTE.SPLATE_CLIENT_DATA) {
+    if (itemWithoutExt === import_constants.NESTED_ROUTE.SPLATE_CLIENT_DATA) {
       splatClientData = itemPath;
     }
-    if (itemWithoutExt === _constants.NESTED_ROUTE.SPLATE_CONFIG_FILE) {
+    if (itemWithoutExt === import_constants.NESTED_ROUTE.SPLATE_CONFIG_FILE) {
       if (!route.config) {
         splatConfigFile = itemPath;
       }
     }
-    if (itemWithoutExt === _constants.NESTED_ROUTE.SPLATE_DATA_FILE) {
+    if (itemWithoutExt === import_constants.NESTED_ROUTE.SPLATE_DATA_FILE) {
       splatData = itemPath;
+      if (await (0, import_utils2.hasAction)(itemPath)) {
+        splatAction = itemPath;
+      }
     }
-    if (itemWithoutExt === _constants.NESTED_ROUTE.SPLATE_FILE) {
+    if (itemWithoutExt === import_constants.NESTED_ROUTE.SPLATE_FILE) {
       var _route_children2;
       splatRoute = createRoute({
-        _component: (0, _utils1.replaceWithAlias)(alias.basename, itemPath, alias.name),
+        _component: (0, import_utils2.replaceWithAlias)(alias.basename, itemPath, alias.name),
         path: "*"
       }, rootDir, itemPath, entryName, isMainEntry);
       if (splatLoaderFile) {
@@ -217,16 +251,19 @@ const walk = async (dirname, rootDir, alias, entryName, isMainEntry, oldVersion)
       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 === _constants.NESTED_ROUTE.LOADING_FILE) {
-      route.loading = (0, _utils1.replaceWithAlias)(alias.basename, itemPath, alias.name);
+    if (itemWithoutExt === import_constants.NESTED_ROUTE.LOADING_FILE) {
+      route.loading = (0, import_utils2.replaceWithAlias)(alias.basename, itemPath, alias.name);
     }
-    if (itemWithoutExt === _constants.NESTED_ROUTE.ERROR_FILE) {
-      route.error = (0, _utils1.replaceWithAlias)(alias.basename, itemPath, alias.name);
+    if (itemWithoutExt === import_constants.NESTED_ROUTE.ERROR_FILE) {
+      route.error = (0, import_utils2.replaceWithAlias)(alias.basename, itemPath, alias.name);
     }
   }
-  let finalRoute = createRoute(route, rootDir, _path.join(dirname, `${_constants.NESTED_ROUTE.LAYOUT_FILE}.ts`), entryName, isMainEntry);
+  let finalRoute = createRoute(route, rootDir, path.join(dirname, `${import_constants.NESTED_ROUTE.LAYOUT_FILE}.ts`), entryName, isMainEntry);
   if (isPathlessLayout) {
     delete finalRoute.path;
   }
@@ -237,10 +274,10 @@ const walk = async (dirname, rootDir, alias, entryName, isMainEntry, oldVersion)
   if (childRoutes && childRoutes.length === 1 && !finalRoute._component) {
     const childRoute = childRoutes[0];
     if (childRoute.path === "*") {
-      const path = `${finalRoute.path || ""}/${childRoute.path || ""}`;
+      const path2 = `${finalRoute.path || ""}/${childRoute.path || ""}`;
       finalRoute = {
         ...childRoute,
-        path
+        path: path2
       };
     }
   }
@@ -250,3 +287,9 @@ const walk = async (dirname, rootDir, alias, entryName, isMainEntry, oldVersion)
   }
   return finalRoute;
 };
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getRouteId,
+  optimizeRoute,
+  walk
+});

package/dist/cjs/analyze/templates.js

@@ -1,39 +1,45 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-function _export(target, all) {
+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)
-    Object.defineProperty(target, name, {
-      enumerable: true,
-      get: all[name]
-    });
-}
-_export(exports, {
-  index: function() {
-    return index;
-  },
-  renderFunction: function() {
-    return renderFunction;
-  },
-  html: function() {
-    return html;
-  },
-  routesForServer: function() {
-    return routesForServer;
-  },
-  fileSystemRoutes: function() {
-    return fileSystemRoutes;
-  },
-  ssrLoaderCombinedModule: function() {
-    return ssrLoaderCombinedModule;
+    __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,
+  html: () => html,
+  index: () => index,
+  renderFunction: () => renderFunction,
+  routesForServer: () => routesForServer,
+  ssrLoaderCombinedModule: () => ssrLoaderCombinedModule
 });
-const _interop_require_default = require("@swc/helpers/_/_interop_require_default");
-const _path = /* @__PURE__ */ _interop_require_default._(require("path"));
-const _utils = require("@modern-js/utils");
-const _constants = require("./constants");
-const _utils1 = require("./utils");
+module.exports = __toCommonJS(templates_exports);
+var import_path = __toESM(require("path"));
+var import_utils = require("@modern-js/utils");
+var import_constants = require("./constants");
+var import_utils2 = require("./utils");
 const index = ({ mountId, imports, renderFunction: renderFunction2, exportStatement }) => `
 const IS_BROWSER = typeof window !== 'undefined' && window.name !== 'nodejs';
 const IS_REACT18 = process.env.IS_REACT18 === 'true';
@@ -58,7 +64,7 @@ const renderFunction = ({ plugins, customBootstrap, fileSystemRoutes: fileSystem
   return `
   const finalAppConfig = {
     ...App.config,
-    ...typeof ${_constants.APP_CONFIG_NAME} === 'function' ? ${_constants.APP_CONFIG_NAME}() : {},
+    ...typeof ${import_constants.APP_CONFIG_NAME} === 'function' ? ${import_constants.APP_CONFIG_NAME}() : {},
   }
 
   AppWrapper = createApp({
@@ -105,6 +111,8 @@ const html = (partials) => `
 `;
 const routesForServer = ({ routes }) => {
   const loaders = [];
+  const actions = [];
+  const loadersMap = {};
   const traverseRouteTree = (route) => {
     let children;
     if ("children" in route && route.children) {
@@ -112,15 +120,31 @@ const routesForServer = ({ routes }) => {
       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) {
+      if (route.loader || route.data) {
         loaders.push(route.loader);
-        loader = `loader_${loaders.length - 1}`;
+        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;
@@ -130,8 +154,14 @@ const routesForServer = ({ routes }) => {
   `;
   for (const route of routes) {
     if ("type" in route) {
+      const keywords = [
+        "loader",
+        "action"
+      ];
+      const regs = keywords.map(createMatchReg);
       const newRoute = traverseRouteTree(route);
-      routesCode += `${JSON.stringify(newRoute, null, 2).replace(/"(loader_[^"]+)"/g, "$1")},`;
+      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)}`;
     }
@@ -139,10 +169,20 @@ const routesForServer = ({ routes }) => {
   routesCode += `
 ];`;
   let importLoadersCode = "";
-  if (loaders.length > 0) {
-    importLoadersCode = loaders.map((loader, index2) => {
-      return `import loader_${index2} from "${(0, _utils.slash)(loader)}"`;
-    }).join("\n");
+  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}
@@ -158,19 +198,19 @@ const fileSystemRoutes = async ({ routes, ssrMode, nestedRoutesEntry, entryName,
   const loadersMap = {};
   const configs = [];
   const configsMap = {};
-  const loadersMapFile = _path.default.join(internalDirectory, entryName, _constants.TEMP_LOADERS_DIR, "map.json");
+  const loadersMapFile = import_path.default.join(internalDirectory, entryName, import_constants.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) => {
+  const getDataLoaderPath = ({ loaderId, clientData, action, inline, routeId }) => {
     if (!ssrMode) {
       return "";
     }
     const clientDataStr = clientData ? `&clientData=${clientData}` : "";
     if (nestedRoutesEntry) {
-      return `?mapFile=${(0, _utils.slash)(loadersMapFile)}&loaderId=${loaderId}${clientDataStr}`;
+      return `?loaderId=${loaderId}${clientDataStr}&action=${action}&inline=${inline}&routeId=${routeId}`;
     }
     return "";
   };
@@ -183,6 +223,7 @@ const fileSystemRoutes = async ({ routes, ssrMode, nestedRoutesEntry, entryName,
     let loading;
     let error;
     let loader;
+    let action;
     let config;
     let component = "";
     let lazyImport = null;
@@ -199,13 +240,19 @@ const fileSystemRoutes = async ({ routes, ssrMode, nestedRoutesEntry, entryName,
         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),
-          inline: Boolean(route.data)
+          route,
+          inline
         };
         loader = `loader_${loaderId}`;
+        if (route.action) {
+          action = `action_${loaderId}`;
+        }
       }
       if (typeof route.config === "string") {
         configs.push(route.config);
@@ -244,6 +291,7 @@ const fileSystemRoutes = async ({ routes, ssrMode, nestedRoutesEntry, entryName,
       lazyImport,
       loading,
       loader,
+      action,
       config,
       error,
       children
@@ -264,6 +312,7 @@ const fileSystemRoutes = async ({ routes, ssrMode, nestedRoutesEntry, entryName,
         "component",
         "lazyImport",
         "loader",
+        "action",
         "loading",
         "error",
         "config"
@@ -304,20 +353,44 @@ const fileSystemRoutes = async ({ routes, ssrMode, nestedRoutesEntry, entryName,
   let importLoadersCode = "";
   for (const [key, loaderInfo] of Object.entries(loadersMap)) {
     if (loaderInfo.inline) {
-      importLoadersCode += `import { loader as ${key} } from "${(0, _utils.slash)(loaderInfo.filePath)}${getDataLoaderPath(key, loaderInfo.clientData)}";
+      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, _utils.slash)(loaderInfo.filePath)}${getDataLoaderPath(key, loaderInfo.clientData)}";
+      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, _utils.slash)(configPath)}";
+    importConfigsCode += `import * as ${key} from "${(0, import_utils.slash)(configPath)}";
 `;
   }
-  await _utils.fs.ensureFile(loadersMapFile);
-  await _utils.fs.writeJSON(loadersMapFile, loadersMap);
+  await import_utils.fs.ensureFile(loadersMapFile);
+  await import_utils.fs.writeJSON(loadersMapFile, loadersMap);
   return `
     ${importLazyCode}
     ${importComponentsCode}
@@ -332,13 +405,22 @@ const fileSystemRoutes = async ({ routes, ssrMode, nestedRoutesEntry, entryName,
 function ssrLoaderCombinedModule(entrypoints, entrypoint, config, appContext) {
   const { entryName, isMainEntry } = entrypoint;
   const { packageName, internalDirectory } = appContext;
-  const ssr = (0, _utils.getEntryOptions)(entryName, isMainEntry, config.server.ssr, config.server.ssrByEntries, packageName);
-  const ssg = (0, _utils.isSSGEntry)(config, entryName, entrypoints);
+  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, _utils1.getServerLoadersFile)(internalDirectory, entryName);
-    const combinedModule = `export * from "${(0, _utils.slash)(serverLoaderRuntime)}"; export * from "${(0, _utils.slash)(serverLoadersFile)}"`;
+    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,
+  html,
+  index,
+  renderFunction,
+  routesForServer,
+  ssrLoaderCombinedModule
+});