@modern-js/runtime 2.68.0 → 2.68.2

package/dist/cjs/router/runtime/plugin.node.js

@@ -44,8 +44,10 @@ var import_react = require("react");
 var import_common = require("../../common");
 var import_core = require("../../core");
 var import_context = require("../../core/context");
+var import_serverPayload = require("../../core/context/serverPayload.server");
 var import_DeferredDataScripts = __toESM(require("./DeferredDataScripts.node"));
 var import_hooks = require("./hooks");
+var import_rsc_router = require("./rsc-router");
 var import_utils = require("./utils");
 function createRemixReuqest(request) {
   const method = "GET";
@@ -78,6 +80,10 @@ const routerPlugin = (userConfig = {}) => {
         if (!finalRouteConfig.routes && !createRoutes) {
           return;
         }
+        const enableRsc = (0, import_context.getGlobalEnableRsc)();
+        if (enableRsc) {
+          await (0, import_rsc_router.prepareRSCRoutes)(finalRouteConfig.routes);
+        }
         const { request, mode: ssrMode, nonce, loaderFailureMode = "errorBoundary" } = context.ssrContext;
         const { baseUrl } = request;
         const _basename = baseUrl === "/" ? (0, import_utils.urlJoin)(baseUrl, basename) : baseUrl;
@@ -86,13 +92,20 @@ const routerPlugin = (userConfig = {}) => {
         requestContext.set(import_node.reporterCtx, reporter);
         const hooks = api.getHooks();
         await hooks.onBeforeCreateRoutes.call(context);
-        let routes = createRoutes ? createRoutes() : (0, import_router2.createRoutesFromElements)((0, import_utils.renderRoutes)({
-          routesConfig: finalRouteConfig,
-          ssrMode,
-          props: {
-            nonce
-          }
-        }));
+        let routes = [];
+        if (enableRsc) {
+          routes = createRoutes ? createRoutes() : (0, import_utils.createRouteObjectsFromConfig)({
+            routesConfig: finalRouteConfig
+          });
+        } else {
+          routes = createRoutes ? createRoutes() : (0, import_router2.createRoutesFromElements)((0, import_utils.renderRoutes)({
+            routesConfig: finalRouteConfig,
+            ssrMode,
+            props: {
+              nonce
+            }
+          }));
+        }
         routes = hooks.modifyRoutes.call(routes);
         const { query } = (0, import_remix_router.createStaticHandler)(routes, {
           basename: _basename
@@ -104,8 +117,13 @@ const routerPlugin = (userConfig = {}) => {
         });
         const cost = end();
         (_context_ssrContext1 = context.ssrContext) === null || _context_ssrContext1 === void 0 ? void 0 : (_context_ssrContext_onTiming = _context_ssrContext1.onTiming) === null || _context_ssrContext_onTiming === void 0 ? void 0 : _context_ssrContext_onTiming.call(_context_ssrContext1, import_constants.LOADER_REPORTER_NAME, cost);
+        const isRSCNavigation = remixRequest.headers.get("x-rsc-tree") === "true";
         if (routerContext instanceof Response) {
-          return interrupt(routerContext);
+          if (enableRsc && isRSCNavigation) {
+            return interrupt((0, import_rsc_router.handleRSCRedirect)(routerContext.headers, _basename, routerContext.status));
+          } else {
+            return interrupt(routerContext);
+          }
         }
         const errors = Object.values(routerContext.errors || {});
         if (
@@ -115,9 +133,19 @@ const routerPlugin = (userConfig = {}) => {
           routerContext.statusCode = 200;
           throw errors[0];
         }
-        const router = (0, import_router.createStaticRouter)(routes, routerContext);
         context.routerContext = routerContext;
-        context.remixRouter = router;
+        let payload;
+        if (enableRsc) {
+          if (isRSCNavigation) {
+            for (const match of routerContext.matches) {
+              if (match.route.hasClientLoader) {
+                delete routerContext.loaderData[match.route.id];
+              }
+            }
+          }
+          payload = (0, import_rsc_router.createServerPayload)(routerContext, routes);
+          (0, import_serverPayload.setServerPayload)(payload);
+        }
         Object.defineProperty(context, "routes", {
           get() {
             return routes;
@@ -130,30 +158,43 @@ const routerPlugin = (userConfig = {}) => {
           return App;
         }
         const getRouteApp = () => {
-          return () => {
+          const enableRsc = (0, import_context.getGlobalEnableRsc)();
+          return (props) => {
             const context = (0, import_react.useContext)(import_core.RuntimeReactContext);
-            const { remixRouter, routerContext, ssrContext } = context;
+            const { routerContext, ssrContext, routes } = context;
             const { nonce, mode, useJsonScript } = ssrContext;
-            const routerWrapper = /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(import_jsx_runtime.Fragment, {
-              children: [
-                /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_router.StaticRouterProvider, {
-                  router: remixRouter,
-                  context: routerContext,
-                  hydrate: false
-                }),
-                mode === "stream" && // ROUTER_DATA will inject in `packages/runtime/plugin-runtime/src/core/server/string/ssrData.ts` in string ssr
-                // So we can inject it only when streaming ssr
-                /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_DeferredDataScripts.default, {
-                  nonce,
-                  context: routerContext,
-                  useJsonScript
-                }),
-                mode === "stream" && import_common.JSX_SHELL_STREAM_END_MARK
-              ]
-            });
-            return App ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)(App, {
-              children: routerWrapper
-            }) : routerWrapper;
+            const { basename } = routerContext;
+            const remixRouter = (0, import_router.createStaticRouter)(routes, routerContext);
+            if (!enableRsc) {
+              const routerWrapper = /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(import_jsx_runtime.Fragment, {
+                children: [
+                  /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_router.StaticRouterProvider, {
+                    router: remixRouter,
+                    context: routerContext,
+                    hydrate: false
+                  }),
+                  mode === "stream" && // ROUTER_DATA will inject in `packages/runtime/plugin-runtime/src/core/server/string/ssrData.ts` in string ssr
+                  // So we can inject it only when streaming ssr
+                  /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_DeferredDataScripts.default, {
+                    nonce,
+                    context: routerContext,
+                    useJsonScript
+                  }),
+                  mode === "stream" && import_common.JSX_SHELL_STREAM_END_MARK
+                ]
+              });
+              return App ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)(App, {
+                children: routerWrapper
+              }) : routerWrapper;
+            } else {
+              return App ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)(App, {
+                children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_rsc_router.RSCStaticRouter, {
+                  basename
+                })
+              }) : /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_rsc_router.RSCStaticRouter, {
+                basename
+              });
+            }
           };
         };
         return getRouteApp();

package/dist/cjs/router/runtime/rsc-router.js

@@ -0,0 +1,322 @@
+"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 rsc_router_exports = {};
+__export(rsc_router_exports, {
+  RSCStaticRouter: () => RSCStaticRouter,
+  createClientRouterFromPayload: () => createClientRouterFromPayload,
+  createServerPayload: () => createServerPayload,
+  handleRSCRedirect: () => handleRSCRedirect,
+  prepareRSCRoutes: () => prepareRSCRoutes
+});
+module.exports = __toCommonJS(rsc_router_exports);
+var import_jsx_runtime = require("react/jsx-runtime");
+var import_client = require("@modern-js/render/client");
+var import_router = require("@modern-js/runtime-utils/node/router");
+var import_router2 = require("@modern-js/runtime-utils/router");
+var import_react = __toESM(require("react"));
+const safeUse = (promise) => {
+  if (typeof import_react.default.use === "function") {
+    return import_react.default.use(promise);
+  }
+  return null;
+};
+const createServerPayload = (routerContext, routes) => {
+  return {
+    type: "render",
+    actionData: routerContext.actionData,
+    errors: routerContext.errors,
+    loaderData: routerContext.loaderData,
+    location: routerContext.location,
+    routes: routerContext.matches.map((match, index, matches) => {
+      const element = match.route.element;
+      const parentMatch = index > 0 ? matches[index - 1] : void 0;
+      let processedElement;
+      if (element) {
+        var _routerContext_loaderData, _routerContext_actionData;
+        const ElementComponent = element.type;
+        processedElement = /* @__PURE__ */ import_react.default.createElement(ElementComponent, {
+          loaderData: routerContext === null || routerContext === void 0 ? void 0 : (_routerContext_loaderData = routerContext.loaderData) === null || _routerContext_loaderData === void 0 ? void 0 : _routerContext_loaderData[match.route.id],
+          actionData: routerContext === null || routerContext === void 0 ? void 0 : (_routerContext_actionData = routerContext.actionData) === null || _routerContext_actionData === void 0 ? void 0 : _routerContext_actionData[match.route.id],
+          params: match.params,
+          matches: routerContext.matches.map((m) => {
+            var _routerContext_loaderData2;
+            const { route, pathname, params } = m;
+            return {
+              id: route.id,
+              pathname,
+              params,
+              data: routerContext === null || routerContext === void 0 ? void 0 : (_routerContext_loaderData2 = routerContext.loaderData) === null || _routerContext_loaderData2 === void 0 ? void 0 : _routerContext_loaderData2[route.id],
+              handle: route.handle
+            };
+          })
+        });
+      }
+      return {
+        element: processedElement,
+        errorElement: match.route.errorElement,
+        handle: match.route.handle,
+        hasAction: !!match.route.action,
+        hasErrorBoundary: !!match.route.hasErrorBoundary,
+        hasLoader: !!match.route.loader,
+        hasClientLoader: !!match.route.hasClientLoader,
+        id: match.route.id,
+        index: match.route.index,
+        params: match.params,
+        parentId: (parentMatch === null || parentMatch === void 0 ? void 0 : parentMatch.route.id) || match.route.parentId,
+        path: match.route.path,
+        pathname: match.pathname,
+        pathnameBase: match.pathnameBase
+      };
+    })
+  };
+};
+const handleRSCRedirect = (headers, basename, status) => {
+  const newHeaders = new Headers(headers);
+  let redirectUrl = headers.get("Location");
+  if (basename !== "/") {
+    redirectUrl = redirectUrl.replace(basename, "");
+  }
+  newHeaders.set("X-Modernjs-Redirect", redirectUrl);
+  newHeaders.set("X-Modernjs-BaseUrl", basename);
+  newHeaders.delete("Location");
+  return new Response(null, {
+    status,
+    headers: newHeaders
+  });
+};
+const prepareRSCRoutes = async (routes) => {
+  const isLazyComponent = (component) => {
+    return component && typeof component === "object" && component._init !== void 0 && component._payload !== void 0;
+  };
+  const processRoutes = async (routesList) => {
+    await Promise.all(routesList.map(async (route) => {
+      if ("lazyImport" in route && isLazyComponent(route.component)) {
+        route.component = (await route.lazyImport()).default;
+      }
+      if (route.children && Array.isArray(route.children)) {
+        await processRoutes(route.children);
+      }
+    }));
+  };
+  await processRoutes(routes);
+};
+const mergeRoutes = (routes, originalRoutes) => {
+  if (!originalRoutes || !Array.isArray(originalRoutes)) {
+    return routes;
+  }
+  const routesMap = /* @__PURE__ */ new Map();
+  const buildRoutesMap = (routesList) => {
+    routesList.forEach((route) => {
+      if (route.id) {
+        routesMap.set(route.id, route);
+      }
+      if ("children" in route && route.children && Array.isArray(route.children)) {
+        buildRoutesMap(route.children);
+      }
+    });
+  };
+  buildRoutesMap(routes);
+  const mergeRoutesRecursive = (origRoutes) => {
+    return origRoutes.map((origRoute) => {
+      if (origRoute.id && routesMap.has(origRoute.id)) {
+        const matchedRoute = routesMap.get(origRoute.id);
+        const result = {
+          loader: origRoute.hasClientLoader ? origRoute.loader : void 0,
+          ...matchedRoute
+        };
+        if (origRoute.children && Array.isArray(origRoute.children)) {
+          result.children = mergeRoutesRecursive(origRoute.children);
+        }
+        return result;
+      }
+      return origRoute;
+    });
+  };
+  return mergeRoutesRecursive(originalRoutes);
+};
+const findRouteInTree = (routes, routeId) => {
+  for (const route of routes) {
+    if (route.id === routeId) {
+      return route;
+    }
+    if (route.children && Array.isArray(route.children)) {
+      const found = findRouteInTree(route.children, routeId);
+      if (found) {
+        return found;
+      }
+    }
+  }
+  return null;
+};
+const createClientRouterFromPayload = (payload, originalRoutes, basename = "") => {
+  const processedRoutes = payload.routes.reduceRight((previous, route) => {
+    if (previous.length > 0) {
+      return [
+        {
+          ...route,
+          children: previous
+        }
+      ];
+    }
+    return [
+      route
+    ];
+  }, []);
+  const mergedRoutes = mergeRoutes(processedRoutes, originalRoutes);
+  const router = (0, import_router2.createBrowserRouter)(mergedRoutes, {
+    //@ts-ignore
+    hydrationData: payload,
+    basename,
+    dataStrategy: async (context) => {
+      const { request, matches } = context;
+      const results = {};
+      const clientMatches = matches.filter((match) => match.route.hasClientLoader);
+      const fetchPromise = fetch(request.url, {
+        headers: {
+          "x-rsc-tree": "true"
+        }
+      });
+      const clientLoadersPromise = clientMatches.length > 0 ? Promise.all(clientMatches.map(async (clientMatch) => {
+        const foundRoute = findRouteInTree(originalRoutes, clientMatch.route.id);
+        clientMatch.route.loader = foundRoute === null || foundRoute === void 0 ? void 0 : foundRoute.loader;
+        const res2 = await clientMatch.resolve();
+        return {
+          routeId: clientMatch.route.id,
+          result: res2
+        };
+      })) : Promise.resolve([]);
+      const res = await fetchPromise;
+      const redirectLocation = res.headers.get("X-Modernjs-Redirect");
+      if (redirectLocation) {
+        matches.forEach((match) => {
+          const routeId = match.route.id;
+          if (routeId) {
+            results[routeId] = {
+              type: "redirect",
+              result: (0, import_router2.redirect)(redirectLocation)
+            };
+          }
+        });
+        return results;
+      }
+      const [clientLoaderResults] = await Promise.all([
+        clientLoadersPromise
+      ]);
+      clientLoaderResults.forEach(({ routeId, result }) => {
+        results[routeId] = result;
+      });
+      const payload2 = await (0, import_client.createFromReadableStream)(res.body);
+      if (typeof payload2.type === "undefined" || payload2.type !== "render") {
+        throw new Error("Unexpected payload type");
+      }
+      matches.forEach((match) => {
+        var _payload_loaderData;
+        const routeId = match.route.id;
+        const matchedRoute = payload2.routes.find((route) => route.id === routeId);
+        if (matchedRoute) {
+          router.patchRoutes(matchedRoute.parentId, [
+            matchedRoute
+          ], true);
+        }
+        if ((_payload_loaderData = payload2.loaderData) === null || _payload_loaderData === void 0 ? void 0 : _payload_loaderData[routeId]) {
+          results[routeId] = {
+            type: "data",
+            result: payload2.loaderData[routeId]
+          };
+        }
+      });
+      return results;
+    }
+  });
+  return router;
+};
+const createRSCStaticRouterComponent = (payload, basename) => {
+  const routerContext = {
+    actionData: payload.actionData,
+    actionHeaders: {},
+    activeDeferreds: {},
+    basename: basename || "",
+    errors: payload.errors,
+    loaderData: payload.loaderData,
+    loaderHeaders: {},
+    location: payload.location,
+    statusCode: 200,
+    matches: payload.routes.map((match) => ({
+      params: match.params,
+      pathname: match.pathname,
+      pathnameBase: match.pathnameBase,
+      route: {
+        id: match.id,
+        action: match.hasAction || !!match.clientAction,
+        handle: match.handle,
+        hasErrorBoundary: match.hasErrorBoundary,
+        loader: match.hasLoader || !!match.clientLoader,
+        index: match.index,
+        path: match.path,
+        shouldRevalidate: match.shouldRevalidate
+      }
+    }))
+  };
+  const processedRoutes = payload.routes.reduceRight((previous, route) => {
+    if (previous.length > 0) {
+      return [
+        {
+          ...route,
+          children: previous
+        }
+      ];
+    }
+    return [
+      route
+    ];
+  }, []);
+  const router = (0, import_router.createStaticRouter)(processedRoutes, routerContext);
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_router.StaticRouterProvider, {
+    context: routerContext,
+    router,
+    hydrate: false
+  });
+};
+const RSCStaticRouter = ({ basename }) => {
+  const payload = safeUse(safeUse(import_client.ElementsContext));
+  if (!payload || payload.type !== "render") {
+    return null;
+  }
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_jsx_runtime.Fragment, {
+    children: createRSCStaticRouterComponent(payload, basename)
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RSCStaticRouter,
+  createClientRouterFromPayload,
+  createServerPayload,
+  handleRSCRedirect,
+  prepareRSCRoutes
+});

package/dist/cjs/router/runtime/utils.js

@@ -28,9 +28,11 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var utils_exports = {};
 __export(utils_exports, {
+  createRouteObjectsFromConfig: () => createRouteObjectsFromConfig,
   deserializeErrors: () => deserializeErrors,
   getLocation: () => getLocation,
   getRouteComponents: () => getRouteComponents,
+  getRouteObjects: () => getRouteObjects,
   renderRoutes: () => renderRoutes,
   serializeErrors: () => serializeErrors,
   standardSlash: () => standardSlash,
@@ -41,6 +43,7 @@ var import_jsx_runtime = require("react/jsx-runtime");
 var import_browser = require("@modern-js/runtime-utils/browser");
 var import_remix_router = require("@modern-js/runtime-utils/remix-router");
 var import_router = require("@modern-js/runtime-utils/router");
+var import_react = __toESM(require("react"));
 var import_DefaultNotFound = require("./DefaultNotFound");
 var import_DeferredDataScripts = __toESM(require("./DeferredDataScripts"));
 function getRouteComponents(routes, { globalApp, ssrMode, props }) {
@@ -80,6 +83,76 @@ function getRouteComponents(routes, { globalApp, ssrMode, props }) {
   }, "*"));
   return routeElements;
 }
+function getRouteObjects(routes, { globalApp, ssrMode, props }) {
+  const createLayoutElement = (Component) => {
+    const GlobalLayout = globalApp;
+    if (!GlobalLayout) {
+      return Component;
+    }
+    const LayoutWrapper = (props2) => {
+      const LayoutComponent = GlobalLayout;
+      return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(LayoutComponent, {
+        Component,
+        ...props2
+      });
+    };
+    return LayoutWrapper;
+  };
+  const routeObjects = [];
+  for (const route of routes) {
+    if (route.type === "nested") {
+      const nestedRouteObject = {
+        path: route.path,
+        id: route.id,
+        loader: route.loader,
+        action: route.action,
+        hasErrorBoundary: route.hasErrorBoundary,
+        shouldRevalidate: route.shouldRevalidate,
+        handle: route.handle,
+        index: route.index,
+        hasClientLoader: !!route.clientData,
+        Component: route.component ? route.component : void 0,
+        errorElement: route.error ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)(route.error, {}) : void 0,
+        children: route.children ? route.children.map((child) => getRouteObjects([
+          child
+        ], {
+          globalApp,
+          ssrMode,
+          props
+        })[0]) : void 0
+      };
+      routeObjects.push(nestedRouteObject);
+    } else {
+      if (typeof route.component === "function" || typeof route.component === "object") {
+        const LayoutComponent = createLayoutElement(route.component);
+        const routeObject = {
+          path: route.path,
+          element: /* @__PURE__ */ import_react.default.createElement(LayoutComponent)
+        };
+        routeObjects.push(routeObject);
+      }
+    }
+  }
+  routeObjects.push({
+    path: "*",
+    element: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_DefaultNotFound.DefaultNotFound, {})
+  });
+  return routeObjects;
+}
+function createRouteObjectsFromConfig({ routesConfig, props, ssrMode }) {
+  if (!routesConfig) {
+    return null;
+  }
+  const { routes, globalApp } = routesConfig;
+  if (!routes) {
+    return null;
+  }
+  return getRouteObjects(routes, {
+    globalApp,
+    ssrMode,
+    props
+  });
+}
 function renderRoutes({ routesConfig, props, ssrMode }) {
   if (!routesConfig) {
     return null;
@@ -97,7 +170,7 @@ function renderRoutes({ routesConfig, props, ssrMode }) {
 }
 function getLocation(serverContext) {
   var _url_replace;
-  const { pathname, url } = (serverContext === null || serverContext === void 0 ? void 0 : serverContext.request) || {};
+  const { pathname = "", url = "" } = (serverContext === null || serverContext === void 0 ? void 0 : serverContext.request) || {};
   const cleanUrl = url === null || url === void 0 ? void 0 : (_url_replace = url.replace("http://", "")) === null || _url_replace === void 0 ? void 0 : _url_replace.replace("https://", "");
   const index = (cleanUrl || "").indexOf(pathname);
   if (index === -1) {
@@ -171,9 +244,11 @@ function deserializeErrors(errors) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  createRouteObjectsFromConfig,
   deserializeErrors,
   getLocation,
   getRouteComponents,
+  getRouteObjects,
   renderRoutes,
   serializeErrors,
   standardSlash,

package/dist/cjs/rsc/client.js

@@ -3,6 +3,10 @@ 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))
@@ -14,9 +18,16 @@ var __copyProps = (to, from, except, desc) => {
 var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var client_exports = {};
+__export(client_exports, {
+  isRedirectResponse: () => isRedirectResponse
+});
 module.exports = __toCommonJS(client_exports);
 __reExport(client_exports, require("@modern-js/render/client"), module.exports);
+const isRedirectResponse = (res) => {
+  return res.headers.get("X-Modernjs-Redirect") != null;
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  isRedirectResponse,
   ...require("@modern-js/render/client")
 });

package/dist/cjs/rsc/server.js

@@ -3,6 +3,10 @@ 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))
@@ -14,9 +18,45 @@ var __copyProps = (to, from, except, desc) => {
 var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var server_exports = {};
+__export(server_exports, {
+  processRSCStream: () => processRSCStream
+});
 module.exports = __toCommonJS(server_exports);
 __reExport(server_exports, require("@modern-js/render/rsc"), module.exports);
+async function processRSCStream(rscStream, controller, encoder) {
+  try {
+    const reader = rscStream.getReader();
+    const decoder = new TextDecoder("utf-8", {
+      fatal: true
+    });
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done)
+        break;
+      try {
+        const chunk = JSON.stringify(decoder.decode(value, {
+          stream: true
+        }));
+        const scriptTag = `<script>(self.__FLIGHT_DATA||=[]).push(${chunk})</script>`;
+        controller.enqueue(encoder.encode(scriptTag));
+      } catch (err) {
+        const base64 = JSON.stringify(btoa(String.fromCodePoint(...value)));
+        const scriptTag = `<script>(self.__FLIGHT_DATA||=[]).push(Uint8Array.from(atob(${base64}), m => m.codePointAt(0)))</script>`;
+        controller.enqueue(encoder.encode(scriptTag));
+      }
+    }
+    const remaining = decoder.decode();
+    if (remaining.length) {
+      const scriptTag = `<script>(self.__FLIGHT_DATA||=[]).push(${JSON.stringify(remaining)})</script>`;
+      controller.enqueue(encoder.encode(scriptTag));
+    }
+    controller.close();
+  } catch (error) {
+    controller.error(error);
+  }
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  processRSCStream,
   ...require("@modern-js/render/rsc")
 });