@modern-js/runtime 2.69.5 → 3.0.0-alpha.0

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

@@ -1,367 +1,311 @@
 "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,
-  runtimeGlobalContext: () => runtimeGlobalContext,
-  ssrLoaderCombinedModule: () => ssrLoaderCombinedModule
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    ssrLoaderCombinedModule: ()=>ssrLoaderCombinedModule,
+    runtimeGlobalContext: ()=>runtimeGlobalContext,
+    routesForServer: ()=>routesForServer,
+    fileSystemRoutes: ()=>fileSystemRoutes
 });
-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 = ({ routesForServerLoaderMatches }) => {
-  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 external_path_namespaceObject = require("path");
+var external_path_default = /*#__PURE__*/ __webpack_require__.n(external_path_namespaceObject);
+const utils_namespaceObject = require("@modern-js/utils");
+const constants_namespaceObject = require("@modern-js/utils/universal/constants");
+const external_constants_js_namespaceObject = require("../constants.js");
+const external_utils_js_namespaceObject = require("./utils.js");
+const routesForServer = ({ routesForServerLoaderMatches })=>{
+    const loaders = [];
+    const actions = [];
+    const loadersMap = {};
+    const traverseRouteTree = (route)=>{
+        let children;
+        if ('children' in route && route.children) children = route?.children?.map(traverseRouteTree);
+        let loader;
+        let action;
+        if ('nested' === route.type) {
+            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
+        const finalRoute = {
+            ...route,
+            loader,
+            action,
+            children
+        };
+        return finalRoute;
     };
-    return finalRoute;
-  };
-  let routesCode = `
+    let routesCode = `
   export const routes = [
   `;
-  for (const route of routesForServerLoaderMatches) {
-    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)}`;
+    for(let i = 0; i < routesForServerLoaderMatches.length; i++){
+        const route = routesForServerLoaderMatches[i];
+        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)}`;
+        if (i < routesForServerLoaderMatches.length - 1) routesCode += ',';
     }
-  }
-  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 `
+    routesCode += `\n];`;
+    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, utils_namespaceObject.slash)(loaderInfo.filePath)}";\n`;
+        else importLoadersCode += `import { loader as ${key} } from "${(0, utils_namespaceObject.slash)(loaderInfo.filePath)}";\n`;
+    } else importLoadersCode += `import ${key} from "${(0, utils_namespaceObject.slash)(loaderInfo.filePath)}";\n`;
+    return `
     ${importLoadersCode}
     ${routesCode}
   `;
 };
-const createMatchReg = (keyword) => new RegExp(`("${keyword}":\\s)"([^
-]+)"`, "g");
-const fileSystemRoutes = async ({ metaName, routes, ssrMode, nestedRoutesEntry, entryName, internalDirectory, splitRouteChunks = true, isRscClient = false }) => {
-  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 = `
+const createMatchReg = (keyword)=>new RegExp(`("${keyword}":\\s)"([^\n]+)"`, 'g');
+const fileSystemRoutes = async ({ metaName, routes, ssrMode, nestedRoutesEntry, entryName, internalDirectory, splitRouteChunks = true, isRscClient = false })=>{
+    const components = [];
+    const loadings = [];
+    const errors = [];
+    const loaders = [];
+    const loadersMap = {};
+    const configs = [];
+    const configsMap = {};
+    const loadersMapFile = external_path_default().join(internalDirectory, entryName, external_constants_js_namespaceObject.TEMP_LOADERS_DIR, 'map.json');
+    const importLazyCode = `
     import { lazy } from "react";
     import loadable, { lazy as loadableLazy } from "@${metaName}/runtime/loadable"
   `;
-  let rootLayoutCode = ``;
-  const getDataLoaderPath = ({ loaderId, clientData, action, inline, routeId, inValidSSRRoute }) => {
-    if (!ssrMode) {
-      return "";
-    }
-    const clientDataStr = clientData ? `&clientData=${clientData}` : "";
-    const retain = inValidSSRRoute !== null && inValidSSRRoute !== void 0 ? inValidSSRRoute : false;
-    if (nestedRoutesEntry) {
-      return `?loaderId=${loaderId}${clientDataStr}&action=${action ? (0, import_utils.slash)(action) : action}&inline=${inline}&routeId=${routeId}&retain=${retain}`;
-    }
-    return "";
-  };
-  const createLazyImport = ({ componentPath, routeId, webpackChunkName, eager }) => {
-    const importOptions = webpackChunkName ? `/* webpackChunkName: "${routeId}" */  ` : eager ? `/* webpackMode: "eager" */  ` : "";
-    return `() => import(${importOptions}'${componentPath}').then(routeModule => handleRouteModule(routeModule, "${routeId}")).catch(handleRouteModuleError)`;
-  };
-  const traverseRouteTree = (route, isRscClient2) => {
-    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((child) => traverseRouteTree(child, isRscClient2));
-    }
-    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,
-          inValidSSRRoute: route.inValidSSRRoute,
-          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 (route.isRoot) {
-          lazyImport = createLazyImport({
-            componentPath: route._component,
-            routeId: route.id
-          });
-          rootLayoutCode = `import RootLayout from '${route._component}'`;
-          component = "RootLayout";
-        } else if (splitRouteChunks) {
-          lazyImport = createLazyImport({
-            componentPath: route._component,
-            routeId: route.id,
-            webpackChunkName: true
-          });
-          component = ssrMode === "string" ? `loadable(${lazyImport})` : `lazy(${lazyImport})`;
+    let rootLayoutCode = "";
+    const getDataLoaderPath = ({ loaderId, clientData, action, inline, routeId, inValidSSRRoute })=>{
+        if (!ssrMode) return '';
+        const clientDataStr = clientData ? `&clientData=${clientData}` : '';
+        const retain = inValidSSRRoute ?? false;
+        if (nestedRoutesEntry) return `?loaderId=${loaderId}${clientDataStr}&action=${action ? (0, utils_namespaceObject.slash)(action) : action}&inline=${inline}&routeId=${routeId}&retain=${retain}`;
+        return '';
+    };
+    const createLazyImport = ({ componentPath, routeId, webpackChunkName, eager })=>{
+        const importOptions = webpackChunkName ? `/* webpackChunkName: "${routeId}" */  ` : eager ? '/* webpackMode: "eager" */  ' : '';
+        return `() => import(${importOptions}'${componentPath}').then(routeModule => handleRouteModule(routeModule, "${routeId}")).catch(handleRouteModuleError)`;
+    };
+    const traverseRouteTree = (route, isRscClient)=>{
+        let children;
+        if ('children' in route && route.children) children = route?.children?.map((child)=>traverseRouteTree(child, isRscClient));
+        let loading;
+        let error;
+        let loader;
+        let action;
+        let config;
+        let component = '';
+        let lazyImport = null;
+        if ('nested' === route.type) {
+            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,
+                    inValidSSRRoute: route.inValidSSRRoute,
+                    filePath: route.data || route.loader,
+                    clientData: Boolean(route.clientData),
+                    route,
+                    inline
+                };
+                loader = `loader_${loaderId}`;
+                if (route.action) action = `action_${loaderId}`;
+            }
+            if ('string' == typeof route.config) {
+                configs.push(route.config);
+                const configId = configs.length - 1;
+                config = `config_${configId}`;
+                configsMap[config] = route.config;
+            }
+            if (route._component) if (route.isRoot) {
+                lazyImport = createLazyImport({
+                    componentPath: route._component,
+                    routeId: route.id
+                });
+                rootLayoutCode = `import RootLayout from '${route._component}'`;
+                component = 'RootLayout';
+            } else if (splitRouteChunks) {
+                lazyImport = createLazyImport({
+                    componentPath: route._component,
+                    routeId: route.id,
+                    webpackChunkName: true
+                });
+                component = 'string' === ssrMode ? `loadable(${lazyImport})` : `lazy(${lazyImport})`;
+            } else if ('string' === ssrMode) {
+                components.push(route._component);
+                component = `component_${components.length - 1}`;
+            } else {
+                lazyImport = createLazyImport({
+                    componentPath: route._component,
+                    routeId: route.id,
+                    eager: true
+                });
+                component = `lazy(${lazyImport})`;
+            }
+        } else if (route._component) if (splitRouteChunks) {
+            lazyImport = `() => import('${route._component}')`;
+            component = `loadable(${lazyImport})`;
         } else {
-          if (ssrMode === "string") {
             components.push(route._component);
             component = `component_${components.length - 1}`;
-          } else {
-            lazyImport = createLazyImport({
-              componentPath: route._component,
-              routeId: route.id,
-              eager: true
-            });
-            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,
-      loading,
-      loader,
-      action,
-      config,
-      error,
-      children
+        const finalRoute = {
+            ...route,
+            loading,
+            loader,
+            action,
+            config,
+            error,
+            children
+        };
+        if (!isRscClient) finalRoute.lazyImport = lazyImport;
+        if (route._component && !isRscClient) finalRoute.component = component;
+        if ('nested' === route.type && route._component && (route.loader || route.data)) finalRoute.shouldRevalidate = `createShouldRevalidate("${route.id}")`;
+        return finalRoute;
     };
-    if (!isRscClient2) {
-      finalRoute.lazyImport = lazyImport;
-    }
-    if (route._component && !isRscClient2) {
-      finalRoute.component = component;
-    }
-    if (route.type === "nested" && route._component && (route.loader || route.data)) {
-      finalRoute.shouldRevalidate = `createShouldRevalidate("${route.id}")`;
-    }
-    return finalRoute;
-  };
-  let routeComponentsCode = `
+    let routeComponentsCode = `
     export const routes = [
   `;
-  for (const route of routes) {
-    if ("type" in route) {
-      const newRoute = traverseRouteTree(route, isRscClient);
-      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},`;
+    for (const route of routes)if ('type' in route) {
+        const newRoute = traverseRouteTree(route, isRscClient);
+        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},`;
+        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,
-          inValidSSRRoute: loaderInfo.inValidSSRRoute
-        })}";
-`;
-      } 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,
-          inValidSSRRoute: loaderInfo.inValidSSRRoute
-        })}";
-`;
-      }
-    } else {
-      importLoadersCode += `import ${key} from "${(0, import_utils.slash)(loaderInfo.filePath)}${getDataLoaderPath({
+    routeComponentsCode += `\n];`;
+    const importLoadingCode = loadings.map((loading, index)=>`import loading_${index} from '${loading}';\n`).join('');
+    const importComponentsCode = components.map((component, index)=>`import component_${index} from '${component}';\n`).join('');
+    const importErrorComponentsCode = errors.map((error, index)=>`import error_${index} from '${error}';\n`).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, utils_namespaceObject.slash)(loaderInfo.filePath)}${getDataLoaderPath({
+            loaderId: key,
+            clientData: loaderInfo.clientData,
+            action: route.action,
+            inline: loaderInfo.inline,
+            routeId: loaderInfo.routeId,
+            inValidSSRRoute: loaderInfo.inValidSSRRoute
+        })}";\n`;
+        else importLoadersCode += `import { loader as ${key} } from "${(0, utils_namespaceObject.slash)(loaderInfo.filePath)}${getDataLoaderPath({
+            loaderId: key,
+            clientData: loaderInfo.clientData,
+            action: false,
+            inline: loaderInfo.inline,
+            routeId: route.id,
+            inValidSSRRoute: loaderInfo.inValidSSRRoute
+        })}";\n`;
+    } else importLoadersCode += `import ${key} from "${(0, utils_namespaceObject.slash)(loaderInfo.filePath)}${getDataLoaderPath({
         loaderId: key,
         clientData: loaderInfo.clientData,
         action: false,
         inline: loaderInfo.inline,
         routeId: loaderInfo.routeId,
         inValidSSRRoute: loaderInfo.inValidSSRRoute
-      })}";
-`;
-    }
-  }
-  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 '@${metaName}/runtime/router';
+    })}";\n`;
+    let importConfigsCode = '';
+    for (const [key, configPath] of Object.entries(configsMap))importConfigsCode += `import * as ${key} from "${(0, utils_namespaceObject.slash)(configPath)}";\n`;
+    await utils_namespaceObject.fs.ensureFile(loadersMapFile);
+    await utils_namespaceObject.fs.writeJSON(loadersMapFile, loadersMap);
+    const importRuntimeRouterCode = `
+    import { createShouldRevalidate, handleRouteModule,  handleRouteModuleError} from '@${metaName}/runtime/routerHelper';
   `;
-  const routeModulesCode = `
+    const routeModulesCode = `
     if(typeof document !== 'undefined'){
-      window.${import_constants.ROUTE_MODULES} = {}
+      window.${constants_namespaceObject.ROUTE_MODULES} = {}
     }
   `;
-  return `
+    return `
     ${importLazyCode}
-    ${!isRscClient ? importComponentsCode : ""}
+    ${!isRscClient ? importComponentsCode : ''}
     ${importRuntimeRouterCode}
-    ${!isRscClient ? rootLayoutCode : ""}
+    ${!isRscClient ? rootLayoutCode : ''}
     ${importLoadingCode}
     ${importErrorComponentsCode}
     ${importLoadersCode}
@@ -371,22 +315,20 @@ const fileSystemRoutes = async ({ metaName, routes, ssrMode, nestedRoutesEntry,
   `;
 };
 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)}"`;
-    if (!config.source.enableAsyncEntry) {
-      return combinedModule;
-    }
-    return `
+    const { entryName, isMainEntry } = entrypoint;
+    const { packageName, internalDirectory } = appContext;
+    const ssr = (0, utils_namespaceObject.getEntryOptions)(entryName, isMainEntry, config.server.ssr, config.server.ssrByEntries, packageName);
+    const ssg = (0, utils_namespaceObject.isSSGEntry)(config, entryName, entrypoints);
+    if (entrypoint.nestedRoutesEntry && (ssr || ssg)) {
+        const serverLoaderRuntime = require.resolve('@modern-js/plugin-data-loader/runtime');
+        const serverLoadersFile = (0, external_utils_js_namespaceObject.getServerLoadersFile)(internalDirectory, entryName);
+        const combinedModule = `export * from "${(0, utils_namespaceObject.slash)(serverLoaderRuntime)}"; export * from "${(0, utils_namespaceObject.slash)(serverLoadersFile)}"`;
+        if (!config.source.enableAsyncEntry) return combinedModule;
+        return `
     async function loadModules() {
       const [moduleA, moduleB] = await Promise.all([
-        import("${(0, import_utils.slash)(serverLoaderRuntime)}"),
-        import("${(0, import_utils.slash)(serverLoadersFile)}")
+        import("${(0, utils_namespaceObject.slash)(serverLoaderRuntime)}"),
+        import("${(0, utils_namespaceObject.slash)(serverLoadersFile)}")
       ]);
 
       return {
@@ -397,93 +339,80 @@ function ssrLoaderCombinedModule(entrypoints, entrypoint, config, appContext) {
 
     export { loadModules };
     `;
-  }
-  return null;
-}
-const runtimeGlobalContext = async ({ entryName, metaName, srcDirectory, nestedRoutesEntry, internalSrcAlias, globalApp, rscType = false }) => {
-  const imports = [
-    `import { setGlobalContext } from '@${metaName}/runtime/context';`
-  ];
-  if (nestedRoutesEntry) {
-    const rootLayoutPath = import_path.default.join(nestedRoutesEntry, "layout");
-    const rootLayoutFile = (0, import_utils.findExists)([
-      ".js",
-      ".ts",
-      ".jsx",
-      ".tsx"
-    ].map((ext) => `${rootLayoutPath}${ext}`));
-    if (rootLayoutFile) {
-      const rootLayoutBuffer = await import_utils.fs.readFile(rootLayoutFile);
-      const rootLayout = rootLayoutBuffer.toString();
-      const [, moduleExports] = await (0, import_utils2.parseModule)({
-        source: rootLayout.toString(),
-        filename: rootLayoutFile
-      });
-      const hasAppConfig = moduleExports.some((e) => e.n === import_constants2.APP_CONFIG_NAME);
-      const hasAppInit = moduleExports.some((e) => e.n === import_constants2.APP_INIT_EXPORTED);
-      const layoutPath = (0, import_utils.formatImportPath)((0, import_utils2.getPathWithoutExt)((0, import_utils2.replaceWithAlias)(srcDirectory, rootLayoutFile, internalSrcAlias)));
-      if (hasAppConfig) {
-        imports.push(`import { config as appConfig } from '${layoutPath}';`);
-      } else {
-        imports.push(`let appConfig;`);
-      }
-      if (hasAppInit) {
-        imports.push(`import { init as appInit } from '${layoutPath}';`);
-      } else {
-        imports.push(`let appInit;`);
-      }
-    } else {
-      imports.push(`let appConfig;`);
-      imports.push(`let appInit;`);
     }
-  } else {
-    imports.push(`let appConfig;`);
-    imports.push(`let appInit;`);
-  }
-  if (globalApp) {
-    imports.push(`import layoutApp from '${(0, import_utils.formatImportPath)(globalApp.replace(srcDirectory, internalSrcAlias))}';`);
-  } else {
-    imports.push(`let layoutApp;`);
-  }
-  const isClient = rscType === "client";
-  const enableRsc = Boolean(rscType);
-  if (isClient) {
-    return `${imports.join("\n")}
+    return null;
+}
+const runtimeGlobalContext = async ({ entryName, metaName, srcDirectory, nestedRoutesEntry, internalSrcAlias, globalApp, rscType = false, basename })=>{
+    const imports = [
+        `import { setGlobalContext } from '@${metaName}/runtime/context';`
+    ];
+    if (nestedRoutesEntry) {
+        const rootLayoutPath = external_path_default().join(nestedRoutesEntry, 'layout');
+        const rootLayoutFile = (0, utils_namespaceObject.findExists)([
+            '.js',
+            '.ts',
+            '.jsx',
+            '.tsx'
+        ].map((ext)=>`${rootLayoutPath}${ext}`));
+        if (rootLayoutFile) {
+            const rootLayoutBuffer = await utils_namespaceObject.fs.readFile(rootLayoutFile);
+            const rootLayout = rootLayoutBuffer.toString();
+            const [, moduleExports] = await (0, external_utils_js_namespaceObject.parseModule)({
+                source: rootLayout.toString(),
+                filename: rootLayoutFile
+            });
+            const hasAppInit = moduleExports.some((e)=>e.n === external_constants_js_namespaceObject.APP_INIT_EXPORTED);
+            const layoutPath = (0, utils_namespaceObject.formatImportPath)((0, external_utils_js_namespaceObject.getPathWithoutExt)((0, external_utils_js_namespaceObject.replaceWithAlias)(srcDirectory, rootLayoutFile, internalSrcAlias)));
+            if (hasAppInit) imports.push(`import { init as appInit } from '${layoutPath}';`);
+            else imports.push("let appInit;");
+        } else imports.push("let appInit;");
+    } else imports.push("let appInit;");
+    if (globalApp) imports.push(`import layoutApp from '${(0, utils_namespaceObject.formatImportPath)(globalApp.replace(srcDirectory, internalSrcAlias))}';`);
+    else imports.push("let layoutApp;");
+    const isClient = 'client' === rscType;
+    const enableRsc = Boolean(rscType);
+    if (isClient) return `${imports.join('\n')}
 
     import { routes } from './routes';
 
     const entryName = '${entryName}';
+    const basename = '${basename || '/'}';
       setGlobalContext({
         entryName,
         layoutApp,
         routes,
         appInit,
-        appConfig,
+        basename,
         isRscClient: true,
         enableRsc: true,
       });
     `;
-  } else {
-    return `${imports.join("\n")}
+    return `${imports.join('\n')}
 
     import { routes } from './routes';
 
     const entryName = '${entryName}';
+    const basename = '${basename || '/'}';
       setGlobalContext({
         entryName,
         layoutApp,
         routes,
         appInit,
-        appConfig,
+        basename,
         enableRsc: ${enableRsc},
       });
     `;
-  }
 };
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  fileSystemRoutes,
-  routesForServer,
-  runtimeGlobalContext,
-  ssrLoaderCombinedModule
+exports.fileSystemRoutes = __webpack_exports__.fileSystemRoutes;
+exports.routesForServer = __webpack_exports__.routesForServer;
+exports.runtimeGlobalContext = __webpack_exports__.runtimeGlobalContext;
+exports.ssrLoaderCombinedModule = __webpack_exports__.ssrLoaderCombinedModule;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "fileSystemRoutes",
+    "routesForServer",
+    "runtimeGlobalContext",
+    "ssrLoaderCombinedModule"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
 });