@modern-js/render 3.11.0 → 3.11.2

package/dist/esm/client/callServer.js

@@ -1,83 +1,103 @@
-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 { 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/client/index.js

@@ -1,44 +1,28 @@
-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";
-import { callServer } from "./callServer";
-import { createFromFetch } from "react-server-dom-rspack/client.browser";
-const ResetRootContext = /* @__PURE__ */ createContext(void 0);
+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.js";
+export { callServer } from "./callServer.js";
+export { ElementsContext, RSCServerSlot, ResetRootContext, RscClientRoot, ServerElementsProvider };

package/dist/esm/rsc-html-stream/client.js

@@ -1,32 +1,22 @@
 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 };

package/dist/esm/rsc-html-stream/server.js

@@ -1,131 +1,107 @@
 const encoder = new TextEncoder();
 const closingTagsPattern = /<\/body>\s*<\/html>\s*$/i;
 function injectRSCPayload(rscStream, { injectClosingTags = true }) {
-  const decoder = new TextDecoder();
-  let resolveFlightDataPromise;
-  const flightDataPromise = new Promise((resolve) => resolveFlightDataPromise = resolve);
-  let startedRSC = false;
-  const buffered = [];
-  let timeout = null;
-  function flushBufferedChunks(controller) {
-    for (const chunk of buffered) {
-      let buf = decoder.decode(chunk);
-      if (closingTagsPattern.test(buf)) {
-        buf = buf.replace(closingTagsPattern, "");
-      }
-      controller.enqueue(encoder.encode(buf));
-    }
-    buffered.length = 0;
-    timeout = null;
-  }
-  return new TransformStream({
-    transform(chunk, controller) {
-      buffered.push(chunk);
-      if (timeout) {
-        return;
-      }
-      timeout = setTimeout(async () => {
-        flushBufferedChunks(controller);
-        if (!startedRSC) {
-          startedRSC = true;
-          writeRSCStream(rscStream, controller).catch((err) => controller.error(err)).then(() => resolveFlightDataPromise());
+    const decoder = new TextDecoder();
+    let resolveFlightDataPromise;
+    const flightDataPromise = new Promise((resolve)=>resolveFlightDataPromise = resolve);
+    let startedRSC = false;
+    const buffered = [];
+    let timeout = null;
+    function flushBufferedChunks(controller) {
+        for (const chunk of buffered){
+            let buf = decoder.decode(chunk);
+            if (closingTagsPattern.test(buf)) buf = buf.replace(closingTagsPattern, '');
+            controller.enqueue(encoder.encode(buf));
         }
-      }, 0);
-    },
-    async flush(controller) {
-      await flightDataPromise;
-      if (timeout) {
-        clearTimeout(timeout);
-        flushBufferedChunks(controller);
-      }
-      if (injectClosingTags) {
-        controller.enqueue(encoder.encode("</body></html>"));
-      }
+        buffered.length = 0;
+        timeout = null;
     }
-  });
+    return new TransformStream({
+        transform (chunk, controller) {
+            buffered.push(chunk);
+            if (timeout) return;
+            timeout = setTimeout(async ()=>{
+                flushBufferedChunks(controller);
+                if (!startedRSC) {
+                    startedRSC = true;
+                    writeRSCStream(rscStream, controller).catch((err)=>controller.error(err)).then(()=>resolveFlightDataPromise());
+                }
+            }, 0);
+        },
+        async flush (controller) {
+            await flightDataPromise;
+            if (timeout) {
+                clearTimeout(timeout);
+                flushBufferedChunks(controller);
+            }
+            if (injectClosingTags) controller.enqueue(encoder.encode('</body></html>'));
+        }
+    });
 }
 async function writeRSCStream(rscStream, controller) {
-  const decoder = new TextDecoder("utf-8", {
-    fatal: true
-  });
-  for await (const chunk of rscStream) {
-    try {
-      writeChunk(JSON.stringify(decoder.decode(chunk, {
-        stream: true
-      })), controller);
+    const decoder = new TextDecoder('utf-8', {
+        fatal: true
+    });
+    for await (const chunk of rscStream)try {
+        writeChunk(JSON.stringify(decoder.decode(chunk, {
+            stream: true
+        })), controller);
     } catch (err) {
-      const base64 = JSON.stringify(btoa(String.fromCodePoint(...chunk)));
-      writeChunk(`Uint8Array.from(atob(${base64}), m => m.codePointAt(0))`, controller);
+        const base64 = JSON.stringify(btoa(String.fromCodePoint(...chunk)));
+        writeChunk(`Uint8Array.from(atob(${base64}), m => m.codePointAt(0))`, controller);
     }
-  }
-  const remaining = decoder.decode();
-  if (remaining.length) {
-    writeChunk(JSON.stringify(remaining), controller);
-  }
+    const remaining = decoder.decode();
+    if (remaining.length) writeChunk(JSON.stringify(remaining), controller);
 }
 function writeChunk(chunk, controller) {
-  controller.enqueue(encoder.encode(`<script>${escapeScript(`(self.__FLIGHT_DATA||=[]).push(${chunk})`)}</script>`));
+    controller.enqueue(encoder.encode(`<script>${escapeScript(`(self.__FLIGHT_DATA||=[]).push(${chunk})`)}</script>`));
 }
 function escapeScript(script) {
-  return script.replace(/<!--/g, "<\\!--").replace(/<\/(script)/gi, "</\\$1");
+    return script.replace(/<!--/g, '<\\!--').replace(/<\/(script)/gi, '</\\$1');
 }
 function injectCSS(cssFiles, { injectClosingTags = true } = {}) {
-  if (cssFiles.length === 0) {
-    return new TransformStream({
-      transform(chunk, controller) {
-        controller.enqueue(chunk);
-      },
-      flush(controller) {
-        if (injectClosingTags) {
-          controller.enqueue(encoder.encode("</body></html>"));
+    if (0 === cssFiles.length) return new TransformStream({
+        transform (chunk, controller) {
+            controller.enqueue(chunk);
+        },
+        flush (controller) {
+            if (injectClosingTags) controller.enqueue(encoder.encode('</body></html>'));
         }
-      }
     });
-  }
-  const decoder = new TextDecoder();
-  const headTrailer = "</head>";
-  const bodyTrailer = "</body>";
-  const buffered = [];
-  let timeout = null;
-  let cssInjected = false;
-  const cssLinks = cssFiles.map((css) => `<link href="${css}" rel="stylesheet" />`).join("");
-  function flushBufferedChunks(controller) {
-    for (const chunk of buffered) {
-      let buf = decoder.decode(chunk);
-      if (!cssInjected && buf.includes(headTrailer)) {
-        buf = buf.replace(headTrailer, `${cssLinks}${headTrailer}`);
-        cssInjected = true;
-      }
-      controller.enqueue(encoder.encode(buf));
-    }
-    buffered.length = 0;
-    timeout = null;
-  }
-  return new TransformStream({
-    transform(chunk, controller) {
-      buffered.push(chunk);
-      if (timeout) {
-        return;
-      }
-      timeout = setTimeout(() => {
-        flushBufferedChunks(controller);
-      }, 0);
-    },
-    async flush(controller) {
-      if (timeout) {
-        clearTimeout(timeout);
-        flushBufferedChunks(controller);
-      }
-      if (!cssInjected) {
-        controller.enqueue(encoder.encode(cssLinks));
-      }
-      if (injectClosingTags) {
-        controller.enqueue(encoder.encode("</body></html>"));
-      }
+    const decoder = new TextDecoder();
+    const headTrailer = '</head>';
+    const buffered = [];
+    let timeout = null;
+    let cssInjected = false;
+    const cssLinks = cssFiles.map((css)=>`<link href="${css}" rel="stylesheet" />`).join('');
+    function flushBufferedChunks(controller) {
+        for (const chunk of buffered){
+            let buf = decoder.decode(chunk);
+            if (!cssInjected && buf.includes(headTrailer)) {
+                buf = buf.replace(headTrailer, `${cssLinks}${headTrailer}`);
+                cssInjected = true;
+            }
+            controller.enqueue(encoder.encode(buf));
+        }
+        buffered.length = 0;
+        timeout = null;
     }
-  });
+    return new TransformStream({
+        transform (chunk, controller) {
+            buffered.push(chunk);
+            if (timeout) return;
+            timeout = setTimeout(()=>{
+                flushBufferedChunks(controller);
+            }, 0);
+        },
+        async flush (controller) {
+            if (timeout) {
+                clearTimeout(timeout);
+                flushBufferedChunks(controller);
+            }
+            if (!cssInjected) controller.enqueue(encoder.encode(cssLinks));
+            if (injectClosingTags) controller.enqueue(encoder.encode('</body></html>'));
+        }
+    });
 }
-export {
-  injectCSS,
-  injectRSCPayload
-};
+export { injectCSS, injectRSCPayload };

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

@@ -1,30 +1,28 @@
-import { injectCSS, injectRSCPayload } from "../../rsc-html-stream/server";
-import { renderRsc } from "./rsc";
+import { injectCSS, injectRSCPayload } from "../../rsc-html-stream/server.js";
+import { renderRsc } from "./rsc.js";
 async function renderCSRWithRSC(options) {
-  const entryCssFiles = __rspack_rsc_manifest__ === null || __rspack_rsc_manifest__ === void 0 ? void 0 : __rspack_rsc_manifest__.entryCssFiles;
-  const cssFiles = entryCssFiles ? Object.values(entryCssFiles).flat() : [];
-  const rscPayloadStream = renderRsc({
-    element: options.rscRoot
-  });
-  const htmlStream = new ReadableStream({
-    start(controller) {
-      const encoder = new TextEncoder();
-      controller.enqueue(encoder.encode(options.html));
-      controller.close();
-    }
-  });
-  const stream = htmlStream.pipeThrough(injectCSS(cssFiles, {
-    injectClosingTags: false
-  })).pipeThrough(injectRSCPayload(rscPayloadStream, {
-    injectClosingTags: true
-  }));
-  return new Response(stream, {
-    status: 200,
-    headers: new Headers({
-      "content-type": "text/html; charset=UTF-8"
-    })
-  });
+    const entryCssFiles = __rspack_rsc_manifest__?.entryCssFiles;
+    const cssFiles = entryCssFiles ? Object.values(entryCssFiles).flat() : [];
+    const rscPayloadStream = renderRsc({
+        element: options.rscRoot
+    });
+    const htmlStream = new ReadableStream({
+        start (controller) {
+            const encoder = new TextEncoder();
+            controller.enqueue(encoder.encode(options.html));
+            controller.close();
+        }
+    });
+    const stream = htmlStream.pipeThrough(injectCSS(cssFiles, {
+        injectClosingTags: false
+    })).pipeThrough(injectRSCPayload(rscPayloadStream, {
+        injectClosingTags: true
+    }));
+    return new Response(stream, {
+        status: 200,
+        headers: new Headers({
+            'content-type': 'text/html; charset=UTF-8'
+        })
+    });
 }
-export {
-  renderCSRWithRSC
-};
+export { renderCSRWithRSC };

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

@@ -1,2 +1,2 @@
-export * from "./rsc";
-export * from "./csr";
+export * from "./rsc.js";
+export * from "./csr.js";