@modern-js/render 0.0.0-next-20250108080920

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021-present Modern.js
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,26 @@
+<p align="center">
+  <a href="https://modernjs.dev" target="blank"><img src="https://lf3-static.bytednsdoc.com/obj/eden-cn/ylaelkeh7nuhfnuhf/modernjs-cover.png" width="300" alt="Modern.js Logo" /></a>
+</p>
+
+<h1 align="center">Modern.js</h1>
+
+<p align="center">
+  A Progressive React Framework for modern web development.
+</p>
+
+## Getting Started
+
+Please follow [Quick Start](https://modernjs.dev/en/guides/get-started/quick-start) to get started with Modern.js.
+
+## Documentation
+
+- [English Documentation](https://modernjs.dev/en/)
+- [中文文档](https://modernjs.dev)
+
+## Contributing
+
+Please read the [Contributing Guide](https://github.com/web-infra-dev/modern.js/blob/main/CONTRIBUTING.md).
+
+## License
+
+Modern.js is [MIT licensed](https://github.com/web-infra-dev/modern.js/blob/main/LICENSE).

package/dist/cjs/client/callServer.js

@@ -0,0 +1,110 @@
+"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 callServer_exports = {};
+__export(callServer_exports, {
+  callServer: () => callServer,
+  requestCallServer: () => requestCallServer
+});
+module.exports = __toCommonJS(callServer_exports);
+var import_class_private_field_get = require("@swc/helpers/_/_class_private_field_get");
+var import_class_private_field_init = require("@swc/helpers/_/_class_private_field_init");
+var import_class_private_field_set = require("@swc/helpers/_/_class_private_field_set");
+var import_client = require("react-server-dom-webpack/client.browser");
+var _statusCode = /* @__PURE__ */ new WeakMap(), _url = /* @__PURE__ */ new WeakMap(), _details = /* @__PURE__ */ new WeakMap();
+class CallServerError extends Error {
+  get statusCode() {
+    return (0, import_class_private_field_get._)(this, _statusCode);
+  }
+  get url() {
+    return (0, import_class_private_field_get._)(this, _url);
+  }
+  get details() {
+    return {
+      ...(0, import_class_private_field_get._)(this, _details)
+    };
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      statusCode: (0, import_class_private_field_get._)(this, _statusCode),
+      url: (0, import_class_private_field_get._)(this, _url),
+      details: (0, import_class_private_field_get._)(this, _details)
+    };
+  }
+  constructor(message, statusCode, url = "", details = {}) {
+    const formattedMessage = `Call Server Action failed (${statusCode}): ${message}
+URL: ${url}`;
+    super(formattedMessage), (0, import_class_private_field_init._)(this, _statusCode, {
+      writable: true,
+      value: void 0
+    }), (0, import_class_private_field_init._)(this, _url, {
+      writable: true,
+      value: void 0
+    }), (0, import_class_private_field_init._)(this, _details, {
+      writable: true,
+      value: void 0
+    });
+    this.name = "CallServerError";
+    (0, import_class_private_field_set._)(this, _statusCode, statusCode);
+    (0, import_class_private_field_set._)(this, _url, url);
+    (0, import_class_private_field_set._)(this, _details, details);
+  }
+}
+async function requestCallServer(id, args) {
+  const entryName = window.__MODERN_JS_ENTRY_NAME;
+  const url = entryName === "main" ? "/" : `/${entryName}`;
+  try {
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        Accept: "text/x-component",
+        "x-rsc-action": id
+      },
+      body: await (0, import_client.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
+    });
+  }
+}
+async function callServer(id, args) {
+  const response = requestCallServer(id, args);
+  const res = (0, import_client.createFromFetch)(response, {
+    callServer
+  });
+  return res;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  callServer,
+  requestCallServer
+});

package/dist/cjs/client/index.js

@@ -0,0 +1,71 @@
+"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 client_exports = {};
+__export(client_exports, {
+  RSCServerSlot: () => RSCServerSlot,
+  RscClientRoot: () => RscClientRoot,
+  ServerElementsProvider: () => ServerElementsProvider,
+  callServer: () => import_callServer.callServer,
+  createFromFetch: () => import_client3.createFromFetch,
+  createFromReadableStream: () => import_client.createFromReadableStream,
+  createServerReference: () => import_client.createServerReference,
+  rscStream: () => import_client2.rscStream
+});
+module.exports = __toCommonJS(client_exports);
+var import_jsx_runtime = require("react/jsx-runtime");
+var import_react = require("react");
+var import_client = require("react-server-dom-webpack/client.browser");
+var import_client2 = require("rsc-html-stream/client");
+var import_callServer = require("./callServer");
+var import_client3 = require("react-server-dom-webpack/client.browser");
+function RscClientRoot({ data }) {
+  const elements = (0, import_react.use)(data);
+  const [root, setRoot] = (0, import_react.useState)(elements);
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_jsx_runtime.Fragment, {
+    children: root
+  });
+}
+const ElementsContext = /* @__PURE__ */ (0, import_react.createContext)(null);
+const JSX_SHELL_STREAM_END_MARK = "<!--<?- SHELL_STREAM_END ?>-->";
+const ServerElementsProvider = ({ elements, children }) => {
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(import_jsx_runtime.Fragment, {
+    children: [
+      /* @__PURE__ */ (0, import_jsx_runtime.jsx)(ElementsContext.Provider, {
+        value: elements,
+        children
+      }),
+      JSX_SHELL_STREAM_END_MARK
+    ]
+  });
+};
+const RSCServerSlot = () => {
+  const elements = (0, import_react.use)(ElementsContext);
+  return elements;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RSCServerSlot,
+  RscClientRoot,
+  ServerElementsProvider,
+  callServer,
+  createFromFetch,
+  createFromReadableStream,
+  createServerReference,
+  rscStream
+});

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

@@ -0,0 +1,98 @@
+"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 server_exports = {};
+__export(server_exports, {
+  injectRSCPayload: () => injectRSCPayload
+});
+module.exports = __toCommonJS(server_exports);
+const encoder = new TextEncoder();
+const trailer = "</body></html>";
+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 (buf.endsWith(trailer)) {
+        buf = buf.slice(0, -trailer.length);
+      }
+      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());
+        }
+      }, 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);
+    } catch (err) {
+      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);
+  }
+}
+function writeChunk(chunk, controller) {
+  controller.enqueue(encoder.encode(`<script>${escapeScript(`(self.__FLIGHT_DATA||=[]).push(${chunk})`)}</script>`));
+}
+function escapeScript(script) {
+  return script.replace(/<!--/g, "<\\!--").replace(/<\/(script)/gi, "</\\$1");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  injectRSCPayload
+});

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

@@ -0,0 +1,22 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var rsc_exports = {};
+module.exports = __toCommonJS(rsc_exports);
+__reExport(rsc_exports, require("./rsc"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./rsc")
+});

package/dist/cjs/server/rsc/rsc.js

@@ -0,0 +1,82 @@
+"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 rsc_exports = {};
+__export(rsc_exports, {
+  createFromReadableStream: () => import_client.createFromReadableStream,
+  handleAction: () => handleAction,
+  registerClientReference: () => import_server4.registerClientReference,
+  registerServerReference: () => import_server4.registerServerReference,
+  renderRsc: () => renderRsc,
+  renderToReadableStream: () => import_server.renderToReadableStream
+});
+module.exports = __toCommonJS(rsc_exports);
+var import_server = require("react-server-dom-webpack/server.edge");
+var import_server2 = require("react-server-dom-webpack/server.edge");
+var import_server3 = require("react-server-dom-webpack/server.edge");
+var import_client = require("react-server-dom-webpack/client.edge");
+var import_server4 = require("react-server-dom-webpack/server");
+const renderRsc = (options) => {
+  const payload = options.returnValue ? {
+    returnValue: options.returnValue,
+    root: options.element
+  } : options.element;
+  const readable = (0, import_server2.renderToReadableStream)(payload, options.clientManifest);
+  return readable;
+};
+const handleAction = async (req, options) => {
+  const serverReference = req.headers.get("x-rsc-action");
+  if (serverReference) {
+    const [filepath, name] = serverReference.split("#");
+    const action = __webpack_require__(filepath)[name || "default"];
+    if (action.$$typeof !== Symbol.for("react.server.reference")) {
+      throw new Error("Invalid action");
+    }
+    const { clientManifest } = options;
+    const contentType = req.headers.get("content-type");
+    let args;
+    if (contentType === null || contentType === void 0 ? void 0 : contentType.includes("multipart/form-data")) {
+      const formData = await req.formData();
+      args = await (0, import_server3.decodeReply)(formData);
+    } else {
+      const text = await req.text();
+      args = await (0, import_server3.decodeReply)(text);
+    }
+    const result = action.apply(null, args);
+    const stream = (0, import_server2.renderToReadableStream)(result, clientManifest);
+    const response = new Response(stream, {
+      status: 200,
+      headers: {
+        "Content-Type": "text/html"
+      }
+    });
+    return response;
+  }
+  return new Response("Cannot find server reference", {
+    status: 404
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createFromReadableStream,
+  handleAction,
+  registerClientReference,
+  registerServerReference,
+  renderRsc,
+  renderToReadableStream
+});

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

@@ -0,0 +1,22 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var ssr_exports = {};
+module.exports = __toCommonJS(ssr_exports);
+__reExport(ssr_exports, require("./ssr"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./ssr")
+});

package/dist/cjs/server/ssr/ssr.js

@@ -0,0 +1,80 @@
+"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 ssr_exports = {};
+__export(ssr_exports, {
+  renderSSRStream: () => renderSSRStream
+});
+module.exports = __toCommonJS(ssr_exports);
+var import_jsx_runtime = require("react/jsx-runtime");
+var import_server = require("react-dom/server.edge");
+var import_client = require("../../client");
+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 renderSSRStream = async (element, options) => {
+  const { clientManifest, ssrManifest, rscRoot } = options;
+  if (!clientManifest || !ssrManifest) {
+    return (0, import_server.renderToReadableStream)(element, options);
+  }
+  try {
+    const [{ renderRsc }, { createFromReadableStream }, { injectRSCPayload }] = await Promise.all([
+      Promise.resolve().then(() => __toESM(require("../rsc"))),
+      Promise.resolve().then(() => __toESM(require("react-server-dom-webpack/client.edge"))),
+      Promise.resolve().then(() => __toESM(require("../../rsc-html-stream/server")))
+    ]);
+    const rscStream = await renderRsc({
+      element: rscRoot || element,
+      clientManifest
+    });
+    const [rscElementStream, rscPayloadStream] = rscStream.tee();
+    const elements = createFromReadableStream(rscElementStream, {
+      serverConsumerManifest: ssrManifest
+    });
+    const htmlStream = await (0, import_server.renderToReadableStream)(/* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_client.ServerElementsProvider, {
+      elements,
+      children: element
+    }), options);
+    return wrapStream(htmlStream.pipeThrough(injectRSCPayload(rscPayloadStream, {
+      injectClosingTags: false
+    })), htmlStream);
+  } catch (error) {
+    console.error(error);
+    throw error;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  renderSSRStream
+});