@modern-js/runtime 2.54.6 → 2.55.0

package/dist/cjs/core/server/string/ssrData.js

@@ -0,0 +1,100 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var ssrData_exports = {};
+__export(ssrData_exports, {
+  SSRDataCollector: () => SSRDataCollector
+});
+module.exports = __toCommonJS(ssrData_exports);
+var import_class_private_field_get = require("@swc/helpers/_/_class_private_field_get");
+var import_class_private_field_init = require("@swc/helpers/_/_class_private_field_init");
+var import_class_private_field_set = require("@swc/helpers/_/_class_private_field_set");
+var import_class_private_method_get = require("@swc/helpers/_/_class_private_method_get");
+var import_class_private_method_init = require("@swc/helpers/_/_class_private_method_init");
+var import_node = require("@modern-js/runtime-utils/node");
+var import_utils = require("../utils");
+var import_constants = require("../constants");
+var _options = /* @__PURE__ */ new WeakMap(), _getSSRData = /* @__PURE__ */ new WeakSet(), _getSSRDataScripts = /* @__PURE__ */ new WeakSet();
+class SSRDataCollector {
+  effect() {
+    const { routerContext, chunkSet } = (0, import_class_private_field_get._)(this, _options);
+    const ssrData = (0, import_class_private_method_get._)(this, _getSSRData, getSSRData).call(this);
+    const routerData = routerContext ? {
+      loaderData: routerContext.loaderData,
+      errors: (0, import_utils.serializeErrors)(routerContext.errors)
+    } : void 0;
+    const ssrDataScripts = (0, import_class_private_method_get._)(this, _getSSRDataScripts, getSSRDataScripts).call(this, ssrData, routerData);
+    chunkSet.ssrScripts = ssrDataScripts;
+  }
+  constructor(options) {
+    (0, import_class_private_method_init._)(this, _getSSRData);
+    (0, import_class_private_method_init._)(this, _getSSRDataScripts);
+    (0, import_class_private_field_init._)(this, _options, {
+      writable: true,
+      value: void 0
+    });
+    (0, import_class_private_field_set._)(this, _options, options);
+  }
+}
+function getSSRData() {
+  const { prefetchData, chunkSet, ssrConfig, ssrContext } = (0, import_class_private_field_get._)(this, _options);
+  const { reporter, request } = ssrContext;
+  const headers = typeof ssrConfig === "object" && ssrConfig.unsafeHeaders ? Object.fromEntries(Object.entries(request.headers).filter(([key, _]) => {
+    var _ssrConfig_unsafeHeaders_map, _ssrConfig_unsafeHeaders;
+    return (_ssrConfig_unsafeHeaders = ssrConfig.unsafeHeaders) === null || _ssrConfig_unsafeHeaders === void 0 ? void 0 : (_ssrConfig_unsafeHeaders_map = _ssrConfig_unsafeHeaders.map((header) => header.toLowerCase())) === null || _ssrConfig_unsafeHeaders_map === void 0 ? void 0 : _ssrConfig_unsafeHeaders_map.includes(key.toLowerCase());
+  })) : void 0;
+  return {
+    data: prefetchData,
+    context: {
+      request: {
+        params: request.params,
+        query: request.query,
+        pathname: request.pathname,
+        host: request.host,
+        url: request.raw.url,
+        headers
+      },
+      reporter: {
+        sessionId: reporter === null || reporter === void 0 ? void 0 : reporter.sessionId
+      }
+    },
+    mode: "string",
+    renderLevel: chunkSet.renderLevel
+  };
+}
+function getSSRDataScripts(ssrData, routerData) {
+  const { nonce, ssrConfig } = (0, import_class_private_field_get._)(this, _options);
+  const inlineScript = typeof ssrConfig === "boolean" ? true : (ssrConfig === null || ssrConfig === void 0 ? void 0 : ssrConfig.inlineScript) !== false;
+  const useInlineScript = inlineScript !== false;
+  const serializeSSRData = (0, import_node.serializeJson)(ssrData);
+  const attrsStr = (0, import_utils.attributesToString)({
+    nonce
+  });
+  let ssrDataScripts = useInlineScript ? `<script${attrsStr}>window._SSR_DATA = ${serializeSSRData}</script>` : `<script type="application/json" id="${import_constants.SSR_DATA_JSON_ID}">${serializeSSRData}</script>`;
+  if (routerData) {
+    const serializedRouterData = (0, import_node.serializeJson)(routerData);
+    ssrDataScripts += useInlineScript ? `
+<script${attrsStr}>window._ROUTER_DATA = ${serializedRouterData}</script>` : `
+<script type="application/json" id="${import_constants.ROUTER_DATA_JSON_ID}">${serializedRouterData}</script>`;
+  }
+  return ssrDataScripts;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SSRDataCollector
+});

package/dist/cjs/{ssr/serverRender/renderToString → core/server/string}/styledComponent.js

@@ -18,27 +18,36 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var styledComponent_exports = {};
 __export(styledComponent_exports, {
-  createStyledCollector: () => createStyledCollector
+  StyledCollector: () => StyledCollector
 });
 module.exports = __toCommonJS(styledComponent_exports);
+var import_class_private_field_get = require("@swc/helpers/_/_class_private_field_get");
+var import_class_private_field_init = require("@swc/helpers/_/_class_private_field_init");
+var import_class_private_field_set = require("@swc/helpers/_/_class_private_field_set");
 var import_styled_components = require("styled-components");
+var _sheet = /* @__PURE__ */ new WeakMap(), _chunkSet = /* @__PURE__ */ new WeakMap();
 class StyledCollector {
   collect(comopnent) {
-    return this.sheet.collectStyles(comopnent);
+    return (0, import_class_private_field_get._)(this, _sheet).collectStyles(comopnent);
   }
   effect() {
-    const css = this.sheet.getStyleTags();
-    this.result.chunksMap.css += css;
+    const css = (0, import_class_private_field_get._)(this, _sheet).getStyleTags();
+    (0, import_class_private_field_get._)(this, _chunkSet).cssChunk += css;
   }
-  constructor(result) {
-    this.sheet = new import_styled_components.ServerStyleSheet();
-    this.result = result;
+  constructor(chunkSet) {
+    (0, import_class_private_field_init._)(this, _sheet, {
+      writable: true,
+      value: void 0
+    });
+    (0, import_class_private_field_init._)(this, _chunkSet, {
+      writable: true,
+      value: void 0
+    });
+    (0, import_class_private_field_set._)(this, _sheet, new import_styled_components.ServerStyleSheet());
+    (0, import_class_private_field_set._)(this, _chunkSet, chunkSet);
   }
 }
-function createStyledCollector(result) {
-  return new StyledCollector(result);
-}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  createStyledCollector
+  StyledCollector
 });

package/dist/cjs/core/server/string/types.js

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);

package/dist/cjs/core/server/tracer.js

@@ -0,0 +1,60 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var tracer_exports = {};
+__export(tracer_exports, {
+  SSRErrors: () => SSRErrors,
+  SSRTimings: () => SSRTimings,
+  createOnError: () => createOnError,
+  createOnTiming: () => createOnTiming
+});
+module.exports = __toCommonJS(tracer_exports);
+var SSRTimings;
+(function(SSRTimings2) {
+  SSRTimings2["PRERENDER"] = "ssr-prerender";
+  SSRTimings2["RENDER_HTML"] = "ssr-render-html";
+  SSRTimings2["RENDER_SHELL"] = "ssr-render-shell";
+  SSRTimings2["USE_LOADER"] = "use-loader";
+})(SSRTimings || (SSRTimings = {}));
+var SSRErrors;
+(function(SSRErrors2) {
+  SSRErrors2["PRERENDER"] = "App Prerender";
+  SSRErrors2["USE_LOADER"] = "App run useLoader";
+  SSRErrors2["RENDER_HTML"] = "App Render To HTML";
+  SSRErrors2["RENDER_STREAM"] = "An error occurs during streaming SSR";
+  SSRErrors2["RENDER_SHELL"] = "An error occurs during streaming render shell";
+})(SSRErrors || (SSRErrors = {}));
+function createOnError(onError) {
+  return (key, e) => {
+    const error = e instanceof Error ? e : new Error("Unexpected Server Error");
+    error.name = key;
+    onError === null || onError === void 0 ? void 0 : onError(e);
+  };
+}
+function createOnTiming(onTiming) {
+  return (key, cost) => {
+    onTiming === null || onTiming === void 0 ? void 0 : onTiming(key, cost);
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SSRErrors,
+  SSRTimings,
+  createOnError,
+  createOnTiming
+});

package/dist/cjs/{ssr/serverRender → core/server}/utils.js

@@ -20,9 +20,13 @@ var utils_exports = {};
 __export(utils_exports, {
   attributesToString: () => attributesToString,
   checkIsNode: () => checkIsNode,
-  safeReplace: () => safeReplace
+  getSSRConfigByEntry: () => getSSRConfigByEntry,
+  getSSRMode: () => getSSRMode,
+  safeReplace: () => safeReplace,
+  serializeErrors: () => serializeErrors
 });
 module.exports = __toCommonJS(utils_exports);
+var import_remix_router = require("@modern-js/runtime-utils/remix-router");
 function attributesToString(attributes) {
   return Object.entries(attributes).reduce((str, [key, value]) => {
     return value === void 0 ? str : `${str} ${key}="${value}"`;
@@ -35,9 +39,51 @@ function checkIsNode() {
   var _process_release;
   return typeof process !== "undefined" && ((_process_release = process.release) === null || _process_release === void 0 ? void 0 : _process_release.name) === "node";
 }
+function serializeErrors(errors) {
+  if (!errors) {
+    return null;
+  }
+  const entries = Object.entries(errors);
+  const serialized = {};
+  for (const [key, val] of entries) {
+    if ((0, import_remix_router.isRouteErrorResponse)(val)) {
+      serialized[key] = {
+        ...val,
+        __type: "RouteErrorResponse"
+      };
+    } else if (val instanceof Error) {
+      serialized[key] = {
+        message: val.message,
+        stack: val.stack,
+        __type: "Error"
+      };
+    } else {
+      serialized[key] = val;
+    }
+  }
+  return serialized;
+}
+function getSSRConfigByEntry(entryName, ssr, ssrByEntries, staticGenerate) {
+  if (staticGenerate) {
+    return true;
+  }
+  if (ssrByEntries === null || ssrByEntries === void 0 ? void 0 : ssrByEntries[entryName]) {
+    return ssrByEntries[entryName];
+  }
+  return ssr;
+}
+function getSSRMode(ssrConfig) {
+  if (typeof ssrConfig === "boolean") {
+    return ssrConfig ? "string" : false;
+  }
+  return (ssrConfig === null || ssrConfig === void 0 ? void 0 : ssrConfig.mode) === "stream" ? "stream" : "string";
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   attributesToString,
   checkIsNode,
-  safeReplace
+  getSSRConfigByEntry,
+  getSSRMode,
+  safeReplace,
+  serializeErrors
 });

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

@@ -28,12 +28,14 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var code_exports = {};
 __export(code_exports, {
-  generateCode: () => generateCode
+  generateCode: () => generateCode,
+  generatorRegisterCode: () => generatorRegisterCode
 });
 module.exports = __toCommonJS(code_exports);
 var import_path = __toESM(require("path"));
 var import_utils = require("@modern-js/utils");
 var import_constants = require("../constants");
+var import_constants2 = require("../../../cli/constants");
 var templates = __toESM(require("./templates"));
 var import_getClientRoutes = require("./getClientRoutes");
 var import_utils2 = require("./utils");
@@ -43,14 +45,11 @@ const generateCode = async (appContext, config, entrypoints, api) => {
   const hookRunners = api.useHookRunners();
   const isV5 = (0, import_utils.isRouterV5)(config);
   const getRoutes = isV5 ? import_getClientRoutes.getClientRoutesLegacy : import_getClientRoutes.getClientRoutes;
-  const importsStatemets = /* @__PURE__ */ new Map();
   const oldVersion = typeof (config === null || config === void 0 ? void 0 : config.runtime.router) === "object" ? Boolean((config === null || config === void 0 ? void 0 : config.runtime.router).oldVersion) : false;
   await Promise.all(entrypoints.map(generateEntryCode));
-  return {
-    importsStatemets
-  };
   async function generateEntryCode(entrypoint) {
     const { entryName, isMainEntry, isAutoMount, fileSystemRoutes } = entrypoint;
+    const { metaName } = api.useAppContext();
     if (isAutoMount) {
       if (fileSystemRoutes) {
         var _config_output;
@@ -102,6 +101,7 @@ const generateCode = async (appContext, config, entrypoints, api) => {
         const { code } = await hookRunners.beforeGenerateRoutes({
           entrypoint,
           code: await templates.fileSystemRoutes({
+            metaName,
             routes,
             ssrMode: useSSG ? "string" : mode,
             nestedRoutesEntry: entrypoint.nestedRoutesEntry,
@@ -128,7 +128,11 @@ const generateCode = async (appContext, config, entrypoints, api) => {
     }
   }
 };
+function generatorRegisterCode(internalDirectory, entryName, code) {
+  import_utils.fs.outputFileSync(import_path.default.resolve(internalDirectory, `./${entryName}/${import_constants2.ENTRY_POINT_RUNTIME_GLOBAL_CONTEXT_FILE_NAME}`), code, "utf8");
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  generateCode
+  generateCode,
+  generatorRegisterCode
 });

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

@@ -30,6 +30,7 @@ var templates_exports = {};
 __export(templates_exports, {
   fileSystemRoutes: () => fileSystemRoutes,
   routesForServer: () => routesForServer,
+  runtimeGlobalContext: () => runtimeGlobalContext,
   ssrLoaderCombinedModule: () => ssrLoaderCombinedModule
 });
 module.exports = __toCommonJS(templates_exports);
@@ -120,7 +121,7 @@ const routesForServer = ({ routes }) => {
 };
 const createMatchReg = (keyword) => new RegExp(`("${keyword}":\\s)"([^
 ]+)"`, "g");
-const fileSystemRoutes = async ({ routes, ssrMode, nestedRoutesEntry, entryName, internalDirectory, splitRouteChunks = true }) => {
+const fileSystemRoutes = async ({ metaName, routes, ssrMode, nestedRoutesEntry, entryName, internalDirectory, splitRouteChunks = true }) => {
   const components = [];
   const loadings = [];
   const errors = [];
@@ -131,7 +132,7 @@ const fileSystemRoutes = async ({ routes, ssrMode, nestedRoutesEntry, entryName,
   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"
+    import loadable, { lazy as loadableLazy } from "@${metaName}/runtime/loadable"
   `;
   let rootLayoutCode = ``;
   const getDataLoaderPath = ({ loaderId, clientData, action, inline, routeId }) => {
@@ -330,7 +331,7 @@ const fileSystemRoutes = async ({ routes, ssrMode, nestedRoutesEntry, entryName,
   await import_utils.fs.ensureFile(loadersMapFile);
   await import_utils.fs.writeJSON(loadersMapFile, loadersMap);
   const importRuntimeRouterCode = `
-    import { createShouldRevalidate, handleRouteModule,  handleRouteModuleError} from '@modern-js/runtime/router';
+    import { createShouldRevalidate, handleRouteModule,  handleRouteModuleError} from '@${metaName}/runtime/router';
   `;
   const routeModulesCode = `
     if(typeof document !== 'undefined'){
@@ -363,9 +364,63 @@ function ssrLoaderCombinedModule(entrypoints, entrypoint, config, appContext) {
   }
   return null;
 }
+const runtimeGlobalContext = async ({ metaName, srcDirectory, nestedRoutesEntry, internalSrcAlias, globalApp }) => {
+  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;`);
+  }
+  if (globalApp) {
+    imports.push(`import layoutApp from '${(0, import_utils.formatImportPath)(globalApp.replace(srcDirectory, internalSrcAlias))}';`);
+  } else {
+    imports.push(`let layoutApp;`);
+  }
+  return `${imports.join("\n")}
+
+import { routes } from './routes.js';
+
+setGlobalContext({
+  layoutApp,
+  routes,
+  appInit,
+  appConfig,
+});`;
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   fileSystemRoutes,
   routesForServer,
+  runtimeGlobalContext,
   ssrLoaderCombinedModule
 });

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

@@ -19,6 +19,8 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var constants_exports = {};
 __export(constants_exports, {
   ACTION_EXPORT_NAME: () => ACTION_EXPORT_NAME,
+  APP_CONFIG_NAME: () => APP_CONFIG_NAME,
+  APP_INIT_EXPORTED: () => APP_INIT_EXPORTED,
   FILE_SYSTEM_ROUTES_COMPONENTS_DIR: () => FILE_SYSTEM_ROUTES_COMPONENTS_DIR,
   FILE_SYSTEM_ROUTES_DYNAMIC_REGEXP: () => FILE_SYSTEM_ROUTES_DYNAMIC_REGEXP,
   FILE_SYSTEM_ROUTES_FILE_NAME: () => FILE_SYSTEM_ROUTES_FILE_NAME,
@@ -45,6 +47,8 @@ const FILE_SYSTEM_ROUTES_INDEX = "index";
 const FILE_SYSTEM_ROUTES_IGNORED_REGEX = /\.(d|test|spec|e2e)\.(js|jsx|ts|tsx)$/;
 const FILE_SYSTEM_ROUTES_DYNAMIC_REGEXP = /^\[(\S+)\]([*+?]?)$/;
 const FILE_SYSTEM_ROUTES_COMPONENTS_DIR = "internal_components";
+const APP_CONFIG_NAME = "config";
+const APP_INIT_EXPORTED = "init";
 const NESTED_ROUTE = {
   LAYOUT_FILE: "layout",
   LAYOUT_CONFIG_FILE: "layout.config",
@@ -68,6 +72,8 @@ const NESTED_ROUTE = {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ACTION_EXPORT_NAME,
+  APP_CONFIG_NAME,
+  APP_INIT_EXPORTED,
   FILE_SYSTEM_ROUTES_COMPONENTS_DIR,
   FILE_SYSTEM_ROUTES_DYNAMIC_REGEXP,
   FILE_SYSTEM_ROUTES_FILE_NAME,

package/dist/cjs/router/cli/entry.js

@@ -70,12 +70,10 @@ const modifyEntrypoints = (entrypoints, config = {}) => {
         globalApp: (0, import_utils.findExists)(import_utils.JS_EXTENSIONS.map((ext) => import_path.default.resolve(entrypoint.absoluteEntryDir, `./${import_constants.PAGES_DIR_NAME}/${import_constants.FILE_SYSTEM_ROUTES_GLOBAL_LAYOUT}${ext}`)))
       };
       if (isHasPages) {
-        entrypoint.entry = import_path.default.join(entrypoint.absoluteEntryDir, import_constants.PAGES_DIR_NAME);
-        entrypoint.pageRoutesEntry = entrypoint.entry;
+        entrypoint.pageRoutesEntry = import_path.default.join(entrypoint.absoluteEntryDir, import_constants.PAGES_DIR_NAME);
       }
       if (isHasNestedRoutes) {
-        entrypoint.entry = import_path.default.join(entrypoint.absoluteEntryDir, import_constants.NESTED_ROUTES_DIR);
-        entrypoint.nestedRoutesEntry = entrypoint.entry;
+        entrypoint.nestedRoutesEntry = import_path.default.join(entrypoint.absoluteEntryDir, import_constants.NESTED_ROUTES_DIR);
       }
     } else {
       throw Error("Custom entries with conventional routing not support use react router v5!");

package/dist/cjs/router/cli/handler.js

@@ -29,6 +29,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var handler_exports = {};
 __export(handler_exports, {
   handleFileChange: () => handleFileChange,
+  handleGeneratorEntryCode: () => handleGeneratorEntryCode,
   handleModifyEntrypoints: () => handleModifyEntrypoints
 });
 module.exports = __toCommonJS(handler_exports);
@@ -36,17 +37,32 @@ var import_path = __toESM(require("path"));
 var import_lodash = require("@modern-js/utils/lodash");
 var import_entry = require("./entry");
 var import_utils = require("./code/utils");
+var templates = __toESM(require("./code/templates"));
 let originEntrypoints = [];
 async function handleModifyEntrypoints(api, entrypoints) {
   const config = api.useResolvedConfigContext();
-  const newEntryPoints = (0, import_entry.modifyEntrypoints)(entrypoints, config);
+  return (0, import_entry.modifyEntrypoints)(entrypoints, config);
+}
+async function handleGeneratorEntryCode(api, entrypoints) {
   const appContext = api.useAppContext();
+  const { internalDirectory } = api.useAppContext();
   const resolvedConfig = api.useResolvedConfigContext();
-  appContext.entrypoints = newEntryPoints;
-  originEntrypoints = (0, import_lodash.cloneDeep)(newEntryPoints);
-  const { generateCode } = await Promise.resolve().then(() => __toESM(require("./code")));
+  const { generatorRegisterCode, generateCode } = await Promise.resolve().then(() => __toESM(require("./code")));
+  originEntrypoints = (0, import_lodash.cloneDeep)(entrypoints);
   await generateCode(appContext, resolvedConfig, entrypoints, api);
-  return newEntryPoints;
+  await Promise.all(entrypoints.map(async (entrypoint) => {
+    if (entrypoint.nestedRoutesEntry || entrypoint.pageRoutesEntry) {
+      var _entrypoint_fileSystemRoutes;
+      generatorRegisterCode(internalDirectory, entrypoint.entryName, await templates.runtimeGlobalContext({
+        metaName: appContext.metaName,
+        srcDirectory: appContext.srcDirectory,
+        nestedRoutesEntry: entrypoint.nestedRoutesEntry,
+        internalSrcAlias: appContext.internalSrcAlias,
+        globalApp: (_entrypoint_fileSystemRoutes = entrypoint.fileSystemRoutes) === null || _entrypoint_fileSystemRoutes === void 0 ? void 0 : _entrypoint_fileSystemRoutes.globalApp
+      }));
+    }
+  }));
+  return entrypoints;
 }
 async function handleFileChange(api, e) {
   const appContext = api.useAppContext();
@@ -67,5 +83,6 @@ async function handleFileChange(api, e) {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   handleFileChange,
+  handleGeneratorEntryCode,
   handleModifyEntrypoints
 });

package/dist/cjs/router/cli/index.js

@@ -30,17 +30,36 @@ var import_entry = require("./entry");
 var import_handler = require("./handler");
 var import_entry2 = require("./entry");
 var import_handler2 = require("./handler");
-const PLUGIN_IDENTIFIER = "router";
-const ROUTES_IDENTIFIER = "routes";
 const routerPlugin = () => ({
   name: "@modern-js/plugin-router",
   required: [
     "@modern-js/runtime"
   ],
   setup: (api) => {
-    const runtimeConfigMap = /* @__PURE__ */ new Map();
-    let pluginsExportsUtils;
     return {
+      _internalRuntimePlugins({ entrypoint, plugins }) {
+        var _getEntryOptions;
+        const { packageName, serverRoutes, metaName } = api.useAppContext();
+        const serverBase = serverRoutes.filter((route) => route.entryName === entrypoint.entryName).map((route) => route.urlPath).sort((a, b) => a.length - b.length > 0 ? -1 : 1);
+        const userConfig = api.useResolvedConfigContext();
+        const routerConfig = (_getEntryOptions = (0, import_utils.getEntryOptions)(entrypoint.entryName, entrypoint.isMainEntry, userConfig.runtime, userConfig.runtimeByEntries, packageName)) === null || _getEntryOptions === void 0 ? void 0 : _getEntryOptions.router;
+        if (routerConfig && !(0, import_utils.isRouterV5)(userConfig)) {
+          plugins.push({
+            name: "router",
+            path: `@${metaName}/runtime/router`,
+            config: typeof routerConfig === "boolean" ? {
+              serverBase
+            } : {
+              ...routerConfig,
+              serverBase
+            }
+          });
+        }
+        return {
+          entrypoint,
+          plugins
+        };
+      },
       checkEntryPoint({ path, entry }) {
         return {
           path,
@@ -48,8 +67,6 @@ const routerPlugin = () => ({
         };
       },
       config() {
-        const appContext = api.useAppContext();
-        pluginsExportsUtils = (0, import_utils.createRuntimeExportsUtils)(appContext.internalDirectory, "plugins");
         return {
           source: {
             include: [
@@ -59,10 +76,7 @@ const routerPlugin = () => ({
               /node_modules\/react-router/,
               /node_modules\/react-router-dom/,
               /node_modules\/@remix-run\/router/
-            ],
-            alias: {
-              "@modern-js/runtime/plugins": pluginsExportsUtils.getPath()
-            }
+            ]
           }
         };
       },
@@ -72,56 +86,15 @@ const routerPlugin = () => ({
           entrypoints: newEntryPoints
         };
       },
-      modifyEntryImports({ entrypoint, imports }) {
-        const { entryName, isMainEntry, fileSystemRoutes } = entrypoint;
-        const userConfig = api.useResolvedConfigContext();
-        const { packageName } = api.useAppContext();
-        const runtimeConfig = (0, import_utils.getEntryOptions)(entryName, isMainEntry, userConfig.runtime, userConfig.runtimeByEntries, packageName);
-        runtimeConfigMap.set(entryName, runtimeConfig);
-        if (runtimeConfig === null || runtimeConfig === void 0 ? void 0 : runtimeConfig.router) {
-          if (!(0, import_utils.isRouterV5)(userConfig)) {
-            imports.push({
-              value: "@modern-js/runtime/plugins",
-              specifiers: [
-                {
-                  imported: PLUGIN_IDENTIFIER
-                }
-              ]
-            });
-          }
-        } else if (fileSystemRoutes) {
-          throw new Error(`should enable runtime.router for entry ${entryName}`);
-        }
-        return {
-          entrypoint,
-          imports
-        };
-      },
-      modifyEntryRuntimePlugins({ entrypoint, plugins }) {
-        const { entryName, fileSystemRoutes } = entrypoint;
-        const { serverRoutes } = api.useAppContext();
-        const userConfig = api.useResolvedConfigContext();
-        const runtimeConfig = runtimeConfigMap.get(entryName);
-        if (runtimeConfig.router && !(0, import_utils.isRouterV5)(userConfig)) {
-          const serverBase = serverRoutes.filter((route) => route.entryName === entryName).map((route) => route.urlPath).sort((a, b) => a.length - b.length > 0 ? -1 : 1);
-          plugins.push({
-            name: PLUGIN_IDENTIFIER,
-            options: JSON.stringify({
-              serverBase,
-              ...runtimeConfig.router,
-              routesConfig: fileSystemRoutes ? `{ ${ROUTES_IDENTIFIER}, globalApp: App }` : void 0
-            }).replace(/"routesConfig"\s*:\s*"((\S|\s)+)"/g, '"routesConfig": $1,')
-          });
-        }
-        return {
-          entrypoint,
-          plugins
-        };
+      async generateEntryCode({ entrypoints }) {
+        await (0, import_handler.handleGeneratorEntryCode)(api, entrypoints);
       },
       addRuntimeExports() {
         const userConfig = api.useResolvedConfigContext();
+        const { internalDirectory, metaName } = api.useAppContext();
+        const pluginsExportsUtils = (0, import_utils.createRuntimeExportsUtils)(internalDirectory, "plugins");
         if (!(0, import_utils.isRouterV5)(userConfig)) {
-          pluginsExportsUtils.addExport(`export { default as router } from '@modern-js/runtime/router'`);
+          pluginsExportsUtils.addExport(`export { default as router } from '@${metaName}/runtime/router'`);
         }
       },
       async fileChange(e) {