@modern-js/runtime 2.54.6 → 2.55.0

package/dist/esm/core/server/stream/shared.js

@@ -0,0 +1,102 @@
+import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
+import { time } from "@modern-js/runtime-utils/time";
+import { parseHeaders } from "@modern-js/runtime-utils/universal/request";
+import { run } from "@modern-js/runtime-utils/node";
+import React from "react";
+import { SSRErrors, SSRTimings, createOnError, createOnTiming } from "../tracer";
+import { getSSRConfigByEntry } from "../utils";
+var ShellChunkStatus;
+(function(ShellChunkStatus2) {
+  ShellChunkStatus2[ShellChunkStatus2["START"] = 0] = "START";
+  ShellChunkStatus2[ShellChunkStatus2["FINISH"] = 1] = "FINISH";
+})(ShellChunkStatus || (ShellChunkStatus = {}));
+var encoder;
+function encodeForWebStream(thing) {
+  if (!encoder) {
+    encoder = new TextEncoder();
+  }
+  if (typeof thing === "string") {
+    return encoder.encode(thing);
+  }
+  return thing;
+}
+function getReadableStreamFromString(content) {
+  var readableStream = new ReadableStream({
+    start: function start(controller) {
+      controller.enqueue(encodeForWebStream(content));
+      controller.close();
+    }
+  });
+  return readableStream;
+}
+function createRenderStreaming(createReadableStreamFromElement) {
+  return function() {
+    var _ref = _async_to_generator(function(request, serverRoot, options) {
+      var headersData;
+      return _ts_generator(this, function(_state) {
+        headersData = parseHeaders(request);
+        return [
+          2,
+          run(headersData, /* @__PURE__ */ _async_to_generator(function() {
+            var end, runtimeContext, config, resource, staticGenerate, onError, onTiming, htmlTemplate, entryName, ssrConfig, rootElement, stream;
+            return _ts_generator(this, function(_state2) {
+              switch (_state2.label) {
+                case 0:
+                  end = time();
+                  runtimeContext = options.runtimeContext, config = options.config, resource = options.resource, staticGenerate = options.staticGenerate;
+                  onError = createOnError(options.onError);
+                  onTiming = createOnTiming(options.onTiming);
+                  htmlTemplate = resource.htmlTemplate, entryName = resource.entryName;
+                  ssrConfig = getSSRConfigByEntry(entryName, config.ssr, config.ssrByEntries, staticGenerate);
+                  rootElement = React.cloneElement(serverRoot, {
+                    _internal_context: Object.assign(runtimeContext, {
+                      ssr: true
+                    })
+                  });
+                  return [
+                    4,
+                    createReadableStreamFromElement(request, rootElement, {
+                      config,
+                      htmlTemplate,
+                      runtimeContext,
+                      ssrConfig,
+                      onShellReady: function onShellReady() {
+                        var cost = end();
+                        onTiming(SSRTimings.RENDER_SHELL, cost);
+                      },
+                      onAllReady: function onAllReady() {
+                        var cost = end();
+                        onTiming(SSRTimings.RENDER_HTML, cost);
+                      },
+                      onShellError: function onShellError(error) {
+                        onError(SSRErrors.RENDER_SHELL, error);
+                      },
+                      onError: function onError1(error) {
+                        onError(SSRErrors.RENDER_STREAM, error);
+                      }
+                    })
+                  ];
+                case 1:
+                  stream = _state2.sent();
+                  return [
+                    2,
+                    stream
+                  ];
+              }
+            });
+          }))
+        ];
+      });
+    });
+    return function(request, serverRoot, options) {
+      return _ref.apply(this, arguments);
+    };
+  }();
+}
+export {
+  ShellChunkStatus,
+  createRenderStreaming,
+  encodeForWebStream,
+  getReadableStreamFromString
+};

package/dist/esm/core/server/stream/template.js

@@ -0,0 +1,42 @@
+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 { buildShellBeforeTemplate } from "./beforeTemplate";
+import { buildShellAfterTemplate } from "./afterTemplate";
+var HTML_SEPARATOR = "<!--<?- html ?>-->";
+var getTemplates = function() {
+  var _ref = _async_to_generator(function(htmlTemplate, options) {
+    var _ref2, tmp, beforeAppTemplate, tmp1, afterAppHtmlTemplate, builtBeforeTemplate, builtAfterTemplate;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          _ref2 = _sliced_to_array(htmlTemplate.split(HTML_SEPARATOR) || [], 2), tmp = _ref2[0], beforeAppTemplate = tmp === void 0 ? "" : tmp, tmp1 = _ref2[1], afterAppHtmlTemplate = tmp1 === void 0 ? "" : tmp1;
+          return [
+            4,
+            buildShellBeforeTemplate(beforeAppTemplate, options)
+          ];
+        case 1:
+          builtBeforeTemplate = _state.sent();
+          return [
+            4,
+            buildShellAfterTemplate(afterAppHtmlTemplate, options)
+          ];
+        case 2:
+          builtAfterTemplate = _state.sent();
+          return [
+            2,
+            {
+              shellBefore: builtBeforeTemplate,
+              shellAfter: builtAfterTemplate
+            }
+          ];
+      }
+    });
+  });
+  return function getTemplates2(htmlTemplate, options) {
+    return _ref.apply(this, arguments);
+  };
+}();
+export {
+  getTemplates
+};

package/dist/esm/core/server/string/index.js

@@ -0,0 +1,219 @@
+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";
+import ReactHelmet from "react-helmet";
+import ReactDomServer from "react-dom/server";
+import React from "react";
+import { time } from "@modern-js/runtime-utils/time";
+import { run } from "@modern-js/runtime-utils/node";
+import { parseHeaders } from "@modern-js/runtime-utils/universal/request";
+import { createReplaceHelemt } from "../helmet";
+import { getSSRConfigByEntry, safeReplace } from "../utils";
+import { CHUNK_CSS_PLACEHOLDER, CHUNK_JS_PLACEHOLDER, HTML_PLACEHOLDER, SSR_DATA_PLACEHOLDER } from "../constants";
+import { buildHtml } from "../shared";
+import { SSRErrors, SSRTimings, createOnError, createOnTiming } from "../tracer";
+import { RenderLevel } from "../../constants";
+import { SSRDataCollector } from "./ssrData";
+import { LoadableCollector } from "./loadable";
+import { StyledCollector } from "./styledComponent";
+import { prefetch } from "./prefetch";
+var renderString = function() {
+  var _ref = _async_to_generator(function(request, serverRoot, options) {
+    var headersData;
+    return _ts_generator(this, function(_state) {
+      headersData = parseHeaders(request);
+      return [
+        2,
+        run(headersData, /* @__PURE__ */ _async_to_generator(function() {
+          var _runtimeContext_ssrContext, resource, runtimeContext, config, onError, onTiming, staticGenerate, tracer, routerContext, htmlTemplate, entryName, loadableStats, routeManifest, chunkSet, prefetchData, e, ssrConfig, collectors, rootElement, html;
+          return _ts_generator(this, function(_state2) {
+            switch (_state2.label) {
+              case 0:
+                resource = options.resource, runtimeContext = options.runtimeContext, config = options.config, onError = options.onError, onTiming = options.onTiming, staticGenerate = options.staticGenerate;
+                tracer = {
+                  onError: createOnError(onError),
+                  onTiming: createOnTiming(onTiming)
+                };
+                routerContext = runtimeContext.routerContext;
+                htmlTemplate = resource.htmlTemplate, entryName = resource.entryName, loadableStats = resource.loadableStats, routeManifest = resource.routeManifest;
+                chunkSet = {
+                  renderLevel: RenderLevel.CLIENT_RENDER,
+                  ssrScripts: "",
+                  jsChunk: "",
+                  cssChunk: ""
+                };
+                prefetchData = {};
+                _state2.label = 1;
+              case 1:
+                _state2.trys.push([
+                  1,
+                  3,
+                  ,
+                  4
+                ]);
+                return [
+                  4,
+                  prefetch(serverRoot, request, options, tracer)
+                ];
+              case 2:
+                prefetchData = _state2.sent();
+                chunkSet.renderLevel = RenderLevel.SERVER_PREFETCH;
+                return [
+                  3,
+                  4
+                ];
+              case 3:
+                e = _state2.sent();
+                chunkSet.renderLevel = RenderLevel.CLIENT_RENDER;
+                return [
+                  3,
+                  4
+                ];
+              case 4:
+                ssrConfig = getSSRConfigByEntry(entryName, config.ssr, config.ssrByEntries, staticGenerate);
+                collectors = [
+                  new StyledCollector(chunkSet),
+                  new LoadableCollector({
+                    stats: loadableStats,
+                    nonce: config.nonce,
+                    routeManifest,
+                    template: htmlTemplate,
+                    entryName,
+                    chunkSet,
+                    config
+                  }),
+                  new SSRDataCollector({
+                    request,
+                    prefetchData,
+                    ssrConfig,
+                    ssrContext: runtimeContext.ssrContext,
+                    chunkSet,
+                    routerContext,
+                    nonce: config.nonce
+                  })
+                ];
+                rootElement = React.cloneElement(serverRoot, {
+                  _internal_context: Object.assign(runtimeContext, {
+                    ssr: true
+                  })
+                });
+                return [
+                  4,
+                  generateHtml(rootElement, htmlTemplate, chunkSet, collectors, ((_runtimeContext_ssrContext = runtimeContext.ssrContext) === null || _runtimeContext_ssrContext === void 0 ? void 0 : _runtimeContext_ssrContext.htmlModifiers) || [], tracer)
+                ];
+              case 5:
+                html = _state2.sent();
+                return [
+                  2,
+                  html
+                ];
+            }
+          });
+        }))
+      ];
+    });
+  });
+  return function renderString2(request, serverRoot, options) {
+    return _ref.apply(this, arguments);
+  };
+}();
+function generateHtml(App, htmlTemplate, chunkSet, collectors, htmlModifiers, _) {
+  return _generateHtml.apply(this, arguments);
+}
+function _generateHtml() {
+  _generateHtml = _async_to_generator(function(App, htmlTemplate, chunkSet, collectors, htmlModifiers, param) {
+    var onError, onTiming, end, html, helmetData, finalApp, cost, e, ssrScripts, cssChunk, jsChunk, finalHtml;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          onError = param.onError, onTiming = param.onTiming;
+          end = time();
+          html = "";
+          if (!(chunkSet.renderLevel >= RenderLevel.SERVER_PREFETCH))
+            return [
+              3,
+              4
+            ];
+          _state.label = 1;
+        case 1:
+          _state.trys.push([
+            1,
+            3,
+            ,
+            4
+          ]);
+          finalApp = collectors.reduce(function(pre, creator) {
+            var _creator_collect;
+            return ((_creator_collect = creator.collect) === null || _creator_collect === void 0 ? void 0 : _creator_collect.call(creator, pre)) || pre;
+          }, App);
+          html = ReactDomServer.renderToString(finalApp);
+          helmetData = ReactHelmet.renderStatic();
+          chunkSet.renderLevel = RenderLevel.SERVER_RENDER;
+          return [
+            4,
+            Promise.all(collectors.map(function(component) {
+              return component.effect();
+            }))
+          ];
+        case 2:
+          _state.sent();
+          cost = end();
+          onTiming(SSRTimings.RENDER_HTML, cost);
+          return [
+            3,
+            4
+          ];
+        case 3:
+          e = _state.sent();
+          chunkSet.renderLevel = RenderLevel.CLIENT_RENDER;
+          onError(SSRErrors.RENDER_HTML, e);
+          return [
+            3,
+            4
+          ];
+        case 4:
+          ssrScripts = chunkSet.ssrScripts, cssChunk = chunkSet.cssChunk, jsChunk = chunkSet.jsChunk;
+          return [
+            4,
+            buildHtml(htmlTemplate, [
+              createReplaceHtml(html),
+              createReplaceChunkJs(jsChunk),
+              createReplaceChunkCss(cssChunk),
+              createReplaceSSRDataScript(ssrScripts),
+              createReplaceHelemt(helmetData)
+            ].concat(_to_consumable_array(htmlModifiers)))
+          ];
+        case 5:
+          finalHtml = _state.sent();
+          return [
+            2,
+            finalHtml
+          ];
+      }
+    });
+  });
+  return _generateHtml.apply(this, arguments);
+}
+function createReplaceHtml(html) {
+  return function(template) {
+    return safeReplace(template, HTML_PLACEHOLDER, html);
+  };
+}
+function createReplaceSSRDataScript(data) {
+  return function(template) {
+    return safeReplace(template, SSR_DATA_PLACEHOLDER, data);
+  };
+}
+function createReplaceChunkJs(js) {
+  return function(template) {
+    return safeReplace(template, CHUNK_JS_PLACEHOLDER, js);
+  };
+}
+function createReplaceChunkCss(css) {
+  return function(template) {
+    return safeReplace(template, CHUNK_CSS_PLACEHOLDER, css);
+  };
+}
+export {
+  renderString
+};

package/dist/esm/{ssr/serverRender/renderToString → core/server/string}/loadable.js

@@ -124,21 +124,20 @@ var LoadableCollector = /* @__PURE__ */ function() {
     if (!check(scripts)) {
       return;
     }
-    var _this_options = this.options, chunksMap = _this_options.result.chunksMap;
+    var chunkSet = this.options.chunkSet;
     var s = scripts.split("</script>").slice(0, 2).map(function(i) {
       return "".concat(i, "</script>");
     }).join("");
-    chunksMap.js += s;
+    chunkSet.jsChunk += s;
   };
   _proto.emitScriptAssets = function emitScriptAssets(chunks) {
     var _this = this;
     return _async_to_generator(function() {
-      var _this_options, template, config, nonce, result, chunksMap, _config_scriptLoading, scriptLoading, enableInlineScripts, scriptLoadingAtr, attributes, scripts;
+      var _this_options, template, nonce, chunkSet, config, _config_scriptLoading, scriptLoading, enableInlineScripts, scriptLoadingAtr, attributes, scripts;
       return _ts_generator(this, function(_state) {
         switch (_state.label) {
           case 0:
-            _this_options = _this.options, template = _this_options.template, config = _this_options.config, nonce = _this_options.nonce, result = _this_options.result;
-            chunksMap = result.chunksMap;
+            _this_options = _this.options, template = _this_options.template, nonce = _this_options.nonce, chunkSet = _this_options.chunkSet, config = _this_options.config;
             _config_scriptLoading = config.scriptLoading, scriptLoading = _config_scriptLoading === void 0 ? "defer" : _config_scriptLoading, enableInlineScripts = config.enableInlineScripts;
             scriptLoadingAtr = {
               defer: scriptLoading === "defer" ? true : void 0,
@@ -186,7 +185,7 @@ var LoadableCollector = /* @__PURE__ */ function() {
             ];
           case 1:
             scripts = _state.sent();
-            chunksMap.js += scripts.filter(function(script) {
+            chunkSet.jsChunk += scripts.filter(function(script) {
               return Boolean(script);
             }).join("");
             return [
@@ -199,11 +198,12 @@ var LoadableCollector = /* @__PURE__ */ function() {
   _proto.emitStyleAssets = function emitStyleAssets(chunks) {
     var _this = this;
     return _async_to_generator(function() {
-      var _this_options, template, chunksMap, enableInlineStyles, atrributes, css;
+      var _this_options, template, chunkSet, config, enableInlineStyles, atrributes, css;
       return _ts_generator(this, function(_state) {
         switch (_state.label) {
           case 0:
-            _this_options = _this.options, template = _this_options.template, chunksMap = _this_options.result.chunksMap, enableInlineStyles = _this_options.config.enableInlineStyles;
+            _this_options = _this.options, template = _this_options.template, chunkSet = _this_options.chunkSet, config = _this_options.config;
+            enableInlineStyles = config.enableInlineStyles;
             atrributes = attributesToString(_this.generateAttributes());
             return [
               4,
@@ -243,7 +243,7 @@ var LoadableCollector = /* @__PURE__ */ function() {
             ];
           case 1:
             css = _state.sent();
-            chunksMap.css += css.filter(function(css2) {
+            chunkSet.jsChunk += css.filter(function(css2) {
               return Boolean(css2);
             }).join("");
             return [
@@ -275,9 +275,6 @@ var LoadableCollector = /* @__PURE__ */ function() {
   ]);
   return LoadableCollector2;
 }();
-function createLoadableCollector(options) {
-  return new LoadableCollector(options);
-}
 export {
-  createLoadableCollector
+  LoadableCollector
 };

package/dist/esm/{ssr → core/server/string}/prefetch.js

@@ -1,23 +1,27 @@
 import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
 import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
-import { jsx as _jsx } from "react/jsx-runtime";
 import { renderToStaticMarkup } from "react-dom/server";
 import { run } from "@modern-js/runtime-utils/node";
 import { ChunkExtractor } from "@loadable/server";
 import { time } from "@modern-js/runtime-utils/time";
-import { SSRTimings, SSRErrors } from "./serverRender/tracker";
+import { parseHeaders } from "@modern-js/runtime-utils/universal/request";
+import React from "react";
+import { SSRErrors, SSRTimings } from "../tracer";
 var prefetch = function() {
-  var _ref = _async_to_generator(function(App, context, config, tracker) {
+  var _ref = _async_to_generator(function(App, request, options, param) {
+    var onError, onTiming, headersData, context, resource, config, entryName, loadableStats;
     return _ts_generator(this, function(_state) {
+      onError = param.onError, onTiming = param.onTiming;
+      headersData = parseHeaders(request);
+      context = options.runtimeContext, resource = options.resource, config = options.config;
+      entryName = resource.entryName, loadableStats = resource.loadableStats;
       return [
         2,
-        run(context.ssrContext.request.headers, /* @__PURE__ */ _async_to_generator(function() {
-          var _context_store, ssrContext, loadableStats, end, extractor, cost, error, loadersData, end1, cost1, e, error1;
+        run(headersData, /* @__PURE__ */ _async_to_generator(function() {
+          var _context_store, end, extractor, cost, error, loadersData, end1, cost1, e;
           return _ts_generator(this, function(_state2) {
             switch (_state2.label) {
               case 0:
-                ssrContext = context.ssrContext;
-                loadableStats = ssrContext.loadableStats;
                 if (!config.disablePrerender) {
                   try {
                     end = time();
@@ -25,22 +29,26 @@ var prefetch = function() {
                       extractor = new ChunkExtractor({
                         stats: loadableStats,
                         entrypoints: [
-                          ssrContext.entryName
+                          entryName
                         ].filter(Boolean)
                       });
-                      renderToStaticMarkup(extractor.collectChunks(/* @__PURE__ */ _jsx(App, {
-                        context
+                      renderToStaticMarkup(extractor.collectChunks(/* @__PURE__ */ React.cloneElement(App, {
+                        _internal_context: Object.assign(context, {
+                          ssr: false
+                        })
                       })));
                     } else {
-                      renderToStaticMarkup(/* @__PURE__ */ _jsx(App, {
-                        context
+                      renderToStaticMarkup(/* @__PURE__ */ React.cloneElement(App, {
+                        _internal_context: Object.assign(context, {
+                          ssr: false
+                        })
                       }));
                     }
                     cost = end();
-                    tracker.trackTiming(SSRTimings.PRERENDER, cost);
+                    onTiming(SSRTimings.PRERENDER, cost);
                   } catch (e2) {
                     error = e2;
-                    tracker.trackError(SSRErrors.PRERENDER, error);
+                    onError(SSRErrors.PRERENDER, error);
                     throw e2;
                   }
                 }
@@ -70,21 +78,20 @@ var prefetch = function() {
               case 2:
                 loadersData = _state2.sent();
                 cost1 = end1();
-                tracker.trackTiming(SSRTimings.USE_LOADER, cost1);
+                onTiming(SSRTimings.USE_LOADER, cost1);
                 return [
                   3,
                   4
                 ];
               case 3:
                 e = _state2.sent();
-                error1 = e;
-                tracker.trackError(SSRErrors.USE_LOADER, error1);
+                onError(SSRErrors.USE_LOADER, e);
                 throw e;
               case 4:
                 Object.keys(loadersData).forEach(function(id) {
                   var data = loadersData[id];
                   if (data._error) {
-                    ssrContext.logger.error("App Load use-loader", data._error);
+                    onError(SSRErrors.USE_LOADER, data._error);
                     delete data._error;
                   }
                 });
@@ -104,11 +111,10 @@ var prefetch = function() {
       ];
     });
   });
-  return function prefetch2(App, context, config, tracker) {
+  return function prefetch2(App, request, options, _) {
     return _ref.apply(this, arguments);
   };
 }();
-var prefetch_default = prefetch;
 export {
-  prefetch_default as default
+  prefetch
 };

package/dist/esm/core/server/string/ssrData.js

@@ -0,0 +1,83 @@
+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 _class_private_method_get } from "@swc/helpers/_/_class_private_method_get";
+import { _ as _class_private_method_init } from "@swc/helpers/_/_class_private_method_init";
+import { _ as _sliced_to_array } from "@swc/helpers/_/_sliced_to_array";
+import { serializeJson } from "@modern-js/runtime-utils/node";
+import { attributesToString, serializeErrors } from "../utils";
+import { ROUTER_DATA_JSON_ID, SSR_DATA_JSON_ID } from "../constants";
+var _options = /* @__PURE__ */ new WeakMap(), _getSSRData = /* @__PURE__ */ new WeakSet(), _getSSRDataScripts = /* @__PURE__ */ new WeakSet();
+var SSRDataCollector = /* @__PURE__ */ function() {
+  "use strict";
+  function SSRDataCollector2(options) {
+    _class_call_check(this, SSRDataCollector2);
+    _class_private_method_init(this, _getSSRData);
+    _class_private_method_init(this, _getSSRDataScripts);
+    _class_private_field_init(this, _options, {
+      writable: true,
+      value: void 0
+    });
+    _class_private_field_set(this, _options, options);
+  }
+  var _proto = SSRDataCollector2.prototype;
+  _proto.effect = function effect() {
+    var _$_class_private_field_get = _class_private_field_get(this, _options), routerContext = _$_class_private_field_get.routerContext, chunkSet = _$_class_private_field_get.chunkSet;
+    var ssrData = _class_private_method_get(this, _getSSRData, getSSRData).call(this);
+    var routerData = routerContext ? {
+      loaderData: routerContext.loaderData,
+      errors: serializeErrors(routerContext.errors)
+    } : void 0;
+    var ssrDataScripts = _class_private_method_get(this, _getSSRDataScripts, getSSRDataScripts).call(this, ssrData, routerData);
+    chunkSet.ssrScripts = ssrDataScripts;
+  };
+  return SSRDataCollector2;
+}();
+function getSSRData() {
+  var _$_class_private_field_get = _class_private_field_get(this, _options), prefetchData = _$_class_private_field_get.prefetchData, chunkSet = _$_class_private_field_get.chunkSet, ssrConfig = _$_class_private_field_get.ssrConfig, ssrContext = _$_class_private_field_get.ssrContext;
+  var reporter = ssrContext.reporter, request = ssrContext.request;
+  var headers = typeof ssrConfig === "object" && ssrConfig.unsafeHeaders ? Object.fromEntries(Object.entries(request.headers).filter(function(param) {
+    var _param = _sliced_to_array(param, 2), key = _param[0], _ = _param[1];
+    var _ssrConfig_unsafeHeaders_map, _ssrConfig_unsafeHeaders;
+    return (_ssrConfig_unsafeHeaders = ssrConfig.unsafeHeaders) === null || _ssrConfig_unsafeHeaders === void 0 ? void 0 : (_ssrConfig_unsafeHeaders_map = _ssrConfig_unsafeHeaders.map(function(header) {
+      return header.toLowerCase();
+    })) === null || _ssrConfig_unsafeHeaders_map === void 0 ? void 0 : _ssrConfig_unsafeHeaders_map.includes(key.toLowerCase());
+  })) : void 0;
+  return {
+    data: prefetchData,
+    context: {
+      request: {
+        params: request.params,
+        query: request.query,
+        pathname: request.pathname,
+        host: request.host,
+        url: request.raw.url,
+        headers
+      },
+      reporter: {
+        sessionId: reporter === null || reporter === void 0 ? void 0 : reporter.sessionId
+      }
+    },
+    mode: "string",
+    renderLevel: chunkSet.renderLevel
+  };
+}
+function getSSRDataScripts(ssrData, routerData) {
+  var _$_class_private_field_get = _class_private_field_get(this, _options), nonce = _$_class_private_field_get.nonce, ssrConfig = _$_class_private_field_get.ssrConfig;
+  var inlineScript = typeof ssrConfig === "boolean" ? true : (ssrConfig === null || ssrConfig === void 0 ? void 0 : ssrConfig.inlineScript) !== false;
+  var useInlineScript = inlineScript !== false;
+  var serializeSSRData = serializeJson(ssrData);
+  var attrsStr = attributesToString({
+    nonce
+  });
+  var ssrDataScripts = useInlineScript ? "<script".concat(attrsStr, ">window._SSR_DATA = ").concat(serializeSSRData, "</script>") : '<script type="application/json" id="'.concat(SSR_DATA_JSON_ID, '">').concat(serializeSSRData, "</script>");
+  if (routerData) {
+    var serializedRouterData = serializeJson(routerData);
+    ssrDataScripts += useInlineScript ? "\n<script".concat(attrsStr, ">window._ROUTER_DATA = ").concat(serializedRouterData, "</script>") : '\n<script type="application/json" id="'.concat(ROUTER_DATA_JSON_ID, '">').concat(serializedRouterData, "</script>");
+  }
+  return ssrDataScripts;
+}
+export {
+  SSRDataCollector
+};

package/dist/esm/core/server/string/styledComponent.js

@@ -0,0 +1,34 @@
+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 { ServerStyleSheet } from "styled-components";
+var _sheet = /* @__PURE__ */ new WeakMap(), _chunkSet = /* @__PURE__ */ new WeakMap();
+var StyledCollector = /* @__PURE__ */ function() {
+  "use strict";
+  function StyledCollector2(chunkSet) {
+    _class_call_check(this, StyledCollector2);
+    _class_private_field_init(this, _sheet, {
+      writable: true,
+      value: void 0
+    });
+    _class_private_field_init(this, _chunkSet, {
+      writable: true,
+      value: void 0
+    });
+    _class_private_field_set(this, _sheet, new ServerStyleSheet());
+    _class_private_field_set(this, _chunkSet, chunkSet);
+  }
+  var _proto = StyledCollector2.prototype;
+  _proto.collect = function collect(comopnent) {
+    return _class_private_field_get(this, _sheet).collectStyles(comopnent);
+  };
+  _proto.effect = function effect() {
+    var css = _class_private_field_get(this, _sheet).getStyleTags();
+    _class_private_field_get(this, _chunkSet).cssChunk += css;
+  };
+  return StyledCollector2;
+}();
+export {
+  StyledCollector
+};