@modern-js/runtime 2.54.5 → 2.55.0

package/dist/esm-node/core/server/string/index.js

@@ -0,0 +1,118 @@
+import ReactHelmet from "react-helmet";
+import ReactDomServer from "react-dom/server";
+import React from "react";
+import { time } from "@modern-js/runtime-utils/time";
+import { run } from "@modern-js/runtime-utils/node";
+import { parseHeaders } from "@modern-js/runtime-utils/universal/request";
+import { createReplaceHelemt } from "../helmet";
+import { getSSRConfigByEntry, safeReplace } from "../utils";
+import { CHUNK_CSS_PLACEHOLDER, CHUNK_JS_PLACEHOLDER, HTML_PLACEHOLDER, SSR_DATA_PLACEHOLDER } from "../constants";
+import { buildHtml } from "../shared";
+import { SSRErrors, SSRTimings, createOnError, createOnTiming } from "../tracer";
+import { RenderLevel } from "../../constants";
+import { SSRDataCollector } from "./ssrData";
+import { LoadableCollector } from "./loadable";
+import { StyledCollector } from "./styledComponent";
+import { prefetch } from "./prefetch";
+const renderString = async (request, serverRoot, options) => {
+  const headersData = parseHeaders(request);
+  return run(headersData, async () => {
+    var _runtimeContext_ssrContext;
+    const { resource, runtimeContext, config, onError, onTiming, staticGenerate } = options;
+    const tracer = {
+      onError: createOnError(onError),
+      onTiming: createOnTiming(onTiming)
+    };
+    const routerContext = runtimeContext.routerContext;
+    const { htmlTemplate, entryName, loadableStats, routeManifest } = resource;
+    const chunkSet = {
+      renderLevel: RenderLevel.CLIENT_RENDER,
+      ssrScripts: "",
+      jsChunk: "",
+      cssChunk: ""
+    };
+    let prefetchData = {};
+    try {
+      prefetchData = await prefetch(serverRoot, request, options, tracer);
+      chunkSet.renderLevel = RenderLevel.SERVER_PREFETCH;
+    } catch (e) {
+      chunkSet.renderLevel = RenderLevel.CLIENT_RENDER;
+    }
+    const ssrConfig = getSSRConfigByEntry(entryName, config.ssr, config.ssrByEntries, staticGenerate);
+    const collectors = [
+      new StyledCollector(chunkSet),
+      new LoadableCollector({
+        stats: loadableStats,
+        nonce: config.nonce,
+        routeManifest,
+        template: htmlTemplate,
+        entryName,
+        chunkSet,
+        config
+      }),
+      new SSRDataCollector({
+        request,
+        prefetchData,
+        ssrConfig,
+        ssrContext: runtimeContext.ssrContext,
+        chunkSet,
+        routerContext,
+        nonce: config.nonce
+      })
+    ];
+    const rootElement = React.cloneElement(serverRoot, {
+      _internal_context: Object.assign(runtimeContext, {
+        ssr: true
+      })
+    });
+    const html = await generateHtml(rootElement, htmlTemplate, chunkSet, collectors, ((_runtimeContext_ssrContext = runtimeContext.ssrContext) === null || _runtimeContext_ssrContext === void 0 ? void 0 : _runtimeContext_ssrContext.htmlModifiers) || [], tracer);
+    return html;
+  });
+};
+async function generateHtml(App, htmlTemplate, chunkSet, collectors, htmlModifiers, { onError, onTiming }) {
+  const end = time();
+  let html = "";
+  let helmetData;
+  if (chunkSet.renderLevel >= RenderLevel.SERVER_PREFETCH) {
+    try {
+      const finalApp = collectors.reduce((pre, creator) => {
+        var _creator_collect;
+        return ((_creator_collect = creator.collect) === null || _creator_collect === void 0 ? void 0 : _creator_collect.call(creator, pre)) || pre;
+      }, App);
+      html = ReactDomServer.renderToString(finalApp);
+      helmetData = ReactHelmet.renderStatic();
+      chunkSet.renderLevel = RenderLevel.SERVER_RENDER;
+      await Promise.all(collectors.map((component) => component.effect()));
+      const cost = end();
+      onTiming(SSRTimings.RENDER_HTML, cost);
+    } catch (e) {
+      chunkSet.renderLevel = RenderLevel.CLIENT_RENDER;
+      onError(SSRErrors.RENDER_HTML, e);
+    }
+  }
+  const { ssrScripts, cssChunk, jsChunk } = chunkSet;
+  const finalHtml = await buildHtml(htmlTemplate, [
+    createReplaceHtml(html),
+    createReplaceChunkJs(jsChunk),
+    createReplaceChunkCss(cssChunk),
+    createReplaceSSRDataScript(ssrScripts),
+    createReplaceHelemt(helmetData),
+    ...htmlModifiers
+  ]);
+  return finalHtml;
+}
+function createReplaceHtml(html) {
+  return (template) => safeReplace(template, HTML_PLACEHOLDER, html);
+}
+function createReplaceSSRDataScript(data) {
+  return (template) => safeReplace(template, SSR_DATA_PLACEHOLDER, data);
+}
+function createReplaceChunkJs(js) {
+  return (template) => safeReplace(template, CHUNK_JS_PLACEHOLDER, js);
+}
+function createReplaceChunkCss(css) {
+  return (template) => safeReplace(template, CHUNK_CSS_PLACEHOLDER, css);
+}
+export {
+  renderString
+};

package/dist/esm-node/{ssr/serverRender/renderToString → core/server/string}/loadable.js

@@ -61,13 +61,12 @@ class LoadableCollector {
     if (!check(scripts)) {
       return;
     }
-    const { result: { chunksMap } } = this.options;
+    const { chunkSet } = this.options;
     const s = scripts.split("</script>").slice(0, 2).map((i) => `${i}</script>`).join("");
-    chunksMap.js += s;
+    chunkSet.jsChunk += s;
   }
   async emitScriptAssets(chunks) {
-    const { template, config, nonce, result } = this.options;
-    const { chunksMap } = result;
+    const { template, nonce, chunkSet, config } = this.options;
     const { scriptLoading = "defer", enableInlineScripts } = config;
     const scriptLoadingAtr = {
       defer: scriptLoading === "defer" ? true : void 0,
@@ -92,10 +91,11 @@ class LoadableCollector {
         return script;
       }
     }));
-    chunksMap.js += scripts.filter((script) => Boolean(script)).join("");
+    chunkSet.jsChunk += scripts.filter((script) => Boolean(script)).join("");
   }
   async emitStyleAssets(chunks) {
-    const { template, result: { chunksMap }, config: { enableInlineStyles } } = this.options;
+    const { template, chunkSet, config } = this.options;
+    const { enableInlineStyles } = config;
     const atrributes = attributesToString(this.generateAttributes());
     const css = await Promise.all(chunks.filter((chunk) => {
       var _this_existsAssets;
@@ -111,7 +111,7 @@ class LoadableCollector {
         return link;
       }
     }));
-    chunksMap.css += css.filter((css2) => Boolean(css2)).join("");
+    chunkSet.jsChunk += css.filter((css2) => Boolean(css2)).join("");
   }
   generateAttributes(extraAtr = {}) {
     const { config } = this.options;
@@ -129,9 +129,6 @@ class LoadableCollector {
     this.options = options;
   }
 }
-function createLoadableCollector(options) {
-  return new LoadableCollector(options);
-}
 export {
-  createLoadableCollector
+  LoadableCollector
 };

package/dist/esm-node/core/server/string/prefetch.js

@@ -0,0 +1,78 @@
+import { renderToStaticMarkup } from "react-dom/server";
+import { run } from "@modern-js/runtime-utils/node";
+import { ChunkExtractor } from "@loadable/server";
+import { time } from "@modern-js/runtime-utils/time";
+import { parseHeaders } from "@modern-js/runtime-utils/universal/request";
+import React from "react";
+import { SSRErrors, SSRTimings } from "../tracer";
+const prefetch = async (App, request, options, { onError, onTiming }) => {
+  const headersData = parseHeaders(request);
+  const { runtimeContext: context, resource, config } = options;
+  const { entryName, loadableStats } = resource;
+  return run(headersData, async () => {
+    var _context_store;
+    if (!config.disablePrerender) {
+      try {
+        const end = time();
+        if (loadableStats) {
+          const extractor = new ChunkExtractor({
+            stats: loadableStats,
+            entrypoints: [
+              entryName
+            ].filter(Boolean)
+          });
+          renderToStaticMarkup(extractor.collectChunks(/* @__PURE__ */ React.cloneElement(App, {
+            _internal_context: Object.assign(context, {
+              ssr: false
+            })
+          })));
+        } else {
+          renderToStaticMarkup(/* @__PURE__ */ React.cloneElement(App, {
+            _internal_context: Object.assign(context, {
+              ssr: false
+            })
+          }));
+        }
+        const cost = end();
+        onTiming(SSRTimings.PRERENDER, cost);
+      } catch (e) {
+        const error = e;
+        onError(SSRErrors.PRERENDER, error);
+        throw e;
+      }
+    }
+    if (!context.loaderManager.hasPendingLoaders()) {
+      return {
+        initialData: context.initialData,
+        i18nData: context.__i18nData__
+      };
+    }
+    let loadersData = {};
+    try {
+      const end = time();
+      loadersData = await context.loaderManager.awaitPendingLoaders();
+      const cost = end();
+      onTiming(SSRTimings.USE_LOADER, cost);
+    } catch (e) {
+      onError(SSRErrors.USE_LOADER, e);
+      throw e;
+    }
+    Object.keys(loadersData).forEach((id) => {
+      const data = loadersData[id];
+      if (data._error) {
+        onError(SSRErrors.USE_LOADER, data._error);
+        delete data._error;
+      }
+    });
+    return {
+      loadersData,
+      initialData: context.initialData,
+      i18nData: context.__i18nData__,
+      // todo: move to plugin state
+      storeState: context === null || context === void 0 ? void 0 : (_context_store = context.store) === null || _context_store === void 0 ? void 0 : _context_store.getState()
+    };
+  });
+};
+export {
+  prefetch
+};

package/dist/esm-node/core/server/string/ssrData.js

@@ -0,0 +1,76 @@
+import { _ as _class_private_field_get } from "@swc/helpers/_/_class_private_field_get";
+import { _ as _class_private_field_init } from "@swc/helpers/_/_class_private_field_init";
+import { _ as _class_private_field_set } from "@swc/helpers/_/_class_private_field_set";
+import { _ as _class_private_method_get } from "@swc/helpers/_/_class_private_method_get";
+import { _ as _class_private_method_init } from "@swc/helpers/_/_class_private_method_init";
+import { serializeJson } from "@modern-js/runtime-utils/node";
+import { attributesToString, serializeErrors } from "../utils";
+import { ROUTER_DATA_JSON_ID, SSR_DATA_JSON_ID } from "../constants";
+var _options = /* @__PURE__ */ new WeakMap(), _getSSRData = /* @__PURE__ */ new WeakSet(), _getSSRDataScripts = /* @__PURE__ */ new WeakSet();
+class SSRDataCollector {
+  effect() {
+    const { routerContext, chunkSet } = _class_private_field_get(this, _options);
+    const ssrData = _class_private_method_get(this, _getSSRData, getSSRData).call(this);
+    const routerData = routerContext ? {
+      loaderData: routerContext.loaderData,
+      errors: serializeErrors(routerContext.errors)
+    } : void 0;
+    const ssrDataScripts = _class_private_method_get(this, _getSSRDataScripts, getSSRDataScripts).call(this, ssrData, routerData);
+    chunkSet.ssrScripts = ssrDataScripts;
+  }
+  constructor(options) {
+    _class_private_method_init(this, _getSSRData);
+    _class_private_method_init(this, _getSSRDataScripts);
+    _class_private_field_init(this, _options, {
+      writable: true,
+      value: void 0
+    });
+    _class_private_field_set(this, _options, options);
+  }
+}
+function getSSRData() {
+  const { prefetchData, chunkSet, ssrConfig, ssrContext } = _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 } = _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 = serializeJson(ssrData);
+  const attrsStr = attributesToString({
+    nonce
+  });
+  let ssrDataScripts = useInlineScript ? `<script${attrsStr}>window._SSR_DATA = ${serializeSSRData}</script>` : `<script type="application/json" id="${SSR_DATA_JSON_ID}">${serializeSSRData}</script>`;
+  if (routerData) {
+    const serializedRouterData = serializeJson(routerData);
+    ssrDataScripts += useInlineScript ? `
+<script${attrsStr}>window._ROUTER_DATA = ${serializedRouterData}</script>` : `
+<script type="application/json" id="${ROUTER_DATA_JSON_ID}">${serializedRouterData}</script>`;
+  }
+  return ssrDataScripts;
+}
+export {
+  SSRDataCollector
+};

package/dist/esm-node/core/server/string/styledComponent.js

@@ -0,0 +1,29 @@
+import { _ as _class_private_field_get } from "@swc/helpers/_/_class_private_field_get";
+import { _ as _class_private_field_init } from "@swc/helpers/_/_class_private_field_init";
+import { _ as _class_private_field_set } from "@swc/helpers/_/_class_private_field_set";
+import { ServerStyleSheet } from "styled-components";
+var _sheet = /* @__PURE__ */ new WeakMap(), _chunkSet = /* @__PURE__ */ new WeakMap();
+class StyledCollector {
+  collect(comopnent) {
+    return _class_private_field_get(this, _sheet).collectStyles(comopnent);
+  }
+  effect() {
+    const css = _class_private_field_get(this, _sheet).getStyleTags();
+    _class_private_field_get(this, _chunkSet).cssChunk += css;
+  }
+  constructor(chunkSet) {
+    _class_private_field_init(this, _sheet, {
+      writable: true,
+      value: void 0
+    });
+    _class_private_field_init(this, _chunkSet, {
+      writable: true,
+      value: void 0
+    });
+    _class_private_field_set(this, _sheet, new ServerStyleSheet());
+    _class_private_field_set(this, _chunkSet, chunkSet);
+  }
+}
+export {
+  StyledCollector
+};

package/dist/esm-node/core/server/tracer.js

@@ -0,0 +1,33 @@
+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);
+  };
+}
+export {
+  SSRErrors,
+  SSRTimings,
+  createOnError,
+  createOnTiming
+};

package/dist/esm-node/core/server/utils.js

@@ -0,0 +1,60 @@
+import { isRouteErrorResponse } from "@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}"`;
+  }, "");
+}
+function safeReplace(source, searchValue, replaceValue) {
+  return source.replace(searchValue, () => replaceValue);
+}
+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 (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";
+}
+export {
+  attributesToString,
+  checkIsNode,
+  getSSRConfigByEntry,
+  getSSRMode,
+  safeReplace,
+  serializeErrors
+};

package/dist/esm-node/router/cli/code/index.js

@@ -1,6 +1,7 @@
 import path from "path";
 import { fs, getEntryOptions, isRouterV5, isSSGEntry, isUseSSRBundle, logger } from "@modern-js/utils";
 import { FILE_SYSTEM_ROUTES_FILE_NAME } from "../constants";
+import { ENTRY_POINT_RUNTIME_GLOBAL_CONTEXT_FILE_NAME } from "../../../cli/constants";
 import * as templates from "./templates";
 import { getClientRoutes, getClientRoutesLegacy } from "./getClientRoutes";
 import { getServerLoadersFile, getServerCombinedModueFile } from "./utils";
@@ -10,14 +11,11 @@ const generateCode = async (appContext, config, entrypoints, api) => {
   const hookRunners = api.useHookRunners();
   const isV5 = isRouterV5(config);
   const getRoutes = isV5 ? getClientRoutesLegacy : 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;
@@ -69,6 +67,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,
@@ -95,6 +94,10 @@ const generateCode = async (appContext, config, entrypoints, api) => {
     }
   }
 };
+function generatorRegisterCode(internalDirectory, entryName, code) {
+  fs.outputFileSync(path.resolve(internalDirectory, `./${entryName}/${ENTRY_POINT_RUNTIME_GLOBAL_CONTEXT_FILE_NAME}`), code, "utf8");
+}
 export {
-  generateCode
+  generateCode,
+  generatorRegisterCode
 };

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

@@ -1,8 +1,8 @@
 import path from "path";
-import { fs, getEntryOptions, isSSGEntry, slash } from "@modern-js/utils";
+import { findExists, formatImportPath, fs, getEntryOptions, isSSGEntry, slash } from "@modern-js/utils";
 import { ROUTE_MODULES } from "@modern-js/utils/universal/constants";
-import { TEMP_LOADERS_DIR } from "../constants";
-import { getServerLoadersFile } from "./utils";
+import { APP_CONFIG_NAME, APP_INIT_EXPORTED, TEMP_LOADERS_DIR } from "../constants";
+import { getPathWithoutExt, getServerLoadersFile, parseModule, replaceWithAlias } from "./utils";
 const routesForServer = ({ routes }) => {
   const loaders = [];
   const actions = [];
@@ -85,7 +85,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 = [];
@@ -96,7 +96,7 @@ const fileSystemRoutes = async ({ routes, ssrMode, nestedRoutesEntry, entryName,
   const loadersMapFile = path.join(internalDirectory, entryName, 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 }) => {
@@ -295,7 +295,7 @@ const fileSystemRoutes = async ({ routes, ssrMode, nestedRoutesEntry, entryName,
   await fs.ensureFile(loadersMapFile);
   await 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'){
@@ -328,8 +328,62 @@ 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 = path.join(nestedRoutesEntry, "layout");
+    const rootLayoutFile = findExists([
+      ".js",
+      ".ts",
+      ".jsx",
+      ".tsx"
+    ].map((ext) => `${rootLayoutPath}${ext}`));
+    if (rootLayoutFile) {
+      const rootLayoutBuffer = await fs.readFile(rootLayoutFile);
+      const rootLayout = rootLayoutBuffer.toString();
+      const [, moduleExports] = await parseModule({
+        source: rootLayout.toString(),
+        filename: rootLayoutFile
+      });
+      const hasAppConfig = moduleExports.some((e) => e.n === APP_CONFIG_NAME);
+      const hasAppInit = moduleExports.some((e) => e.n === APP_INIT_EXPORTED);
+      const layoutPath = formatImportPath(getPathWithoutExt(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 '${formatImportPath(globalApp.replace(srcDirectory, internalSrcAlias))}';`);
+  } else {
+    imports.push(`let layoutApp;`);
+  }
+  return `${imports.join("\n")}
+
+import { routes } from './routes.js';
+
+setGlobalContext({
+  layoutApp,
+  routes,
+  appInit,
+  appConfig,
+});`;
+};
 export {
   fileSystemRoutes,
   routesForServer,
+  runtimeGlobalContext,
   ssrLoaderCombinedModule
 };

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

@@ -10,6 +10,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",
@@ -32,6 +34,8 @@ const NESTED_ROUTE = {
 };
 export {
   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/esm-node/router/cli/entry.js

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

package/dist/esm-node/router/cli/handler.js

@@ -2,17 +2,32 @@ import path from "path";
 import { cloneDeep } from "@modern-js/utils/lodash";
 import { modifyEntrypoints } from "./entry";
 import { isPageComponentFile } from "./code/utils";
+import * as templates from "./code/templates";
 let originEntrypoints = [];
 async function handleModifyEntrypoints(api, entrypoints) {
   const config = api.useResolvedConfigContext();
-  const newEntryPoints = modifyEntrypoints(entrypoints, config);
+  return modifyEntrypoints(entrypoints, config);
+}
+async function handleGeneratorEntryCode(api, entrypoints) {
   const appContext = api.useAppContext();
+  const { internalDirectory } = api.useAppContext();
   const resolvedConfig = api.useResolvedConfigContext();
-  appContext.entrypoints = newEntryPoints;
-  originEntrypoints = cloneDeep(newEntryPoints);
-  const { generateCode } = await import("./code");
+  const { generatorRegisterCode, generateCode } = await import("./code");
+  originEntrypoints = 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();
@@ -32,5 +47,6 @@ async function handleFileChange(api, e) {
 }
 export {
   handleFileChange,
+  handleGeneratorEntryCode,
   handleModifyEntrypoints
 };