@modern-js/render 3.10.4 → 3.11.1

package/dist/esm/server/rsc/rsc.js

@@ -1,69 +1,56 @@
-import { renderToReadableStream } from "react-server-dom-rspack/server.node";
-import { loadServerAction, renderToReadableStream as renderToReadableStream2 } from "react-server-dom-rspack/server.node";
-import { decodeReply } from "react-server-dom-rspack/server.node";
-import { createFromReadableStream } from "react-server-dom-rspack/client.node";
-import { registerClientReference, registerServerReference } from "react-server-dom-rspack/server.node";
-const renderRsc = (options) => {
-  const readable = renderToReadableStream2(options.element);
-  return readable;
+import { decodeReply, loadServerAction, registerClientReference, registerServerReference, renderToReadableStream } from "react-server-dom-rspack/server.node";
+const renderRsc = (options)=>{
+    const readable = renderToReadableStream(options.element);
+    return readable;
 };
-const handleAction = async (req) => {
-  try {
-    const serverReference = req.headers.get("x-rsc-action");
-    if (!serverReference) {
-      return new Response("Cannot find server reference", {
-        status: 404
-      });
-    }
-    const action = loadServerAction(serverReference);
-    if (typeof action !== "function") {
-      console.error("[RSC] Invalid action: server reference is not a function, serverReference:", serverReference);
-      return new Response("Invalid action", {
-        status: 400
-      });
-    }
-    const contentType = req.headers.get("content-type");
-    let args;
+const handleAction = async (req)=>{
     try {
-      if (contentType === null || contentType === void 0 ? void 0 : contentType.includes("multipart/form-data")) {
-        const formData = await req.formData();
-        args = await decodeReply(formData);
-      } else {
-        const text = await req.text();
-        args = await decodeReply(text);
-      }
+        const serverReference = req.headers.get('x-rsc-action');
+        if (!serverReference) return new Response('Cannot find server reference', {
+            status: 404
+        });
+        const action = loadServerAction(serverReference);
+        if ('function' != typeof action) {
+            console.error('[RSC] Invalid action: server reference is not a function, serverReference:', serverReference);
+            return new Response('Invalid action', {
+                status: 400
+            });
+        }
+        const contentType = req.headers.get('content-type');
+        let args;
+        try {
+            if (contentType?.includes('multipart/form-data')) {
+                const formData = await req.formData();
+                args = await decodeReply(formData);
+            } else {
+                const text = await req.text();
+                args = await decodeReply(text);
+            }
+        } catch (error) {
+            console.error('[RSC] Failed to decode request arguments, error:', error instanceof Error ? error.message : String(error), 'contentType:', contentType || 'unknown');
+            return new Response('Failed to decode request arguments', {
+                status: 400
+            });
+        }
+        const result = await Promise.resolve(action.apply(null, args));
+        const stream = renderRsc({
+            element: result
+        });
+        const response = new Response(stream, {
+            status: 200,
+            headers: {
+                'Content-Type': 'text/html'
+            }
+        });
+        return response;
     } catch (error) {
-      console.error("[RSC] Failed to decode request arguments, error:", error instanceof Error ? error.message : String(error), "contentType:", contentType || "unknown");
-      return new Response("Failed to decode request arguments", {
-        status: 400
-      });
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        const errorStack = error instanceof Error ? error.stack : void 0;
+        console.error('[RSC] Error handling server action, error:', errorMessage, errorStack ? `\n${errorStack}` : '');
+        return new Response('Internal server error', {
+            status: 500
+        });
     }
-    const result = await Promise.resolve(action.apply(null, args));
-    const stream = renderRsc({
-      element: result
-    });
-    const response = new Response(stream, {
-      status: 200,
-      headers: {
-        "Content-Type": "text/html"
-      }
-    });
-    return response;
-  } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : String(error);
-    const errorStack = error instanceof Error ? error.stack : void 0;
-    console.error("[RSC] Error handling server action, error:", errorMessage, errorStack ? `
-${errorStack}` : "");
-    return new Response("Internal server error", {
-      status: 500
-    });
-  }
-};
-export {
-  createFromReadableStream,
-  handleAction,
-  registerClientReference,
-  registerServerReference,
-  renderRsc,
-  renderToReadableStream
 };
+export { createFromReadableStream } from "react-server-dom-rspack/client.node";
+export { handleAction, registerClientReference, registerServerReference, renderRsc, renderToReadableStream };

package/dist/esm/server/ssr/index.js

@@ -1 +1 @@
-export * from "./ssr";
+export * from "./ssr.js";

package/dist/esm/server/ssr/ssr.js

@@ -1,76 +1,63 @@
-import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
 import { SSR_HYDRATION_ID_PREFIX } from "@modern-js/utils/universal/constants";
 import { renderToReadableStream } from "react-dom/server.edge";
-import { ServerElementsProvider } from "../../client/index";
+import { ServerElementsProvider } from "../../client/index.js";
 function CSSLinks({ cssFiles }) {
-  if (cssFiles.length === 0) {
-    return null;
-  }
-  return /* @__PURE__ */ _jsx(_Fragment, {
-    children: cssFiles.map((css) => /* @__PURE__ */ _jsx("link", {
-      href: css,
-      rel: "stylesheet"
-    }, css))
-  });
+    if (0 === cssFiles.length) return null;
+    return /*#__PURE__*/ jsx(Fragment, {
+        children: cssFiles.map((css)=>/*#__PURE__*/ jsx("link", {
+                href: css,
+                rel: "stylesheet"
+            }, css))
+    });
 }
 function wrapStream(stream, originalStream) {
-  const wrappedStream = Object.create(stream);
-  for (const prop of Object.keys(originalStream)) {
-    if (!(prop in wrappedStream)) {
-      wrappedStream[prop] = originalStream[prop];
-    }
-  }
-  return wrappedStream;
+    const wrappedStream = Object.create(stream);
+    for (const prop of Object.keys(originalStream))if (!(prop in wrappedStream)) wrappedStream[prop] = originalStream[prop];
+    return wrappedStream;
 }
-const renderSSRStream = async (children, options) => {
-  var __rspack_rsc_manifest__1, __rspack_rsc_manifest__2, __rspack_rsc_manifest__3;
-  const { rscRoot, routes } = options;
-  const clientManifest = (__rspack_rsc_manifest__1 = __rspack_rsc_manifest__) === null || __rspack_rsc_manifest__1 === void 0 ? void 0 : __rspack_rsc_manifest__1.clientManifest;
-  const serverConsumerModuleMap = (__rspack_rsc_manifest__2 = __rspack_rsc_manifest__) === null || __rspack_rsc_manifest__2 === void 0 ? void 0 : __rspack_rsc_manifest__2.serverConsumerModuleMap;
-  const entryCssFiles = (__rspack_rsc_manifest__3 = __rspack_rsc_manifest__) === null || __rspack_rsc_manifest__3 === void 0 ? void 0 : __rspack_rsc_manifest__3.entryCssFiles;
-  const hasRoutes = Boolean(routes && routes.length > 0);
-  if (!clientManifest || !serverConsumerModuleMap) {
-    return renderToReadableStream(children, {
-      ...options,
-      identifierPrefix: SSR_HYDRATION_ID_PREFIX
-    });
-  }
-  try {
-    const [{ renderRsc }, { createFromReadableStream }, { injectRSCPayload }] = await Promise.all([
-      import("../rsc/index"),
-      import("react-server-dom-rspack/client.edge"),
-      import("../../rsc-html-stream/server")
-    ]);
-    const rscStream = await renderRsc({
-      element: rscRoot || children
+const renderSSRStream = async (children, options)=>{
+    const { rscRoot, routes } = options;
+    const clientManifest = __rspack_rsc_manifest__?.clientManifest;
+    const serverConsumerModuleMap = __rspack_rsc_manifest__?.serverConsumerModuleMap;
+    const entryCssFiles = __rspack_rsc_manifest__?.entryCssFiles;
+    const hasRoutes = Boolean(routes && routes.length > 0);
+    if (!clientManifest || !serverConsumerModuleMap) return renderToReadableStream(children, {
+        ...options,
+        identifierPrefix: SSR_HYDRATION_ID_PREFIX
     });
-    const [rscElementStream, rscPayloadStream] = rscStream.tee();
-    const elements = createFromReadableStream(rscElementStream);
-    let cssFiles = [];
-    if (!hasRoutes && entryCssFiles) {
-      cssFiles = Object.values(entryCssFiles).flat();
+    try {
+        const [{ renderRsc }, { createFromReadableStream }, { injectRSCPayload }] = await Promise.all([
+            import("../rsc/index.js"),
+            import("react-server-dom-rspack/client.edge"),
+            import("../../rsc-html-stream/server.js")
+        ]);
+        const rscStream = await renderRsc({
+            element: rscRoot || children
+        });
+        const [rscElementStream, rscPayloadStream] = rscStream.tee();
+        const elements = createFromReadableStream(rscElementStream);
+        let cssFiles = [];
+        if (!hasRoutes && entryCssFiles) cssFiles = Object.values(entryCssFiles).flat();
+        const htmlStream = await renderToReadableStream(/*#__PURE__*/ jsxs(ServerElementsProvider, {
+            elements: elements,
+            children: [
+                /*#__PURE__*/ jsx(CSSLinks, {
+                    cssFiles: cssFiles
+                }),
+                children
+            ]
+        }), {
+            ...options,
+            identifierPrefix: SSR_HYDRATION_ID_PREFIX
+        });
+        const stream = htmlStream.pipeThrough(injectRSCPayload(rscPayloadStream, {
+            injectClosingTags: true
+        }));
+        return wrapStream(stream, htmlStream);
+    } catch (error) {
+        console.error(error);
+        throw error;
     }
-    const htmlStream = await renderToReadableStream(/* @__PURE__ */ _jsxs(ServerElementsProvider, {
-      elements,
-      children: [
-        /* @__PURE__ */ _jsx(CSSLinks, {
-          cssFiles
-        }),
-        children
-      ]
-    }), {
-      ...options,
-      identifierPrefix: SSR_HYDRATION_ID_PREFIX
-    });
-    const stream = htmlStream.pipeThrough(injectRSCPayload(rscPayloadStream, {
-      injectClosingTags: true
-    }));
-    return wrapStream(stream, htmlStream);
-  } catch (error) {
-    console.error(error);
-    throw error;
-  }
-};
-export {
-  renderSSRStream
 };
+export { renderSSRStream };

package/dist/esm-node/client/callServer.mjs

@@ -1,83 +1,104 @@
-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 "node:module";
 import { createFromFetch, encodeReply } from "react-server-dom-rspack/client.browser";
-var _statusCode = /* @__PURE__ */ new WeakMap(), _url = /* @__PURE__ */ new WeakMap(), _details = /* @__PURE__ */ new WeakMap();
+function _check_private_redeclaration(obj, privateCollection) {
+    if (privateCollection.has(obj)) throw new TypeError("Cannot initialize the same private elements twice on an object");
+}
+function _class_apply_descriptor_get(receiver, descriptor) {
+    if (descriptor.get) return descriptor.get.call(receiver);
+    return descriptor.value;
+}
+function _class_apply_descriptor_set(receiver, descriptor, value) {
+    if (descriptor.set) descriptor.set.call(receiver, value);
+    else {
+        if (!descriptor.writable) throw new TypeError("attempted to set read only private field");
+        descriptor.value = value;
+    }
+}
+function _class_extract_field_descriptor(receiver, privateMap, action) {
+    if (!privateMap.has(receiver)) throw new TypeError("attempted to " + action + " private field on non-instance");
+    return privateMap.get(receiver);
+}
+function _class_private_field_get(receiver, privateMap) {
+    var descriptor = _class_extract_field_descriptor(receiver, privateMap, "get");
+    return _class_apply_descriptor_get(receiver, descriptor);
+}
+function _class_private_field_init(obj, privateMap, value) {
+    _check_private_redeclaration(obj, privateMap);
+    privateMap.set(obj, value);
+}
+function _class_private_field_set(receiver, privateMap, value) {
+    var descriptor = _class_extract_field_descriptor(receiver, privateMap, "set");
+    _class_apply_descriptor_set(receiver, descriptor, value);
+    return value;
+}
+var _statusCode = /*#__PURE__*/ new WeakMap(), _url = /*#__PURE__*/ new WeakMap(), _details = /*#__PURE__*/ new WeakMap();
 class CallServerError extends Error {
-  get statusCode() {
-    return _class_private_field_get(this, _statusCode);
-  }
-  get url() {
-    return _class_private_field_get(this, _url);
-  }
-  get details() {
-    return {
-      ..._class_private_field_get(this, _details)
-    };
-  }
-  toJSON() {
-    return {
-      name: this.name,
-      message: this.message,
-      statusCode: _class_private_field_get(this, _statusCode),
-      url: _class_private_field_get(this, _url),
-      details: _class_private_field_get(this, _details)
-    };
-  }
-  constructor(message, statusCode, url = "", details = {}) {
-    const formattedMessage = `Call Server Action failed (${statusCode}): ${message}
-URL: ${url}`;
-    super(formattedMessage), _class_private_field_init(this, _statusCode, {
-      writable: true,
-      value: void 0
-    }), _class_private_field_init(this, _url, {
-      writable: true,
-      value: void 0
-    }), _class_private_field_init(this, _details, {
-      writable: true,
-      value: void 0
-    });
-    this.name = "CallServerError";
-    _class_private_field_set(this, _statusCode, statusCode);
-    _class_private_field_set(this, _url, url);
-    _class_private_field_set(this, _details, details);
-  }
+    get statusCode() {
+        return _class_private_field_get(this, _statusCode);
+    }
+    get url() {
+        return _class_private_field_get(this, _url);
+    }
+    get details() {
+        return {
+            ..._class_private_field_get(this, _details)
+        };
+    }
+    toJSON() {
+        return {
+            name: this.name,
+            message: this.message,
+            statusCode: _class_private_field_get(this, _statusCode),
+            url: _class_private_field_get(this, _url),
+            details: _class_private_field_get(this, _details)
+        };
+    }
+    constructor(message, statusCode, url = '', details = {}){
+        const formattedMessage = `Call Server Action failed (${statusCode}): ${message}\nURL: ${url}`;
+        super(formattedMessage), _class_private_field_init(this, _statusCode, {
+            writable: true,
+            value: void 0
+        }), _class_private_field_init(this, _url, {
+            writable: true,
+            value: void 0
+        }), _class_private_field_init(this, _details, {
+            writable: true,
+            value: void 0
+        });
+        this.name = 'CallServerError';
+        _class_private_field_set(this, _statusCode, statusCode);
+        _class_private_field_set(this, _url, url);
+        _class_private_field_set(this, _details, details);
+    }
 }
 async function requestCallServer(id, args) {
-  const entryName = window.__MODERN_JS_ENTRY_NAME;
-  const url = entryName === "main" || entryName === "index" ? "/" : `/${entryName}`;
-  try {
-    const response = await fetch(url, {
-      method: "POST",
-      headers: {
-        Accept: "text/x-component",
-        "x-rsc-action": id
-      },
-      body: await encodeReply(args)
-    });
-    if (!response.ok) {
-      throw new CallServerError(response.statusText, response.status, url, {
-        id,
-        args
-      });
-    }
-    return response;
-  } catch (error) {
-    if (error instanceof CallServerError) {
-      throw error;
+    const entryName = window.__MODERN_JS_ENTRY_NAME;
+    const url = 'main' === entryName || 'index' === entryName ? '/' : `/${entryName}`;
+    try {
+        const response = await fetch(url, {
+            method: 'POST',
+            headers: {
+                Accept: 'text/x-component',
+                'x-rsc-action': id
+            },
+            body: await encodeReply(args)
+        });
+        if (!response.ok) throw new CallServerError(response.statusText, response.status, url, {
+            id,
+            args
+        });
+        return response;
+    } catch (error) {
+        if (error instanceof CallServerError) throw error;
+        throw new CallServerError(error instanceof Error ? error.message : 'Unknown error', 1, url, {
+            id,
+            args
+        });
     }
-    throw new CallServerError(error instanceof Error ? error.message : "Unknown error", 1, url, {
-      id,
-      args
-    });
-  }
 }
 async function callServer(id, args) {
-  const response = requestCallServer(id, args);
-  const res = createFromFetch(response);
-  return res;
+    const response = requestCallServer(id, args);
+    const res = createFromFetch(response);
+    return res;
 }
-export {
-  callServer,
-  requestCallServer
-};
+export { callServer, requestCallServer };

package/dist/esm-node/client/index.mjs

@@ -1,44 +1,29 @@
-import { jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
-import React from "react";
-import { createContext, useState } from "react";
-import { createFromReadableStream, createServerReference, setServerCallback } from "react-server-dom-rspack/client.browser";
-import { rscStream } from "../rsc-html-stream/client.mjs";
-import { callServer } from "./callServer.mjs";
-import { createFromFetch } from "react-server-dom-rspack/client.browser";
-const ResetRootContext = /* @__PURE__ */ createContext(void 0);
+import "node:module";
+import { Fragment, jsx } from "react/jsx-runtime";
+import react, { createContext, useState } from "react";
+const ResetRootContext = /*#__PURE__*/ createContext(void 0);
 function RscClientRoot({ rscPayload }) {
-  const elements = React.use(rscPayload);
-  const [root, setRoot] = useState(elements);
-  return /* @__PURE__ */ _jsx(ResetRootContext.Provider, {
-    value: {
-      setRoot
-    },
-    children: root
-  });
+    const elements = react.use(rscPayload);
+    const [root, setRoot] = useState(elements);
+    return /*#__PURE__*/ jsx(ResetRootContext.Provider, {
+        value: {
+            setRoot
+        },
+        children: root
+    });
 }
-const ElementsContext = /* @__PURE__ */ createContext(null);
-const ServerElementsProvider = ({ elements, children }) => {
-  return /* @__PURE__ */ _jsx(_Fragment, {
-    children: /* @__PURE__ */ _jsx(ElementsContext.Provider, {
-      value: elements,
-      children
-    })
-  });
-};
-const RSCServerSlot = () => {
-  const elements = React.use(ElementsContext);
-  return elements;
-};
-export {
-  ElementsContext,
-  RSCServerSlot,
-  ResetRootContext,
-  RscClientRoot,
-  ServerElementsProvider,
-  callServer,
-  createFromFetch,
-  createFromReadableStream,
-  createServerReference,
-  rscStream,
-  setServerCallback
+const ElementsContext = /*#__PURE__*/ createContext(null);
+const ServerElementsProvider = ({ elements, children })=>/*#__PURE__*/ jsx(Fragment, {
+        children: /*#__PURE__*/ jsx(ElementsContext.Provider, {
+            value: elements,
+            children: children
+        })
+    });
+const RSCServerSlot = ()=>{
+    const elements = react.use(ElementsContext);
+    return elements;
 };
+export { createFromFetch, createFromReadableStream, createServerReference, setServerCallback } from "react-server-dom-rspack/client.browser";
+export { rscStream } from "../rsc-html-stream/client.mjs";
+export { callServer } from "./callServer.mjs";
+export { ElementsContext, RSCServerSlot, ResetRootContext, RscClientRoot, ServerElementsProvider };

package/dist/esm-node/rsc-html-stream/client.mjs

@@ -1,32 +1,23 @@
+import "node:module";
 const encoder = new TextEncoder();
 let streamController;
 const rscStream = new ReadableStream({
-  start(controller) {
-    if (typeof window === "undefined") {
-      return;
+    start (controller) {
+        if ("u" < typeof window) return;
+        const handleChunk = (chunk)=>{
+            if ('string' == typeof chunk) controller.enqueue(encoder.encode(chunk));
+            else controller.enqueue(chunk);
+        };
+        window.__FLIGHT_DATA = window.__FLIGHT_DATA || [];
+        window.__FLIGHT_DATA.forEach(handleChunk);
+        window.__FLIGHT_DATA.push = (chunk)=>{
+            handleChunk(chunk);
+        };
+        streamController = controller;
     }
-    const handleChunk = (chunk) => {
-      if (typeof chunk === "string") {
-        controller.enqueue(encoder.encode(chunk));
-      } else {
-        controller.enqueue(chunk);
-      }
-    };
-    window.__FLIGHT_DATA = window.__FLIGHT_DATA || [];
-    window.__FLIGHT_DATA.forEach(handleChunk);
-    window.__FLIGHT_DATA.push = (chunk) => {
-      handleChunk(chunk);
-    };
-    streamController = controller;
-  }
 });
-if (typeof document !== "undefined" && document.readyState === "loading") {
-  document.addEventListener("DOMContentLoaded", () => {
-    streamController === null || streamController === void 0 ? void 0 : streamController.close();
-  });
-} else {
-  streamController === null || streamController === void 0 ? void 0 : streamController.close();
-}
-export {
-  rscStream
-};
+if ("u" > typeof document && 'loading' === document.readyState) document.addEventListener('DOMContentLoaded', ()=>{
+    streamController?.close();
+});
+else streamController?.close();
+export { rscStream };