@modern-js/runtime 2.67.11 → 2.68.1

package/dist/cjs/cli/alias.js

@@ -46,7 +46,7 @@ const builderPluginAlias = ({ entrypoints, internalDirectory, metaName }) => ({
         }
       });
       return mergeRsbuildConfig(userConfig, {
-        source: {
+        resolve: {
           alias: {
             ...entrypointsAlias,
             ...mainEntrypointsAlias

package/dist/cjs/cli/code.js

@@ -71,7 +71,8 @@ const generateCode = async (entrypoints, appContext, config, hooks) => {
           metaName,
           entryName,
           mountId,
-          urlPath: (_serverRoutes_find = serverRoutes.find((route) => route.entryName === entryName)) === null || _serverRoutes_find === void 0 ? void 0 : _serverRoutes_find.urlPath
+          urlPath: (_serverRoutes_find = serverRoutes.find((route) => route.entryName === entryName)) === null || _serverRoutes_find === void 0 ? void 0 : _serverRoutes_find.urlPath,
+          isNestedRouter: entrypoint.nestedRoutesEntry
         });
       } else {
         indexCode = template.index({
@@ -83,7 +84,8 @@ const generateCode = async (entrypoints, appContext, config, hooks) => {
           customEntry,
           customBootstrap,
           mountId,
-          enableRsc: config.server.rsc
+          enableRsc: config.server.rsc,
+          isNestedRouter: !!entrypoint.nestedRoutesEntry
         });
       }
       const indexFile = import_path.default.resolve(internalDirectory, `./${entryName}/${import_constants.ENTRY_POINT_FILE_NAME}`);
@@ -112,6 +114,7 @@ const generateCode = async (entrypoints, appContext, config, hooks) => {
       } else if (config.server.rsc) {
         const indexServerFile = import_path.default.resolve(internalDirectory, `./${entryName}/${import_constants.SERVER_ENTRY_POINT_FILE_NAME}`);
         const indexServerCode = serverTemplate.entryForCSRWithRSC({
+          entryName,
           metaName
         });
         await import_utils.fs.outputFile(indexServerFile, indexServerCode, "utf8");
@@ -130,7 +133,7 @@ const generateCode = async (entrypoints, appContext, config, hooks) => {
       const registerRuntimeFile = import_path.default.resolve(internalDirectory, `./${entryName}/${import_constants.ENTRY_POINT_RUNTIME_REGISTER_FILE_NAME}`);
       await import_utils.fs.outputFile(registerRuntimeFile, registerRuntimeCode, "utf8");
       let contextCode = "";
-      if (!config.server.rsc) {
+      if (!config.server.rsc || entrypoint.nestedRoutesEntry) {
         contextCode = template.runtimeGlobalContext({
           entryName,
           srcDirectory,

package/dist/cjs/cli/index.js

@@ -105,7 +105,7 @@ const runtimePlugin = (params) => ({
       return {
         runtime: {},
         runtimeByEntries: {},
-        source: {
+        resolve: {
           alias: {
             /**
             * twin.macro inserts styled-components into the code during the compilation process
@@ -121,7 +121,9 @@ const runtimePlugin = (params) => ({
             "@meta/runtime/react$": require.resolve("@modern-js/runtime/react"),
             "@meta/runtime/context$": require.resolve("@modern-js/runtime/context"),
             "@meta/runtime$": require.resolve("@modern-js/runtime")
-          },
+          }
+        },
+        source: {
           globalVars: {
             "process.env.IS_REACT18": process.env.IS_REACT18
           }

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

@@ -118,7 +118,7 @@ const ssrPlugin = () => ({
         builderPlugins: [
           ssrBuilderPlugin(api)
         ],
-        source: {
+        resolve: {
           alias: {
             // ensure that all packages use the same storage in @modern-js/runtime-utils/node
             "@modern-js/runtime-utils/node$": require.resolve("@modern-js/runtime-utils/node").replace(`${import_path.default.sep}cjs${import_path.default.sep}`, `${import_path.default.sep}esm${import_path.default.sep}`)

package/dist/cjs/cli/template.js

@@ -41,7 +41,21 @@ module.exports = __toCommonJS(template_exports);
 var import_path = __toESM(require("path"));
 var import_utils = require("@modern-js/utils");
 var import_constants = require("./constants");
-const genRenderCode = ({ srcDirectory, internalSrcAlias, metaName, entry, customEntry, customBootstrap, mountId, enableRsc }) => {
+const genRenderStatement = ({ customBootstrap, enableRsc, mountId, isNestedRouter }) => {
+  if (customBootstrap) {
+    return `customBootstrap(ModernRoot, () => render(<ModernRoot />, '${mountId || "root"}'));`;
+  }
+  if (enableRsc) {
+    if (!isNestedRouter) {
+      return `render(<ModernRoot>
+                  <RscClientRoot rscPayload={data} />
+                </ModernRoot>, '${mountId || "root"}');`;
+    }
+    return `render(<ModernRoot rscPayload={data} />, '${mountId || "root"}');`;
+  }
+  return `render(<ModernRoot />, '${mountId || "root"}');`;
+};
+const genRenderCode = ({ srcDirectory, internalSrcAlias, metaName, entry, customEntry, customBootstrap, mountId, enableRsc, isNestedRouter }) => {
   if (customEntry) {
     return `import '${(0, import_utils.formatImportPath)(entry.replace(srcDirectory, internalSrcAlias))}'`;
   }
@@ -60,11 +74,14 @@ ${customBootstrap ? `import customBootstrap from '${(0, import_utils.formatImpor
 
 const ModernRoot = createRoot();
 
-${customBootstrap ? `customBootstrap(ModernRoot, () => render(<ModernRoot />, '${mountId || "root"}'));` : enableRsc ? `render(<ModernRoot>
-                  <RscClientRoot data={data} />
-                </ModernRoot>, '${mountId || "root"}');` : `render(<ModernRoot />, '${mountId || "root"}');`}`;
+${genRenderStatement({
+    customBootstrap,
+    enableRsc,
+    mountId,
+    isNestedRouter
+  })}`;
 };
-const entryForCSRWithRSC = ({ metaName, entryName, urlPath = "/", mountId = "root" }) => {
+const entryForCSRWithRSC = ({ metaName, entryName, urlPath = "/", mountId = "root", isNestedRouter }) => {
   return `
   import '@${metaName}/runtime/registry/${entryName}';
   import { render } from '@${metaName}/runtime/browser';
@@ -72,28 +89,61 @@ const entryForCSRWithRSC = ({ metaName, entryName, urlPath = "/", mountId = "roo
 
   import {
     RscClientRoot,
-    createFromFetch
+    createFromFetch,
+    isRedirectResponse,
+    rscStream,
+    callServer,
+    createFromReadableStream
   } from '@${metaName}/runtime/rsc/client';
 
-  const content = createFromFetch(
-    fetch('${urlPath}', {
-      headers: {
-        'x-rsc-tree': 'true',
-      },
-    }),
-  );
+  const handleRedirectResponse = (res: Response) => {
+    const { headers } = res;
+    const location = headers.get('X-Modernjs-Redirect');
+    const baseUrl = headers.get('X-Modernjs-BaseUrl');
+    if (location) {
+      if (baseUrl !== '/') {
+        window.location.replace(baseUrl + location);
+      } else {
+        window.location.replace(location);
+      }
+      return;
+    }
+    return res;
+  };
+
+  ${process.env.MODERN_DISABLE_INJECT_RSC_DATA ? `
+      const data = createFromFetch(
+        fetch(location.pathname, {
+          headers: {
+            'x-rsc-tree': 'true',
+          },
+        }).then(handleRedirectResponse),
+      )
+      ` : `
+      const data = createFromReadableStream(rscStream, {
+        callServer: callServer,
+      });
+      `}
 
   const ModernRoot = createRoot();
 
-  render(
-    <ModernRoot>
-      <RscClientRoot data={content} />
-    </ModernRoot>,
-    '${mountId}',
-  );
+  ${isNestedRouter ? `
+      render(
+        <ModernRoot rscPayload={data}>
+        </ModernRoot>,
+        '${mountId}',
+      );
+      ` : `
+      render(
+        <ModernRoot>
+          <RscClientRoot rscPayload={data} />
+        </ModernRoot>,
+        '${mountId}',
+      );
+      `}
   `;
 };
-const index = ({ srcDirectory, internalSrcAlias, metaName, entry, entryName, customEntry, customBootstrap, mountId, enableRsc }) => `import '@${metaName}/runtime/registry/${entryName}';
+const index = ({ srcDirectory, internalSrcAlias, metaName, entry, entryName, customEntry, customBootstrap, mountId, enableRsc, isNestedRouter }) => `import '@${metaName}/runtime/registry/${entryName}';
 ${genRenderCode({
   srcDirectory,
   internalSrcAlias,
@@ -102,7 +152,8 @@ ${genRenderCode({
   customEntry,
   customBootstrap,
   mountId,
-  enableRsc
+  enableRsc,
+  isNestedRouter
 })}
 `;
 const register = () => `import './${import_constants.ENTRY_POINT_RUNTIME_GLOBAL_CONTEXT_FILE_NAME}';

package/dist/cjs/cli/template.server.js

@@ -48,6 +48,7 @@ import {
   createRequestHandler,
 } from '@#metaName/runtime/ssr/server';
 import { RSCServerSlot } from '@#metaName/runtime/rsc/client';
+import { renderRsc } from '@#metaName/runtime/rsc/server';
 export { handleAction } from '@#metaName/runtime/rsc/server';
 
 const handleRequest = async (request, ServerRoot, options) => {
@@ -58,7 +59,7 @@ const handleRequest = async (request, ServerRoot, options) => {
     </ServerRoot>,
     {
       ...options,
-      rscRoot: <options.RSCRoot />,
+      rscRoot: options.rscRoot,
     },
   );
 
@@ -70,7 +71,22 @@ const handleRequest = async (request, ServerRoot, options) => {
 };
 
 export const requestHandler = createRequestHandler(handleRequest, {
-  enableRsc: true,
+  enableRsc: true
+});
+
+const handleRSCRequest = async (request, ServerRoot, options) => {
+  const { serverPayload } = options;
+  const stream = renderRsc({
+    element: options.rscRoot,
+    clientManifest: options.rscClientManifest!,
+  });
+
+  return new Response(stream);
+}
+
+
+export const rscPayloadHandler = createRequestHandler(handleRSCRequest, {
+  enableRsc: true
 });
 `;
 const serverIndex = (options) => {
@@ -80,24 +96,57 @@ const serverIndex = (options) => {
     ${genHandlerCode(options)}
   `;
 };
-const entryForCSRWithRSC = ({ metaName }) => {
+const entryForCSRWithRSC = ({ metaName, entryName }) => {
   return `
-  import App from './AppProxy';
-  import { renderRsc } from '@${metaName}/runtime/rsc/server'
+  import '@${metaName}/runtime/registry/${entryName}';
+  import {
+    createRequestHandler,
+  } from '@${metaName}/runtime/ssr/server';
+  import { renderRsc, processRSCStream } from '@${metaName}/runtime/rsc/server'
   export { handleAction } from '@${metaName}/runtime/rsc/server';
 
+  const handleCSRRender = async (request, ServerRoot, options) => {
+    const rscPayloadStream = renderRsc({
+      element: options.rscRoot,
+      clientManifest: options.rscClientManifest!,
+    });
+    const stream = new ReadableStream({
+      start(controller) {
+        const encoder = new TextEncoder();
+
+        controller.enqueue(encoder.encode(options.html));
 
-  export const rscRequestHandler = ({
-    clientManifest
-  }) => {
+      processRSCStream(rscPayloadStream, controller, encoder)
+        .catch(err => {
+          controller.error(err);
+        });
+      }
+    });
+
+    return new Response(stream, {
+      status: 200,
+      headers: new Headers({
+        'content-type': 'text/html; charset=UTF-8',
+      }),
+    });
+  }
+
+  export const renderRscStreamHandler = createRequestHandler(handleCSRRender, {
+    enableRsc: true
+  });
+
+  const handleRequest = async (request, ServerRoot, options) => {
     const stream = renderRsc({
-      element: <App/>,
-      clientManifest,
-    })
+            element: options.rscRoot,
+      clientManifest: options.rscClientManifest!,
+    });
 
-    const response = new Response(stream);
-    return response
+    return new Response(stream);
   }
+
+  export const rscPayloadHandler = createRequestHandler(handleRequest, {
+    enableRsc: true
+  });
 `;
 };
 function genHandlerCode({ mode, metaName, customServerEntry, srcDirectory, internalSrcAlias, enableRsc }) {

package/dist/cjs/core/context/index.js

@@ -23,17 +23,28 @@ __export(context_exports, {
   getGlobalApp: () => getGlobalApp,
   getGlobalAppConfig: () => getGlobalAppConfig,
   getGlobalAppInit: () => getGlobalAppInit,
+  getGlobalEnableRsc: () => getGlobalEnableRsc,
   getGlobalInternalRuntimeContext: () => getGlobalInternalRuntimeContext,
+  getGlobalIsRscClient: () => getGlobalIsRscClient,
   getGlobalLayoutApp: () => getGlobalLayoutApp,
   getGlobalRSCRoot: () => getGlobalRSCRoot,
   getGlobalRoutes: () => getGlobalRoutes,
   getInitialContext: () => import_runtime.getInitialContext,
+  getServerPayload: () => import_serverPayload.getServerPayload,
   setGlobalContext: () => setGlobalContext,
-  setGlobalInternalRuntimeContext: () => setGlobalInternalRuntimeContext
+  setGlobalInternalRuntimeContext: () => setGlobalInternalRuntimeContext,
+  setServerPayload: () => import_serverPayload.setServerPayload
 });
 module.exports = __toCommonJS(context_exports);
 var import_runtime = require("./runtime");
+var import_serverPayload = require("./serverPayload.server");
 const globalContext = {};
+function getGlobalIsRscClient() {
+  return globalContext.isRscClient;
+}
+function getGlobalEnableRsc() {
+  return globalContext.enableRsc;
+}
 function setGlobalContext(context) {
   globalContext.entryName = context.entryName;
   globalContext.App = context.App;
@@ -42,6 +53,8 @@ function setGlobalContext(context) {
   globalContext.appConfig = typeof context.appConfig === "function" ? context.appConfig() : context.appConfig;
   globalContext.layoutApp = context.layoutApp;
   globalContext.RSCRoot = context.RSCRoot;
+  globalContext.isRscClient = context.isRscClient;
+  globalContext.enableRsc = context.enableRsc;
 }
 function getCurrentEntryName() {
   return globalContext.entryName;
@@ -79,11 +92,15 @@ function getGlobalLayoutApp() {
   getGlobalApp,
   getGlobalAppConfig,
   getGlobalAppInit,
+  getGlobalEnableRsc,
   getGlobalInternalRuntimeContext,
+  getGlobalIsRscClient,
   getGlobalLayoutApp,
   getGlobalRSCRoot,
   getGlobalRoutes,
   getInitialContext,
+  getServerPayload,
   setGlobalContext,
-  setGlobalInternalRuntimeContext
+  setGlobalInternalRuntimeContext,
+  setServerPayload
 });

package/dist/cjs/core/context/serverPayload.server.js

@@ -0,0 +1,40 @@
+"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 serverPayload_server_exports = {};
+__export(serverPayload_server_exports, {
+  getServerPayload: () => getServerPayload,
+  setServerPayload: () => setServerPayload
+});
+module.exports = __toCommonJS(serverPayload_server_exports);
+var import_node = require("@modern-js/runtime-utils/node");
+const getServerPayload = () => {
+  const context = import_node.storage.useContext();
+  return context === null || context === void 0 ? void 0 : context.serverPayload;
+};
+const setServerPayload = (payload) => {
+  const context = import_node.storage.useContext();
+  if (context) {
+    context.serverPayload = payload;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getServerPayload,
+  setServerPayload
+});

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

@@ -21,15 +21,40 @@ __export(requestHandler_exports, {
   createRequestHandler: () => createRequestHandler
 });
 module.exports = __toCommonJS(requestHandler_exports);
+var import_jsx_runtime = require("react/jsx-runtime");
 var import_node = require("@modern-js/runtime-utils/node");
 var import_request = require("@modern-js/runtime-utils/universal/request");
+var import_react = require("react");
 var import_context = require("../context");
 var import_runtime = require("../context/runtime");
+var import_serverPayload = require("../context/serverPayload.server");
 var import_loaderManager = require("../loader/loaderManager");
-var import_react = require("../react");
+var import_react2 = require("../react");
 var import_constants = require("./constants");
 var import_tracer = require("./tracer");
 var import_utils = require("./utils");
+async function handleRSCRequest(request, Root, context, options, handleRequest) {
+  const serverPayload = (0, import_serverPayload.getServerPayload)();
+  if (typeof serverPayload !== "undefined") {
+    return await handleRequest(request, Root, {
+      ...options,
+      runtimeContext: context,
+      rscRoot: serverPayload
+    });
+  }
+  const App = (0, import_context.getGlobalRSCRoot)();
+  if (App) {
+    return await handleRequest(request, import_react.Fragment, {
+      ...options,
+      runtimeContext: context,
+      rscRoot: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(App, {})
+    });
+  }
+  return await handleRequest(request, Root, {
+    ...options,
+    runtimeContext: context
+  });
+}
 function createSSRContext(request, options) {
   const { config, loaderContext, onError, onTiming, locals, resource, params, responseProxy, logger, metrics, reporter } = options;
   const { nonce, useJsonScript } = config;
@@ -100,10 +125,11 @@ const createRequestHandler = async (handleRequest, createRequestOptions) => {
       request,
       monitors: options.monitors,
       responseProxy,
-      activeDeferreds
+      activeDeferreds,
+      serverPayload: void 0
     }, async () => {
       var _context_routerContext, _context_routerContext1, _context_routerContext2;
-      const Root = (0, import_react.createRoot)();
+      const Root = (0, import_react2.createRoot)();
       const internalRuntimeContext = (0, import_context.getGlobalInternalRuntimeContext)();
       const hooks = internalRuntimeContext.hooks;
       const { routeManifest } = options.resource;
@@ -158,15 +184,25 @@ const createRequestHandler = async (handleRequest, createRequestOptions) => {
       context.initialData = initialData;
       const redirectResponse = getRedirectResponse(initialData);
       if (redirectResponse) {
-        return redirectResponse;
+        if (createRequestOptions === null || createRequestOptions === void 0 ? void 0 : createRequestOptions.enableRsc) {
+          return initialData;
+        } else {
+          return redirectResponse;
+        }
+      }
+      if (!(createRequestOptions === null || createRequestOptions === void 0 ? void 0 : createRequestOptions.enableRsc)) {
+        const { htmlTemplate } = options.resource;
+        options.resource.htmlTemplate = htmlTemplate.replace("</head>", `${import_constants.CHUNK_CSS_PLACEHOLDER}</head>`);
+      }
+      let response;
+      if (createRequestOptions === null || createRequestOptions === void 0 ? void 0 : createRequestOptions.enableRsc) {
+        response = await handleRSCRequest(request, Root, context, options, handleRequest);
+      } else {
+        response = await handleRequest(request, Root, {
+          ...options,
+          runtimeContext: context
+        });
       }
-      const { htmlTemplate } = options.resource;
-      options.resource.htmlTemplate = htmlTemplate.replace("</head>", `${import_constants.CHUNK_CSS_PLACEHOLDER}</head>`);
-      const response = await handleRequest(request, Root, {
-        ...options,
-        runtimeContext: context,
-        RSCRoot: (createRequestOptions === null || createRequestOptions === void 0 ? void 0 : createRequestOptions.enableRsc) && (0, import_context.getGlobalRSCRoot)()
-      });
       Object.entries(responseProxy.headers).forEach(([key, value]) => {
         response.headers.set(key, value);
       });

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

@@ -29,7 +29,8 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var code_exports = {};
 __export(code_exports, {
   generateCode: () => generateCode,
-  generatorRegisterCode: () => generatorRegisterCode
+  generatorRegisterCode: () => generatorRegisterCode,
+  generatorServerRegisterCode: () => generatorServerRegisterCode
 });
 module.exports = __toCommonJS(code_exports);
 var import_path = __toESM(require("path"));
@@ -107,14 +108,15 @@ const generateCode = async (appContext, config, entrypoints, api, isRouterV5) =>
           code: await templates.fileSystemRoutes({
             metaName,
             routes,
-            ssrMode: useSSG ? "string" : mode,
+            ssrMode: useSSG ? "string" : (0, import_utils.isUseRsc)(config2) ? "stream" : mode,
             nestedRoutesEntry: entrypoint.nestedRoutesEntry,
             entryName: entrypoint.entryName,
             internalDirectory,
-            splitRouteChunks: config2 === null || config2 === void 0 ? void 0 : (_config_output = config2.output) === null || _config_output === void 0 ? void 0 : _config_output.splitRouteChunks
+            splitRouteChunks: config2 === null || config2 === void 0 ? void 0 : (_config_output = config2.output) === null || _config_output === void 0 ? void 0 : _config_output.splitRouteChunks,
+            isRscClient: (0, import_utils.isUseRsc)(config2)
           })
         });
-        if (entrypoint.nestedRoutesEntry && (0, import_utils.isUseSSRBundle)(config2)) {
+        if (entrypoint.nestedRoutesEntry && ((0, import_utils.isUseSSRBundle)(config2) || (0, import_utils.isUseRsc)(config2))) {
           var _config_output1;
           const routesServerFile = (0, import_utils3.getServerLoadersFile)(internalDirectory, entryName);
           const filtedRoutesForServer = (0, import_utils2.filterRoutesForServer)(routes);
@@ -131,7 +133,8 @@ const generateCode = async (appContext, config, entrypoints, api, isRouterV5) =>
             nestedRoutesEntry: entrypoint.nestedRoutesEntry,
             entryName: entrypoint.entryName,
             internalDirectory,
-            splitRouteChunks: config2 === null || config2 === void 0 ? void 0 : (_config_output1 = config2.output) === null || _config_output1 === void 0 ? void 0 : _config_output1.splitRouteChunks
+            splitRouteChunks: config2 === null || config2 === void 0 ? void 0 : (_config_output1 = config2.output) === null || _config_output1 === void 0 ? void 0 : _config_output1.splitRouteChunks,
+            isRscClient: false
           });
           await import_utils.fs.outputFile(import_path.default.resolve(internalDirectory, `./${entryName}/routes.server.js`), serverRoutesCode, "utf8");
         }
@@ -148,8 +151,12 @@ const generateCode = async (appContext, config, entrypoints, api, isRouterV5) =>
 function generatorRegisterCode(internalDirectory, entryName, code) {
   import_utils.fs.outputFileSync(import_path.default.resolve(internalDirectory, `./${entryName}/${import_constants.ENTRY_POINT_RUNTIME_GLOBAL_CONTEXT_FILE_NAME}.js`), code, "utf8");
 }
+function generatorServerRegisterCode(internalDirectory, entryName, code) {
+  import_utils.fs.outputFileSync(import_path.default.resolve(internalDirectory, `./${entryName}/${import_constants.ENTRY_POINT_RUNTIME_GLOBAL_CONTEXT_FILE_NAME}.server.js`), code, "utf8");
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   generateCode,
-  generatorRegisterCode
+  generatorRegisterCode,
+  generatorServerRegisterCode
 });