@modern-js/runtime 2.54.6 → 2.56.0

package/dist/esm-node/{ssr/serverRender/renderToStream/renderToPipe.js → core/server/stream/createReadableStream.js}

@@ -1,46 +1,46 @@
 import { Transform } from "stream";
+import { renderToPipeableStream } from "react-dom/server";
+import { createReadableStreamFromReadable } from "@modern-js/runtime-utils/node";
 import { ServerStyleSheet } from "styled-components";
-import { RenderLevel } from "../types";
+import checkIsBot from "isbot";
 import { ESCAPED_SHELL_STREAM_END_MARK } from "../../../common";
+import { RenderLevel } from "../../constants";
 import { getTemplates } from "./template";
-var ShellChunkStatus;
-(function(ShellChunkStatus2) {
-  ShellChunkStatus2[ShellChunkStatus2["START"] = 0] = "START";
-  ShellChunkStatus2[ShellChunkStatus2["FINIESH"] = 1] = "FINIESH";
-})(ShellChunkStatus || (ShellChunkStatus = {}));
-function renderToPipe(rootElement, context, pluginConfig, options) {
-  var _context_ssrContext;
-  let shellChunkStatus = 0;
+import { ShellChunkStatus, getReadableStreamFromString } from "./shared";
+const createReadableStreamFromElement = (request, rootElement, options) => {
+  const { runtimeContext, htmlTemplate, config, ssrConfig } = options;
+  let shellChunkStatus = ShellChunkStatus.START;
+  let renderLevel = RenderLevel.SERVER_RENDER;
   const forceStream2String = Boolean(process.env.MODERN_JS_STREAM_TO_STRING);
-  const onReady = ((_context_ssrContext = context.ssrContext) === null || _context_ssrContext === void 0 ? void 0 : _context_ssrContext.isSpider) || forceStream2String ? "onAllReady" : "onShellReady";
+  const isbot = checkIsBot(request.headers.get("user-agent"));
+  const onReady = isbot || forceStream2String ? "onAllReady" : "onShellReady";
   const sheet = new ServerStyleSheet();
-  const { ssrContext } = context;
   const chunkVec = [];
-  const forUserPipe = new Promise((resolve) => {
-    let renderToPipeableStream;
-    try {
-      ({ renderToPipeableStream } = require("react-dom/server"));
-    } catch (e) {
-    }
-    const root = forceStream2String ? sheet.collectStyles(rootElement) : rootElement;
-    let renderLevel = RenderLevel.SERVER_RENDER;
+  const root = forceStream2String ? sheet.collectStyles(rootElement) : rootElement;
+  return new Promise((resolve) => {
     const { pipe } = renderToPipeableStream(root, {
-      ...options,
-      nonce: ssrContext === null || ssrContext === void 0 ? void 0 : ssrContext.nonce,
+      nonce: config.nonce,
       [onReady]() {
+        var _options_onReady;
         const styledComponentsStyleTags = forceStream2String ? sheet.getStyleTags() : "";
-        getTemplates(context, renderLevel, pluginConfig, styledComponentsStyleTags).then(({ shellAfter, shellBefore }) => {
-          var _options_onReady;
-          options === null || options === void 0 ? void 0 : (_options_onReady = options[onReady]) === null || _options_onReady === void 0 ? void 0 : _options_onReady.call(options);
-          const injectableTransform = new Transform({
+        (_options_onReady = options[onReady]) === null || _options_onReady === void 0 ? void 0 : _options_onReady.call(options);
+        getTemplates(htmlTemplate, {
+          request,
+          ssrConfig,
+          renderLevel,
+          runtimeContext,
+          config,
+          styledComponentsStyleTags
+        }).then(({ shellAfter, shellBefore }) => {
+          const body = new Transform({
             transform(chunk, _encoding, callback) {
               try {
-                if (shellChunkStatus !== 1) {
+                if (shellChunkStatus !== ShellChunkStatus.FINISH) {
                   chunkVec.push(chunk.toString());
                   let concatedChunk = chunkVec.join("");
                   if (concatedChunk.includes(ESCAPED_SHELL_STREAM_END_MARK)) {
                     concatedChunk = concatedChunk.replace(ESCAPED_SHELL_STREAM_END_MARK, "");
-                    shellChunkStatus = 1;
+                    shellChunkStatus = ShellChunkStatus.FINISH;
                     this.push(`${shellBefore}${concatedChunk}${shellAfter}`);
                   }
                 } else {
@@ -56,16 +56,24 @@ function renderToPipe(rootElement, context, pluginConfig, options) {
               }
             }
           });
-          pipe(injectableTransform);
-          resolve(injectableTransform);
+          const stream = createReadableStreamFromReadable(body);
+          resolve(stream);
+          pipe(body);
         });
       },
       onShellError(error) {
         renderLevel = RenderLevel.CLIENT_RENDER;
-        getTemplates(context, renderLevel, pluginConfig).then(({ shellAfter, shellBefore }) => {
+        getTemplates(htmlTemplate, {
+          request,
+          ssrConfig,
+          renderLevel,
+          runtimeContext,
+          config
+        }).then(({ shellAfter, shellBefore }) => {
           var _options_onShellError;
           const fallbackHtml = `${shellBefore}${shellAfter}`;
-          resolve(fallbackHtml);
+          const readableStream = getReadableStreamFromString(fallbackHtml);
+          resolve(readableStream);
           options === null || options === void 0 ? void 0 : (_options_onShellError = options.onShellError) === null || _options_onShellError === void 0 ? void 0 : _options_onShellError.call(options, error);
         });
       },
@@ -76,9 +84,7 @@ function renderToPipe(rootElement, context, pluginConfig, options) {
       }
     });
   });
-  return forUserPipe;
-}
-var renderToPipe_default = renderToPipe;
+};
 export {
-  renderToPipe_default as default
+  createReadableStreamFromElement
 };

package/dist/esm-node/core/server/stream/createReadableStream.worker.js

@@ -0,0 +1,71 @@
+import { renderToReadableStream } from "react-dom/server";
+import checkIsBot from "isbot";
+import { RenderLevel } from "../../constants";
+import { ESCAPED_SHELL_STREAM_END_MARK } from "../../../common";
+import { ShellChunkStatus, encodeForWebStream, getReadableStreamFromString } from "./shared";
+import { getTemplates } from "./template";
+const createReadableStreamFromElement = async (request, rootElement, options) => {
+  let shellChunkStatus = ShellChunkStatus.START;
+  const chunkVec = [];
+  const { htmlTemplate, runtimeContext, config, ssrConfig } = options;
+  const { shellBefore, shellAfter } = await getTemplates(htmlTemplate, {
+    renderLevel: RenderLevel.SERVER_RENDER,
+    runtimeContext,
+    ssrConfig,
+    request,
+    config
+  });
+  try {
+    var _options_onShellReady;
+    const readableOriginal = await renderToReadableStream(rootElement, {
+      nonce: config.nonce,
+      onError(error) {
+        var _options_onError;
+        (_options_onError = options.onError) === null || _options_onError === void 0 ? void 0 : _options_onError.call(options, error);
+      }
+    });
+    (_options_onShellReady = options.onShellReady) === null || _options_onShellReady === void 0 ? void 0 : _options_onShellReady.call(options);
+    readableOriginal.allReady.then(() => {
+      var _options_onAllReady;
+      options === null || options === void 0 ? void 0 : (_options_onAllReady = options.onAllReady) === null || _options_onAllReady === void 0 ? void 0 : _options_onAllReady.call(options);
+    });
+    const isbot = checkIsBot(request.headers.get("user-agent"));
+    if (isbot) {
+      await readableOriginal.allReady;
+    }
+    const reader = readableOriginal.getReader();
+    const stream = new ReadableStream({
+      start(controller) {
+        async function push() {
+          const { done, value } = await reader.read();
+          if (done) {
+            controller.close();
+            return;
+          }
+          if (shellChunkStatus !== ShellChunkStatus.FINISH) {
+            const chunk = new TextDecoder().decode(value);
+            chunkVec.push(chunk);
+            let concatedChunk = chunkVec.join("");
+            if (concatedChunk.endsWith(ESCAPED_SHELL_STREAM_END_MARK)) {
+              concatedChunk = concatedChunk.replace(ESCAPED_SHELL_STREAM_END_MARK, "");
+              shellChunkStatus = ShellChunkStatus.FINISH;
+              controller.enqueue(encodeForWebStream(`${shellBefore}${concatedChunk}${shellAfter}`));
+            }
+          } else {
+            controller.enqueue(value);
+          }
+          push();
+        }
+        push();
+      }
+    });
+    return stream;
+  } catch (e) {
+    const fallbackHtml = `${shellBefore}${shellAfter}`;
+    const stream = getReadableStreamFromString(fallbackHtml);
+    return stream;
+  }
+};
+export {
+  createReadableStreamFromElement
+};

package/dist/esm-node/core/server/stream/index.js

@@ -0,0 +1,6 @@
+import { createReadableStreamFromElement } from "./createReadableStream";
+import { createRenderStreaming } from "./shared";
+const renderStreaming = createRenderStreaming(createReadableStreamFromElement);
+export {
+  renderStreaming
+};

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

@@ -0,0 +1,75 @@
+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 = {}));
+let encoder;
+function encodeForWebStream(thing) {
+  if (!encoder) {
+    encoder = new TextEncoder();
+  }
+  if (typeof thing === "string") {
+    return encoder.encode(thing);
+  }
+  return thing;
+}
+function getReadableStreamFromString(content) {
+  const readableStream = new ReadableStream({
+    start(controller) {
+      controller.enqueue(encodeForWebStream(content));
+      controller.close();
+    }
+  });
+  return readableStream;
+}
+function createRenderStreaming(createReadableStreamFromElement) {
+  return async (request, serverRoot, options) => {
+    const headersData = parseHeaders(request);
+    return run(headersData, async () => {
+      const end = time();
+      const { runtimeContext, config, resource, staticGenerate } = options;
+      const onError = createOnError(options.onError);
+      const onTiming = createOnTiming(options.onTiming);
+      const { htmlTemplate, entryName } = resource;
+      const ssrConfig = getSSRConfigByEntry(entryName, config.ssr, config.ssrByEntries, staticGenerate);
+      const rootElement = React.cloneElement(serverRoot, {
+        _internal_context: Object.assign(runtimeContext, {
+          ssr: true
+        })
+      });
+      const stream = await createReadableStreamFromElement(request, rootElement, {
+        config,
+        htmlTemplate,
+        runtimeContext,
+        ssrConfig,
+        onShellReady() {
+          const cost = end();
+          onTiming(SSRTimings.RENDER_SHELL, cost);
+        },
+        onAllReady() {
+          const cost = end();
+          onTiming(SSRTimings.RENDER_HTML, cost);
+        },
+        onShellError(error) {
+          onError(SSRErrors.RENDER_SHELL, error);
+        },
+        onError(error) {
+          onError(SSRErrors.RENDER_STREAM, error);
+        }
+      });
+      return stream;
+    });
+  };
+}
+export {
+  ShellChunkStatus,
+  createRenderStreaming,
+  encodeForWebStream,
+  getReadableStreamFromString
+};

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

@@ -0,0 +1,15 @@
+import { buildShellBeforeTemplate } from "./beforeTemplate";
+import { buildShellAfterTemplate } from "./afterTemplate";
+const HTML_SEPARATOR = "<!--<?- html ?>-->";
+const getTemplates = async (htmlTemplate, options) => {
+  const [beforeAppTemplate = "", afterAppHtmlTemplate = ""] = htmlTemplate.split(HTML_SEPARATOR) || [];
+  const builtBeforeTemplate = await buildShellBeforeTemplate(beforeAppTemplate, options);
+  const builtAfterTemplate = await buildShellAfterTemplate(afterAppHtmlTemplate, options);
+  return {
+    shellBefore: builtBeforeTemplate,
+    shellAfter: builtAfterTemplate
+  };
+};
+export {
+  getTemplates
+};

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

@@ -0,0 +1,118 @@
+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";
+const renderString = async (request, serverRoot, options) => {
+  const headersData = parseHeaders(request);
+  return run(headersData, async () => {
+    var _runtimeContext_ssrContext;
+    const { resource, runtimeContext, config, onError, onTiming, staticGenerate } = options;
+    const tracer = {
+      onError: createOnError(onError),
+      onTiming: createOnTiming(onTiming)
+    };
+    const routerContext = runtimeContext.routerContext;
+    const { htmlTemplate, entryName, loadableStats, routeManifest } = resource;
+    const ssrConfig = getSSRConfigByEntry(entryName, config.ssr, config.ssrByEntries, staticGenerate);
+    const chunkSet = {
+      renderLevel: RenderLevel.CLIENT_RENDER,
+      ssrScripts: "",
+      jsChunk: "",
+      cssChunk: ""
+    };
+    let prefetchData = {};
+    try {
+      prefetchData = await prefetch(serverRoot, request, options, ssrConfig, tracer);
+      chunkSet.renderLevel = RenderLevel.SERVER_PREFETCH;
+    } catch (e) {
+      chunkSet.renderLevel = RenderLevel.CLIENT_RENDER;
+    }
+    const 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
+      })
+    ];
+    const rootElement = React.cloneElement(serverRoot, {
+      _internal_context: Object.assign(runtimeContext, {
+        ssr: true
+      })
+    });
+    const html = await generateHtml(rootElement, htmlTemplate, chunkSet, collectors, ((_runtimeContext_ssrContext = runtimeContext.ssrContext) === null || _runtimeContext_ssrContext === void 0 ? void 0 : _runtimeContext_ssrContext.htmlModifiers) || [], tracer);
+    return html;
+  });
+};
+async function generateHtml(App, htmlTemplate, chunkSet, collectors, htmlModifiers, { onError, onTiming }) {
+  const end = time();
+  let html = "";
+  let helmetData;
+  if (chunkSet.renderLevel >= RenderLevel.SERVER_PREFETCH) {
+    try {
+      const finalApp = collectors.reduce((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;
+      await Promise.all(collectors.map((component) => component.effect()));
+      const cost = end();
+      onTiming(SSRTimings.RENDER_HTML, cost);
+    } catch (e) {
+      chunkSet.renderLevel = RenderLevel.CLIENT_RENDER;
+      onError(SSRErrors.RENDER_HTML, e);
+    }
+  }
+  const { ssrScripts, cssChunk, jsChunk } = chunkSet;
+  const finalHtml = await buildHtml(htmlTemplate, [
+    createReplaceHtml(html),
+    createReplaceChunkJs(jsChunk),
+    createReplaceChunkCss(cssChunk),
+    createReplaceSSRDataScript(ssrScripts),
+    createReplaceHelemt(helmetData),
+    ...htmlModifiers
+  ]);
+  return finalHtml;
+}
+function createReplaceHtml(html) {
+  return (template) => safeReplace(template, HTML_PLACEHOLDER, html);
+}
+function createReplaceSSRDataScript(data) {
+  return (template) => safeReplace(template, SSR_DATA_PLACEHOLDER, data);
+}
+function createReplaceChunkJs(js) {
+  return (template) => safeReplace(template, CHUNK_JS_PLACEHOLDER, js);
+}
+function createReplaceChunkCss(css) {
+  return (template) => safeReplace(template, CHUNK_CSS_PLACEHOLDER, css);
+}
+export {
+  renderString
+};

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

@@ -61,13 +61,12 @@ class LoadableCollector {
     if (!check(scripts)) {
       return;
     }
-    const { result: { chunksMap } } = this.options;
+    const { chunkSet } = this.options;
     const s = scripts.split("</script>").slice(0, 2).map((i) => `${i}</script>`).join("");
-    chunksMap.js += s;
+    chunkSet.jsChunk += s;
   }
   async emitScriptAssets(chunks) {
-    const { template, config, nonce, result } = this.options;
-    const { chunksMap } = result;
+    const { template, nonce, chunkSet, config } = this.options;
     const { scriptLoading = "defer", enableInlineScripts } = config;
     const scriptLoadingAtr = {
       defer: scriptLoading === "defer" ? true : void 0,
@@ -92,10 +91,11 @@ class LoadableCollector {
         return script;
       }
     }));
-    chunksMap.js += scripts.filter((script) => Boolean(script)).join("");
+    chunkSet.jsChunk += scripts.filter((script) => Boolean(script)).join("");
   }
   async emitStyleAssets(chunks) {
-    const { template, result: { chunksMap }, config: { enableInlineStyles } } = this.options;
+    const { template, chunkSet, config } = this.options;
+    const { enableInlineStyles } = config;
     const atrributes = attributesToString(this.generateAttributes());
     const css = await Promise.all(chunks.filter((chunk) => {
       var _this_existsAssets;
@@ -111,7 +111,7 @@ class LoadableCollector {
         return link;
       }
     }));
-    chunksMap.css += css.filter((css2) => Boolean(css2)).join("");
+    chunkSet.jsChunk += css.filter((css2) => Boolean(css2)).join("");
   }
   generateAttributes(extraAtr = {}) {
     const { config } = this.options;
@@ -129,9 +129,6 @@ class LoadableCollector {
     this.options = options;
   }
 }
-function createLoadableCollector(options) {
-  return new LoadableCollector(options);
-}
 export {
-  createLoadableCollector
+  LoadableCollector
 };

package/dist/esm-node/core/server/string/prefetch.js

@@ -0,0 +1,78 @@
+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 { parseHeaders } from "@modern-js/runtime-utils/universal/request";
+import React from "react";
+import { SSRErrors, SSRTimings } from "../tracer";
+const prefetch = async (App, request, options, ssrConfig, { onError, onTiming }) => {
+  const headersData = parseHeaders(request);
+  const { runtimeContext: context, resource } = options;
+  const { entryName, loadableStats } = resource;
+  return run(headersData, async () => {
+    var _context_store;
+    if (typeof ssrConfig === "boolean" || !ssrConfig.disablePrerender) {
+      try {
+        const end = time();
+        if (loadableStats) {
+          const extractor = new ChunkExtractor({
+            stats: loadableStats,
+            entrypoints: [
+              entryName
+            ].filter(Boolean)
+          });
+          renderToStaticMarkup(extractor.collectChunks(/* @__PURE__ */ React.cloneElement(App, {
+            _internal_context: Object.assign(context, {
+              ssr: false
+            })
+          })));
+        } else {
+          renderToStaticMarkup(/* @__PURE__ */ React.cloneElement(App, {
+            _internal_context: Object.assign(context, {
+              ssr: false
+            })
+          }));
+        }
+        const cost = end();
+        onTiming(SSRTimings.PRERENDER, cost);
+      } catch (e) {
+        const error = e;
+        onError(SSRErrors.PRERENDER, error);
+        throw e;
+      }
+    }
+    if (!context.loaderManager.hasPendingLoaders()) {
+      return {
+        initialData: context.initialData,
+        i18nData: context.__i18nData__
+      };
+    }
+    let loadersData = {};
+    try {
+      const end = time();
+      loadersData = await context.loaderManager.awaitPendingLoaders();
+      const cost = end();
+      onTiming(SSRTimings.USE_LOADER, cost);
+    } catch (e) {
+      onError(SSRErrors.USE_LOADER, e);
+      throw e;
+    }
+    Object.keys(loadersData).forEach((id) => {
+      const data = loadersData[id];
+      if (data._error) {
+        onError(SSRErrors.USE_LOADER, data._error);
+        delete data._error;
+      }
+    });
+    return {
+      loadersData,
+      initialData: context.initialData,
+      i18nData: context.__i18nData__,
+      // todo: move to plugin state
+      storeState: context === null || context === void 0 ? void 0 : (_context_store = context.store) === null || _context_store === void 0 ? void 0 : _context_store.getState()
+    };
+  });
+};
+export {
+  prefetch
+};

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

@@ -0,0 +1,76 @@
+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 { 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();
+class SSRDataCollector {
+  effect() {
+    const { routerContext, chunkSet } = _class_private_field_get(this, _options);
+    const ssrData = _class_private_method_get(this, _getSSRData, getSSRData).call(this);
+    const routerData = routerContext ? {
+      loaderData: routerContext.loaderData,
+      errors: serializeErrors(routerContext.errors)
+    } : void 0;
+    const ssrDataScripts = _class_private_method_get(this, _getSSRDataScripts, getSSRDataScripts).call(this, ssrData, routerData);
+    chunkSet.ssrScripts = ssrDataScripts;
+  }
+  constructor(options) {
+    _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);
+  }
+}
+function getSSRData() {
+  const { prefetchData, chunkSet, ssrConfig, ssrContext } = _class_private_field_get(this, _options);
+  const { reporter, request } = ssrContext;
+  const headers = typeof ssrConfig === "object" && ssrConfig.unsafeHeaders ? Object.fromEntries(Object.entries(request.headers).filter(([key, _]) => {
+    var _ssrConfig_unsafeHeaders_map, _ssrConfig_unsafeHeaders;
+    return (_ssrConfig_unsafeHeaders = ssrConfig.unsafeHeaders) === null || _ssrConfig_unsafeHeaders === void 0 ? void 0 : (_ssrConfig_unsafeHeaders_map = _ssrConfig_unsafeHeaders.map((header) => 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) {
+  const { nonce, ssrConfig } = _class_private_field_get(this, _options);
+  const inlineScript = typeof ssrConfig === "boolean" ? true : (ssrConfig === null || ssrConfig === void 0 ? void 0 : ssrConfig.inlineScript) !== false;
+  const useInlineScript = inlineScript !== false;
+  const serializeSSRData = serializeJson(ssrData);
+  const attrsStr = attributesToString({
+    nonce
+  });
+  let ssrDataScripts = useInlineScript ? `<script${attrsStr}>window._SSR_DATA = ${serializeSSRData}</script>` : `<script type="application/json" id="${SSR_DATA_JSON_ID}">${serializeSSRData}</script>`;
+  if (routerData) {
+    const serializedRouterData = serializeJson(routerData);
+    ssrDataScripts += useInlineScript ? `
+<script${attrsStr}>window._ROUTER_DATA = ${serializedRouterData}</script>` : `
+<script type="application/json" id="${ROUTER_DATA_JSON_ID}">${serializedRouterData}</script>`;
+  }
+  return ssrDataScripts;
+}
+export {
+  SSRDataCollector
+};

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

@@ -0,0 +1,29 @@
+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();
+class StyledCollector {
+  collect(comopnent) {
+    return _class_private_field_get(this, _sheet).collectStyles(comopnent);
+  }
+  effect() {
+    const css = _class_private_field_get(this, _sheet).getStyleTags();
+    _class_private_field_get(this, _chunkSet).cssChunk += css;
+  }
+  constructor(chunkSet) {
+    _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);
+  }
+}
+export {
+  StyledCollector
+};

package/dist/esm-node/core/server/tracer.js

@@ -0,0 +1,33 @@
+var SSRTimings;
+(function(SSRTimings2) {
+  SSRTimings2["PRERENDER"] = "ssr-prerender";
+  SSRTimings2["RENDER_HTML"] = "ssr-render-html";
+  SSRTimings2["RENDER_SHELL"] = "ssr-render-shell";
+  SSRTimings2["USE_LOADER"] = "use-loader";
+})(SSRTimings || (SSRTimings = {}));
+var SSRErrors;
+(function(SSRErrors2) {
+  SSRErrors2["PRERENDER"] = "App Prerender";
+  SSRErrors2["USE_LOADER"] = "App run useLoader";
+  SSRErrors2["RENDER_HTML"] = "App Render To HTML";
+  SSRErrors2["RENDER_STREAM"] = "An error occurs during streaming SSR";
+  SSRErrors2["RENDER_SHELL"] = "An error occurs during streaming render shell";
+})(SSRErrors || (SSRErrors = {}));
+function createOnError(onError) {
+  return (key, e) => {
+    const error = e instanceof Error ? e : new Error("Unexpected Server Error");
+    error.name = key;
+    onError === null || onError === void 0 ? void 0 : onError(e);
+  };
+}
+function createOnTiming(onTiming) {
+  return (key, cost) => {
+    onTiming === null || onTiming === void 0 ? void 0 : onTiming(key, cost);
+  };
+}
+export {
+  SSRErrors,
+  SSRTimings,
+  createOnError,
+  createOnTiming
+};