@modern-js/runtime 2.69.5 → 3.0.0-alpha.0

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

@@ -1,76 +0,0 @@
-import { runRouterDataFnStr } from "../../../router/runtime/constants";
-const HTML_ESCAPE_MAP = {
-  "&": "&",
-  "<": "&lt;",
-  ">": "&gt;",
-  '"': "&quot;",
-  "'": "&#39;"
-};
-function escapeAttr(value) {
-  return value.replace(/[&<>"']/g, (ch) => HTML_ESCAPE_MAP[ch]);
-}
-function isRecord(v) {
-  return typeof v === "object" && v !== null;
-}
-function isDeferredDataLike(v) {
-  if (!isRecord(v))
-    return false;
-  const hasPending = "pendingKeys" in v && Array.isArray(v.pendingKeys);
-  const hasData = "data" in v && isRecord(v.data);
-  return hasPending && hasData;
-}
-function isPromiseLike(value) {
-  return !!value && typeof value.then === "function";
-}
-function toErrorInfo(error) {
-  if (error && typeof error === "object") {
-    const maybeMsg = error.message;
-    const maybeStack = error.stack;
-    return {
-      message: typeof maybeMsg === "string" ? maybeMsg : String(maybeMsg !== null && maybeMsg !== void 0 ? maybeMsg : error),
-      stack: process.env.NODE_ENV !== "production" ? maybeStack : void 0
-    };
-  }
-  return {
-    message: String(error)
-  };
-}
-function buildDeferredDataScript(nonce, args) {
-  const payload = JSON.stringify(args);
-  const escaped = escapeAttr(payload);
-  const nonceAttr = nonce ? ` nonce="${nonce}"` : "";
-  return `<script async${nonceAttr} data-fn-name="r" data-script-src="modern-run-router-data-fn" data-fn-args='${escaped}' suppressHydrationWarning>${runRouterDataFnStr}</script>`;
-}
-function enqueueFromEntries(entries, nonce, emit) {
-  entries.forEach(([routeId, value]) => {
-    if (!isDeferredDataLike(value))
-      return;
-    var _value_pendingKeys;
-    const pendingKeys = new Set((_value_pendingKeys = value.pendingKeys) !== null && _value_pendingKeys !== void 0 ? _value_pendingKeys : []);
-    pendingKeys.forEach((key) => {
-      var _value_data;
-      const tracked = (_value_data = value.data) === null || _value_data === void 0 ? void 0 : _value_data[key];
-      if (isPromiseLike(tracked)) {
-        tracked.then((val) => emit(buildDeferredDataScript(nonce, [
-          routeId,
-          key,
-          val
-        ])), (err) => emit(buildDeferredDataScript(nonce, [
-          routeId,
-          key,
-          void 0,
-          toErrorInfo(err)
-        ])));
-      }
-    });
-  });
-}
-export {
-  buildDeferredDataScript,
-  enqueueFromEntries,
-  escapeAttr,
-  isDeferredDataLike,
-  isPromiseLike,
-  isRecord,
-  toErrorInfo
-};

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

@@ -1,6 +0,0 @@
-import { createRenderStreaming } from "./shared";
-const createReadableStreamFromElement = process.env.MODERN_SSR_ENV === "edge" ? import("./createReadableStream.worker").then((m) => m.createReadableStreamFromElement) : import("./createReadableStream").then((m) => m.createReadableStreamFromElement);
-const renderStreaming = createRenderStreaming(createReadableStreamFromElement);
-export {
-  renderStreaming
-};

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

@@ -1,82 +0,0 @@
-import { jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
-import { time } from "@modern-js/runtime-utils/time";
-import { wrapRuntimeContextProvider } from "../../react/wrapper";
-import { SSRErrors, SSRTimings } 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(createReadableStreamPromise) {
-  return async (request, serverRoot, options) => {
-    const createReadableStreamFromElement = await createReadableStreamPromise;
-    const end = time();
-    const { runtimeContext, config, resource } = options;
-    const { onError, onTiming } = options;
-    const { htmlTemplate, entryName } = resource;
-    const ssrConfig = getSSRConfigByEntry(entryName, config.ssr, config.ssrByEntries);
-    const RSCServerRoot = ({ children }) => {
-      return /* @__PURE__ */ _jsx(_Fragment, {
-        children
-      });
-    };
-    let rootElement = wrapRuntimeContextProvider(serverRoot, Object.assign(runtimeContext, {
-      ssr: true
-    }));
-    rootElement = /* @__PURE__ */ _jsx(RSCServerRoot, {
-      children: rootElement
-    });
-    const stream = await createReadableStreamFromElement(request, rootElement, {
-      config,
-      htmlTemplate,
-      runtimeContext,
-      ssrConfig,
-      entryName,
-      rscClientManifest: options.rscClientManifest,
-      rscSSRManifest: options.rscSSRManifest,
-      rscServerManifest: options.rscServerManifest,
-      rscRoot: options.rscRoot,
-      onShellReady() {
-        const cost = end();
-        onTiming(SSRTimings.RENDER_SHELL, cost);
-      },
-      onAllReady() {
-        const cost = end();
-        onTiming(SSRTimings.RENDER_HTML, cost);
-      },
-      onShellError(error) {
-        onError(error, SSRErrors.RENDER_SHELL);
-      },
-      onError(error) {
-        onError(error, SSRErrors.RENDER_STREAM);
-      }
-    });
-    return stream;
-  };
-}
-export {
-  ShellChunkStatus,
-  createRenderStreaming,
-  encodeForWebStream,
-  getReadableStreamFromString
-};

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

@@ -1,15 +0,0 @@
-import { buildShellAfterTemplate } from "./afterTemplate";
-import { buildShellBeforeTemplate } from "./beforeTemplate";
-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

@@ -1,113 +0,0 @@
-import { time } from "@modern-js/runtime-utils/time";
-import ReactDomServer from "react-dom/server";
-import ReactHelmet from "react-helmet";
-import { RenderLevel } from "../../constants";
-import { wrapRuntimeContextProvider } from "../../react/wrapper";
-import { CHUNK_CSS_PLACEHOLDER, CHUNK_JS_PLACEHOLDER, HTML_PLACEHOLDER, SSR_DATA_PLACEHOLDER } from "../constants";
-import { createReplaceHelemt } from "../helmet";
-import { buildHtml } from "../shared";
-import { SSRErrors, SSRTimings } from "../tracer";
-import { getSSRConfigByEntry, safeReplace } from "../utils";
-import { LoadableCollector } from "./loadable";
-import { prefetch } from "./prefetch";
-import { SSRDataCollector } from "./ssrData";
-import { StyledCollector } from "./styledComponent";
-const renderString = async (request, serverRoot, options) => {
-  var _runtimeContext_ssrContext;
-  const { resource, runtimeContext, config, onError, onTiming } = options;
-  const tracer = {
-    onError,
-    onTiming
-  };
-  const routerContext = runtimeContext.routerContext;
-  const { htmlTemplate, entryName, loadableStats, routeManifest } = resource;
-  const ssrConfig = getSSRConfigByEntry(entryName, config.ssr, config.ssrByEntries);
-  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;
-    tracer.onError(e, SSRErrors.PRERENDER);
-  }
-  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,
-      useJsonScript: config.useJsonScript
-    })
-  ];
-  const rootElement = wrapRuntimeContextProvider(serverRoot, 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 }) {
-  let html = "";
-  let helmetData;
-  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);
-  try {
-    const end = time();
-    if (chunkSet.renderLevel >= RenderLevel.SERVER_PREFETCH) {
-      html = ReactDomServer.renderToString(finalApp);
-      chunkSet.renderLevel = RenderLevel.SERVER_RENDER;
-    }
-    helmetData = ReactHelmet.renderStatic();
-    const cost = end();
-    onTiming(SSRTimings.RENDER_HTML, cost);
-  } catch (e) {
-    chunkSet.renderLevel = RenderLevel.CLIENT_RENDER;
-    onError(e, SSRErrors.RENDER_HTML);
-  }
-  await Promise.all(collectors.map((component) => component.effect()));
-  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/core/server/string/loadable.js

@@ -1,154 +0,0 @@
-import { ChunkExtractor } from "@loadable/server";
-import { attributesToString, checkIsNode } from "../utils";
-const extname = (uri) => {
-  if (typeof uri !== "string" || !uri.includes(".")) {
-    return "";
-  }
-  return `.${uri === null || uri === void 0 ? void 0 : uri.split(".").pop()}` || "";
-};
-const generateChunks = (chunks, ext) => chunks.filter((chunk) => Boolean(chunk.url)).filter((chunk) => extname(chunk.url).slice(1) === ext);
-const checkIsInline = (chunk, enableInline) => {
-  if (process.env.NODE_ENV === "production") {
-    if (enableInline instanceof RegExp) {
-      return enableInline.test(chunk.url);
-    } else {
-      return Boolean(enableInline);
-    }
-  } else {
-    return false;
-  }
-};
-const readAsset = async (chunk) => {
-  const fs = await import("fs/promises");
-  const path = await import("path");
-  const filepath = path.resolve(__dirname, chunk.filename);
-  return fs.readFile(filepath, "utf-8");
-};
-class LoadableCollector {
-  get existsAssets() {
-    var _routeManifest_routeAssets_entryName, _routeManifest_routeAssets;
-    const { routeManifest, entryName } = this.options;
-    return routeManifest === null || routeManifest === void 0 ? void 0 : (_routeManifest_routeAssets = routeManifest.routeAssets) === null || _routeManifest_routeAssets === void 0 ? void 0 : (_routeManifest_routeAssets_entryName = _routeManifest_routeAssets[entryName]) === null || _routeManifest_routeAssets_entryName === void 0 ? void 0 : _routeManifest_routeAssets_entryName.assets;
-  }
-  collect(comopnent) {
-    const { stats, entryName } = this.options;
-    if (!stats) {
-      return comopnent;
-    }
-    this.extractor = new ChunkExtractor({
-      stats,
-      entrypoints: [
-        entryName
-      ]
-    });
-    return this.extractor.collectChunks(comopnent);
-  }
-  async effect() {
-    if (!this.extractor) {
-      return;
-    }
-    const { extractor, options } = this;
-    const { entryName, config } = options;
-    const asyncChunks = [];
-    if (config.enableAsyncEntry) {
-      try {
-        asyncChunks.push(...extractor.getChunkAssets([
-          `async-${entryName}`
-        ]));
-      } catch (e) {
-      }
-    }
-    const chunks = [].concat(asyncChunks).concat(extractor.getChunkAssets(extractor.chunks));
-    const scriptChunks = generateChunks(chunks, "js");
-    const styleChunks = generateChunks(chunks, "css");
-    this.emitLoadableScripts(extractor);
-    await this.emitScriptAssets(scriptChunks);
-    await this.emitStyleAssets(styleChunks);
-  }
-  emitLoadableScripts(extractor) {
-    const check = (scripts2) => (scripts2 || "").includes("__LOADABLE_REQUIRED_CHUNKS___ext");
-    const scripts = extractor.getScriptTags();
-    if (!check(scripts)) {
-      return;
-    }
-    const { chunkSet } = this.options;
-    const s = scripts.split("</script>").slice(0, 2).map((i) => `${i}</script>`).join("");
-    chunkSet.jsChunk += s;
-  }
-  async emitScriptAssets(chunks) {
-    const { template, nonce, chunkSet, config } = this.options;
-    const { scriptLoading = "defer", enableInlineScripts } = config;
-    const scriptLoadingAtr = {
-      defer: scriptLoading === "defer" ? true : void 0,
-      type: scriptLoading === "module" ? "module" : void 0,
-      async: scriptLoading === "async" ? true : void 0
-    };
-    const attributes = attributesToString(this.generateAttributes({
-      nonce,
-      ...scriptLoadingAtr
-    }));
-    const jsScriptRegExp = /<script .*?src="([^"]+)".*?>/g;
-    const matchs = template.matchAll(jsScriptRegExp);
-    const existedScript = [];
-    for (const match of matchs) {
-      existedScript.push(match[1]);
-    }
-    const scripts = await Promise.all(chunks.filter((chunk) => {
-      var _this_existsAssets;
-      return !existedScript.includes(chunk.url) && !((_this_existsAssets = this.existsAssets) === null || _this_existsAssets === void 0 ? void 0 : _this_existsAssets.includes(chunk.path));
-    }).map(async (chunk) => {
-      const script = `<script${attributes} src="${chunk.url}"></script>`;
-      if (checkIsNode() && checkIsInline(chunk, enableInlineScripts)) {
-        return readAsset(chunk).then((content) => `<script>${content}</script>`).catch((_) => {
-          return script;
-        });
-      } else {
-        return script;
-      }
-    }));
-    chunkSet.jsChunk += scripts.filter((script) => Boolean(script)).join("");
-  }
-  async emitStyleAssets(chunks) {
-    const { template, chunkSet, config, entryName } = this.options;
-    const { enableInlineStyles } = config;
-    const atrributes = attributesToString(this.generateAttributes());
-    const linkRegExp = /<link .*?href="([^"]+)".*?>/g;
-    const matchs = template.matchAll(linkRegExp);
-    const existedLinks = [];
-    for (const match of matchs) {
-      existedLinks.push(match[1]);
-    }
-    const css = await Promise.all(chunks.filter((chunk) => {
-      var _this_existsAssets;
-      return !existedLinks.includes(chunk.url) && !((_this_existsAssets = this.existsAssets) === null || _this_existsAssets === void 0 ? void 0 : _this_existsAssets.includes(chunk.path));
-    }).map(async (chunk) => {
-      const link = `<link${atrributes} href="${chunk.url}" rel="stylesheet" />`;
-      if (checkIsNode() && checkIsInline(chunk, enableInlineStyles)) {
-        return readAsset(chunk).then((content) => `<style>${content}</style>`).catch((_) => {
-          return link;
-        });
-      } else {
-        return link;
-      }
-    }));
-    chunkSet.cssChunk += css.filter((css2) => Boolean(css2)).join("");
-  }
-  generateAttributes(extraAtr = {}) {
-    const { config } = this.options;
-    const { crossorigin } = config;
-    const attributes = {};
-    if (crossorigin) {
-      attributes.crossorigin = crossorigin === true ? "anonymous" : crossorigin;
-    }
-    return {
-      ...attributes,
-      ...extraAtr
-    };
-  }
-  constructor(options) {
-    this.options = options;
-  }
-}
-export {
-  LoadableCollector
-};

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

@@ -1,69 +0,0 @@
-import { ChunkExtractor } from "@loadable/server";
-import { time } from "@modern-js/runtime-utils/time";
-import { renderToStaticMarkup } from "react-dom/server";
-import { wrapRuntimeContextProvider } from "../../react/wrapper";
-import { SSRErrors, SSRTimings } from "../tracer";
-const prefetch = async (App, request, options, ssrConfig, { onError, onTiming }) => {
-  var _context_store;
-  const { runtimeContext: context, resource } = options;
-  const { entryName, loadableStats } = resource;
-  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(wrapRuntimeContextProvider(App, Object.assign(context, {
-          ssr: false
-        }))));
-      } else {
-        renderToStaticMarkup(wrapRuntimeContextProvider(App, Object.assign(context, {
-          ssr: false
-        })));
-      }
-      const cost = end();
-      onTiming(SSRTimings.PRERENDER, cost);
-    } catch (e) {
-      const error = e;
-      onError(error, SSRErrors.PRERENDER);
-      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(e, SSRErrors.USE_LOADER);
-    throw e;
-  }
-  Object.keys(loadersData).forEach((id) => {
-    const data = loadersData[id];
-    if (data._error) {
-      onError(data._error, SSRErrors.USE_LOADER);
-      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

@@ -1,74 +0,0 @@
-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 { ROUTER_DATA_JSON_ID, SSR_DATA_JSON_ID } from "../../constants";
-import { attributesToString, serializeErrors } from "../utils";
-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.url,
-        headers
-      },
-      reporter: {
-        sessionId: reporter === null || reporter === void 0 ? void 0 : reporter.sessionId
-      }
-    },
-    mode: "string",
-    renderLevel: chunkSet.renderLevel
-  };
-}
-function getSSRDataScripts(ssrData, routerData) {
-  const { nonce, useJsonScript = false } = _class_private_field_get(this, _options);
-  const serializeSSRData = serializeJson(ssrData);
-  const attrsStr = attributesToString({
-    nonce
-  });
-  let ssrDataScripts = useJsonScript ? `<script type="application/json" id="${SSR_DATA_JSON_ID}">${serializeSSRData}</script>` : `<script${attrsStr}>window._SSR_DATA = ${serializeSSRData}</script>`;
-  if (routerData) {
-    const serializedRouterData = serializeJson(routerData);
-    ssrDataScripts += useJsonScript ? `
-<script type="application/json" id="${ROUTER_DATA_JSON_ID}">${serializedRouterData}</script>` : `
-<script${attrsStr}>window._ROUTER_DATA = ${serializedRouterData}</script>`;
-  }
-  return ssrDataScripts;
-}
-export {
-  SSRDataCollector
-};

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

@@ -1,29 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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";
-  SSRErrors2["LOADER_ERROR"] = "App error occurs during data loader";
-})(SSRErrors || (SSRErrors = {}));
-export {
-  SSRErrors,
-  SSRTimings
-};