@modern-js/render 0.0.0-next-20250108080920

package/dist/esm/client/callServer.js

@@ -0,0 +1,165 @@
+import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _call_super } from "@swc/helpers/_/_call_super";
+import { _ as _class_call_check } from "@swc/helpers/_/_class_call_check";
+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 { _ as _create_class } from "@swc/helpers/_/_create_class";
+import { _ as _inherits } from "@swc/helpers/_/_inherits";
+import { _ as _instanceof } from "@swc/helpers/_/_instanceof";
+import { _ as _object_spread } from "@swc/helpers/_/_object_spread";
+import { _ as _wrap_native_super } from "@swc/helpers/_/_wrap_native_super";
+import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
+import { createFromFetch, encodeReply } from "react-server-dom-webpack/client.browser";
+var _statusCode = /* @__PURE__ */ new WeakMap(), _url = /* @__PURE__ */ new WeakMap(), _details = /* @__PURE__ */ new WeakMap();
+var CallServerError = /* @__PURE__ */ function(Error1) {
+  "use strict";
+  _inherits(CallServerError2, Error1);
+  function CallServerError2(message, statusCode) {
+    var url = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : "", details = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : {};
+    _class_call_check(this, CallServerError2);
+    var _this;
+    var formattedMessage = "Call Server Action failed (".concat(statusCode, "): ").concat(message, "\nURL: ").concat(url);
+    _this = _call_super(this, CallServerError2, [
+      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);
+    return _this;
+  }
+  var _proto = CallServerError2.prototype;
+  _proto.toJSON = function 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)
+    };
+  };
+  _create_class(CallServerError2, [
+    {
+      key: "statusCode",
+      get: function get() {
+        return _class_private_field_get(this, _statusCode);
+      }
+    },
+    {
+      key: "url",
+      get: function get() {
+        return _class_private_field_get(this, _url);
+      }
+    },
+    {
+      key: "details",
+      get: function get() {
+        return _object_spread({}, _class_private_field_get(this, _details));
+      }
+    }
+  ]);
+  return CallServerError2;
+}(_wrap_native_super(Error));
+function requestCallServer(id, args) {
+  return _requestCallServer.apply(this, arguments);
+}
+function _requestCallServer() {
+  _requestCallServer = _async_to_generator(function(id, args) {
+    var entryName, url, response, _tmp, _tmp1, error;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          entryName = window.__MODERN_JS_ENTRY_NAME;
+          url = entryName === "main" ? "/" : "/".concat(entryName);
+          _state.label = 1;
+        case 1:
+          _state.trys.push([
+            1,
+            4,
+            ,
+            5
+          ]);
+          _tmp = [
+            url
+          ];
+          _tmp1 = {
+            method: "POST",
+            headers: {
+              Accept: "text/x-component",
+              "x-rsc-action": id
+            }
+          };
+          return [
+            4,
+            encodeReply(args)
+          ];
+        case 2:
+          return [
+            4,
+            fetch.apply(void 0, _tmp.concat([
+              (_tmp1.body = _state.sent(), _tmp1)
+            ]))
+          ];
+        case 3:
+          response = _state.sent();
+          if (!response.ok) {
+            throw new CallServerError(response.statusText, response.status, url, {
+              id,
+              args
+            });
+          }
+          return [
+            2,
+            response
+          ];
+        case 4:
+          error = _state.sent();
+          if (_instanceof(error, CallServerError)) {
+            throw error;
+          }
+          throw new CallServerError(_instanceof(error, Error) ? error.message : "Unknown error", 1, url, {
+            id,
+            args
+          });
+        case 5:
+          return [
+            2
+          ];
+      }
+    });
+  });
+  return _requestCallServer.apply(this, arguments);
+}
+function callServer(id, args) {
+  return _callServer.apply(this, arguments);
+}
+function _callServer() {
+  _callServer = _async_to_generator(function(id, args) {
+    var response, res;
+    return _ts_generator(this, function(_state) {
+      response = requestCallServer(id, args);
+      res = createFromFetch(response, {
+        callServer
+      });
+      return [
+        2,
+        res
+      ];
+    });
+  });
+  return _callServer.apply(this, arguments);
+}
+export {
+  callServer,
+  requestCallServer
+};

package/dist/esm/client/index.js

@@ -0,0 +1,43 @@
+import { _ as _sliced_to_array } from "@swc/helpers/_/_sliced_to_array";
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { createContext, use, useState } from "react";
+import { createFromReadableStream, createServerReference } from "react-server-dom-webpack/client.browser";
+import { rscStream } from "rsc-html-stream/client";
+import { callServer } from "./callServer";
+import { createFromFetch } from "react-server-dom-webpack/client.browser";
+function RscClientRoot(param) {
+  var data = param.data;
+  var elements = use(data);
+  var _useState = _sliced_to_array(useState(elements), 2), root = _useState[0], setRoot = _useState[1];
+  return /* @__PURE__ */ _jsx(_Fragment, {
+    children: root
+  });
+}
+var ElementsContext = /* @__PURE__ */ createContext(null);
+var JSX_SHELL_STREAM_END_MARK = "<!--<?- SHELL_STREAM_END ?>-->";
+var ServerElementsProvider = function(param) {
+  var elements = param.elements, children = param.children;
+  return /* @__PURE__ */ _jsxs(_Fragment, {
+    children: [
+      /* @__PURE__ */ _jsx(ElementsContext.Provider, {
+        value: elements,
+        children
+      }),
+      JSX_SHELL_STREAM_END_MARK
+    ]
+  });
+};
+var RSCServerSlot = function() {
+  var elements = use(ElementsContext);
+  return elements;
+};
+export {
+  RSCServerSlot,
+  RscClientRoot,
+  ServerElementsProvider,
+  callServer,
+  createFromFetch,
+  createFromReadableStream,
+  createServerReference,
+  rscStream
+};

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

@@ -0,0 +1,216 @@
+import { _ as _async_iterator } from "@swc/helpers/_/_async_iterator";
+import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _to_consumable_array } from "@swc/helpers/_/_to_consumable_array";
+import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
+var encoder = new TextEncoder();
+var trailer = "</body></html>";
+function injectRSCPayload(rscStream, param) {
+  var _param_injectClosingTags = param.injectClosingTags, injectClosingTags = _param_injectClosingTags === void 0 ? true : _param_injectClosingTags;
+  var decoder = new TextDecoder();
+  var resolveFlightDataPromise;
+  var flightDataPromise = new Promise(function(resolve) {
+    return resolveFlightDataPromise = resolve;
+  });
+  var startedRSC = false;
+  var buffered = [];
+  var timeout = null;
+  function flushBufferedChunks(controller) {
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
+    try {
+      for (var _iterator = buffered[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+        var chunk = _step.value;
+        var buf = decoder.decode(chunk);
+        if (buf.endsWith(trailer)) {
+          buf = buf.slice(0, -trailer.length);
+        }
+        controller.enqueue(encoder.encode(buf));
+      }
+    } catch (err) {
+      _didIteratorError = true;
+      _iteratorError = err;
+    } finally {
+      try {
+        if (!_iteratorNormalCompletion && _iterator.return != null) {
+          _iterator.return();
+        }
+      } finally {
+        if (_didIteratorError) {
+          throw _iteratorError;
+        }
+      }
+    }
+    buffered.length = 0;
+    timeout = null;
+  }
+  return new TransformStream({
+    transform: function transform(chunk, controller) {
+      buffered.push(chunk);
+      if (timeout) {
+        return;
+      }
+      timeout = setTimeout(/* @__PURE__ */ _async_to_generator(function() {
+        return _ts_generator(this, function(_state) {
+          flushBufferedChunks(controller);
+          if (!startedRSC) {
+            startedRSC = true;
+            writeRSCStream(rscStream, controller).catch(function(err) {
+              return controller.error(err);
+            }).then(function() {
+              return resolveFlightDataPromise();
+            });
+          }
+          return [
+            2
+          ];
+        });
+      }), 0);
+    },
+    flush: function flush(controller) {
+      return _async_to_generator(function() {
+        return _ts_generator(this, function(_state) {
+          switch (_state.label) {
+            case 0:
+              return [
+                4,
+                flightDataPromise
+              ];
+            case 1:
+              _state.sent();
+              if (timeout) {
+                clearTimeout(timeout);
+                flushBufferedChunks(controller);
+              }
+              if (injectClosingTags) {
+                controller.enqueue(encoder.encode("</body></html>"));
+              }
+              return [
+                2
+              ];
+          }
+        });
+      })();
+    }
+  });
+}
+function writeRSCStream(rscStream, controller) {
+  return _writeRSCStream.apply(this, arguments);
+}
+function _writeRSCStream() {
+  _writeRSCStream = _async_to_generator(function(rscStream, controller) {
+    var decoder, _iteratorAbruptCompletion, _didIteratorError, _iteratorError, _iterator, _step, _value, chunk, _String, base64, err, remaining;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          decoder = new TextDecoder("utf-8", {
+            fatal: true
+          });
+          _iteratorAbruptCompletion = false, _didIteratorError = false;
+          _state.label = 1;
+        case 1:
+          _state.trys.push([
+            1,
+            6,
+            7,
+            12
+          ]);
+          _iterator = _async_iterator(rscStream);
+          _state.label = 2;
+        case 2:
+          return [
+            4,
+            _iterator.next()
+          ];
+        case 3:
+          if (!(_iteratorAbruptCompletion = !(_step = _state.sent()).done))
+            return [
+              3,
+              5
+            ];
+          _value = _step.value;
+          chunk = _value;
+          try {
+            writeChunk(JSON.stringify(decoder.decode(chunk, {
+              stream: true
+            })), controller);
+          } catch (err2) {
+            ;
+            base64 = JSON.stringify(btoa((_String = String).fromCodePoint.apply(_String, _to_consumable_array(chunk))));
+            writeChunk("Uint8Array.from(atob(".concat(base64, "), m => m.codePointAt(0))"), controller);
+          }
+          _state.label = 4;
+        case 4:
+          _iteratorAbruptCompletion = false;
+          return [
+            3,
+            2
+          ];
+        case 5:
+          return [
+            3,
+            12
+          ];
+        case 6:
+          err = _state.sent();
+          _didIteratorError = true;
+          _iteratorError = err;
+          return [
+            3,
+            12
+          ];
+        case 7:
+          _state.trys.push([
+            7,
+            ,
+            10,
+            11
+          ]);
+          if (!(_iteratorAbruptCompletion && _iterator.return != null))
+            return [
+              3,
+              9
+            ];
+          return [
+            4,
+            _iterator.return()
+          ];
+        case 8:
+          _state.sent();
+          _state.label = 9;
+        case 9:
+          return [
+            3,
+            11
+          ];
+        case 10:
+          if (_didIteratorError) {
+            throw _iteratorError;
+          }
+          return [
+            7
+          ];
+        case 11:
+          return [
+            7
+          ];
+        case 12:
+          remaining = decoder.decode();
+          if (remaining.length) {
+            writeChunk(JSON.stringify(remaining), controller);
+          }
+          return [
+            2
+          ];
+      }
+    });
+  });
+  return _writeRSCStream.apply(this, arguments);
+}
+function writeChunk(chunk, controller) {
+  controller.enqueue(encoder.encode("<script>".concat(escapeScript("(self.__FLIGHT_DATA||=[]).push(".concat(chunk, ")")), "</script>")));
+}
+function escapeScript(script) {
+  return script.replace(/<!--/g, "<\\!--").replace(/<\/(script)/gi, "</\\$1");
+}
+export {
+  injectRSCPayload
+};

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

@@ -0,0 +1 @@
+export * from "./rsc";

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

@@ -0,0 +1,105 @@
+import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _sliced_to_array } from "@swc/helpers/_/_sliced_to_array";
+import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
+import { renderToReadableStream } from "react-server-dom-webpack/server.edge";
+import { renderToReadableStream as renderToReadableStream2 } from "react-server-dom-webpack/server.edge";
+import { decodeReply } from "react-server-dom-webpack/server.edge";
+import { createFromReadableStream } from "react-server-dom-webpack/client.edge";
+import { registerClientReference, registerServerReference } from "react-server-dom-webpack/server";
+var renderRsc = function(options) {
+  var payload = options.returnValue ? {
+    returnValue: options.returnValue,
+    root: options.element
+  } : options.element;
+  var readable = renderToReadableStream2(payload, options.clientManifest);
+  return readable;
+};
+var handleAction = function() {
+  var _ref = _async_to_generator(function(req, options) {
+    var serverReference, _serverReference_split, filepath, name, action, clientManifest, contentType, args, formData, text, result, stream, response;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          serverReference = req.headers.get("x-rsc-action");
+          if (!serverReference)
+            return [
+              3,
+              7
+            ];
+          _serverReference_split = _sliced_to_array(serverReference.split("#"), 2), filepath = _serverReference_split[0], name = _serverReference_split[1];
+          action = __webpack_require__(filepath)[name || "default"];
+          if (action.$$typeof !== Symbol.for("react.server.reference")) {
+            throw new Error("Invalid action");
+          }
+          clientManifest = options.clientManifest;
+          contentType = req.headers.get("content-type");
+          if (!(contentType === null || contentType === void 0 ? void 0 : contentType.includes("multipart/form-data")))
+            return [
+              3,
+              3
+            ];
+          return [
+            4,
+            req.formData()
+          ];
+        case 1:
+          formData = _state.sent();
+          return [
+            4,
+            decodeReply(formData)
+          ];
+        case 2:
+          args = _state.sent();
+          return [
+            3,
+            6
+          ];
+        case 3:
+          return [
+            4,
+            req.text()
+          ];
+        case 4:
+          text = _state.sent();
+          return [
+            4,
+            decodeReply(text)
+          ];
+        case 5:
+          args = _state.sent();
+          _state.label = 6;
+        case 6:
+          result = action.apply(null, args);
+          stream = renderToReadableStream2(result, clientManifest);
+          response = new Response(stream, {
+            status: 200,
+            headers: {
+              "Content-Type": "text/html"
+            }
+          });
+          return [
+            2,
+            response
+          ];
+        case 7:
+          return [
+            2,
+            new Response("Cannot find server reference", {
+              status: 404
+            })
+          ];
+      }
+    });
+  });
+  return function handleAction2(req, options) {
+    return _ref.apply(this, arguments);
+  };
+}();
+export {
+  createFromReadableStream,
+  handleAction,
+  registerClientReference,
+  registerServerReference,
+  renderRsc,
+  renderToReadableStream
+};

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

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

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

@@ -0,0 +1,112 @@
+import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _sliced_to_array } from "@swc/helpers/_/_sliced_to_array";
+import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
+import { jsx as _jsx } from "react/jsx-runtime";
+import { renderToReadableStream } from "react-dom/server.edge";
+import { ServerElementsProvider } from "../../client";
+function wrapStream(stream, originalStream) {
+  var wrappedStream = Object.create(stream);
+  var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
+  try {
+    for (var _iterator = Object.keys(originalStream)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+      var prop = _step.value;
+      if (!(prop in wrappedStream)) {
+        wrappedStream[prop] = originalStream[prop];
+      }
+    }
+  } catch (err) {
+    _didIteratorError = true;
+    _iteratorError = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion && _iterator.return != null) {
+        _iterator.return();
+      }
+    } finally {
+      if (_didIteratorError) {
+        throw _iteratorError;
+      }
+    }
+  }
+  return wrappedStream;
+}
+var renderSSRStream = function() {
+  var _ref = _async_to_generator(function(element, options) {
+    var clientManifest, ssrManifest, rscRoot, _ref2, renderRsc, createFromReadableStream, injectRSCPayload, rscStream, _rscStream_tee, rscElementStream, rscPayloadStream, elements, htmlStream, error;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          clientManifest = options.clientManifest, ssrManifest = options.ssrManifest, rscRoot = options.rscRoot;
+          if (!clientManifest || !ssrManifest) {
+            return [
+              2,
+              renderToReadableStream(element, options)
+            ];
+          }
+          _state.label = 1;
+        case 1:
+          _state.trys.push([
+            1,
+            5,
+            ,
+            6
+          ]);
+          return [
+            4,
+            Promise.all([
+              import("../rsc"),
+              import("react-server-dom-webpack/client.edge"),
+              import("../../rsc-html-stream/server")
+            ])
+          ];
+        case 2:
+          _ref2 = _sliced_to_array.apply(void 0, [
+            _state.sent(),
+            3
+          ]), renderRsc = _ref2[0].renderRsc, createFromReadableStream = _ref2[1].createFromReadableStream, injectRSCPayload = _ref2[2].injectRSCPayload;
+          return [
+            4,
+            renderRsc({
+              element: rscRoot || element,
+              clientManifest
+            })
+          ];
+        case 3:
+          rscStream = _state.sent();
+          _rscStream_tee = _sliced_to_array(rscStream.tee(), 2), rscElementStream = _rscStream_tee[0], rscPayloadStream = _rscStream_tee[1];
+          elements = createFromReadableStream(rscElementStream, {
+            serverConsumerManifest: ssrManifest
+          });
+          return [
+            4,
+            renderToReadableStream(/* @__PURE__ */ _jsx(ServerElementsProvider, {
+              elements,
+              children: element
+            }), options)
+          ];
+        case 4:
+          htmlStream = _state.sent();
+          return [
+            2,
+            wrapStream(htmlStream.pipeThrough(injectRSCPayload(rscPayloadStream, {
+              injectClosingTags: false
+            })), htmlStream)
+          ];
+        case 5:
+          error = _state.sent();
+          console.error(error);
+          throw error;
+        case 6:
+          return [
+            2
+          ];
+      }
+    });
+  });
+  return function renderSSRStream2(element, options) {
+    return _ref.apply(this, arguments);
+  };
+}();
+export {
+  renderSSRStream
+};