@modern-js/runtime 2.54.6 → 2.55.0

package/dist/esm-node/ssr/prefetch.js

@@ -1,72 +0,0 @@
-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";
-const prefetch = async (App, context, config, tracker) => run(context.ssrContext.request.headers, async () => {
-  var _context_store;
-  const { ssrContext } = context;
-  const { loadableStats } = ssrContext;
-  if (!config.disablePrerender) {
-    try {
-      const end = time();
-      if (loadableStats) {
-        const extractor = new ChunkExtractor({
-          stats: loadableStats,
-          entrypoints: [
-            ssrContext.entryName
-          ].filter(Boolean)
-        });
-        renderToStaticMarkup(extractor.collectChunks(/* @__PURE__ */ _jsx(App, {
-          context
-        })));
-      } else {
-        renderToStaticMarkup(/* @__PURE__ */ _jsx(App, {
-          context
-        }));
-      }
-      const cost = end();
-      tracker.trackTiming(SSRTimings.PRERENDER, cost);
-    } catch (e) {
-      const error = e;
-      tracker.trackError(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();
-    tracker.trackTiming(SSRTimings.USE_LOADER, cost);
-  } catch (e) {
-    const error = e;
-    tracker.trackError(SSRErrors.USE_LOADER, error);
-    throw e;
-  }
-  Object.keys(loadersData).forEach((id) => {
-    const data = loadersData[id];
-    if (data._error) {
-      ssrContext.logger.error("App Load 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()
-  };
-});
-var prefetch_default = prefetch;
-export {
-  prefetch_default as default
-};

package/dist/esm-node/ssr/serverRender/index.js

@@ -1,19 +0,0 @@
-import { isReact18 } from "../utils";
-import { CHUNK_CSS_PLACEHOLDER } from "./constants";
-async function serverRender(options) {
-  var _options_context_ssrContext;
-  if ((_options_context_ssrContext = options.context.ssrContext) === null || _options_context_ssrContext === void 0 ? void 0 : _options_context_ssrContext.template) {
-    var _options_context_ssrContext1;
-    options.context.ssrContext.template = (_options_context_ssrContext1 = options.context.ssrContext) === null || _options_context_ssrContext1 === void 0 ? void 0 : _options_context_ssrContext1.template.replace("</head>", `${CHUNK_CSS_PLACEHOLDER}</head>`);
-  }
-  if (isReact18() && options.config.mode === "stream") {
-    const pipe = await require("./renderToStream").render(options);
-    return pipe;
-  } else {
-    const html = await require("./renderToString").render(options);
-    return html;
-  }
-}
-export {
-  serverRender as default
-};

package/dist/esm-node/ssr/serverRender/renderToStream/buildTemplate.after.js

@@ -1,50 +0,0 @@
-import { serializeJson } from "@modern-js/runtime-utils/node";
-import { attributesToString, safeReplace } from "../utils";
-import { SSR_DATA_PLACEHOLDER } from "../constants";
-import { buildTemplate } from "./buildTemplate.share";
-function buildShellAfterTemplate(afterAppTemplate, options) {
-  const callbacks = [
-    injectSSRDataScript
-  ];
-  return buildTemplate(afterAppTemplate, callbacks);
-  function injectSSRDataScript(template) {
-    const ssrDataScript = buildSSRDataScript();
-    return safeReplace(template, SSR_DATA_PLACEHOLDER, ssrDataScript);
-    function buildSSRDataScript() {
-      const { context: { ssrContext, initialData, __i18nData__ }, renderLevel } = options;
-      const { request, enableUnsafeCtx, nonce, tracker } = ssrContext;
-      const unsafeContext = {
-        headers: request.headers
-      };
-      const SSRData = {
-        data: {
-          initialData,
-          i18nData: __i18nData__
-        },
-        context: {
-          reporter: {
-            sessionId: tracker.sessionId
-          },
-          request: {
-            params: request.params,
-            query: request.query,
-            pathname: request.pathname,
-            host: request.host,
-            url: request.url,
-            ...enableUnsafeCtx ? unsafeContext : {}
-          }
-        },
-        renderLevel
-      };
-      const attrsStr = attributesToString({
-        nonce
-      });
-      return `
-      <script${attrsStr}>window._SSR_DATA = ${serializeJson(SSRData)}</script>
-      `;
-    }
-  }
-}
-export {
-  buildShellAfterTemplate
-};

package/dist/esm-node/ssr/serverRender/renderToStream/buildTemplate.share.js

@@ -1,8 +0,0 @@
-const HEAD_REG_EXP = /<head(.|\n)*>(.|\n)*<\/head>/;
-function buildTemplate(template, callbacks) {
-  return callbacks.reduce((promise, buildTemplateCb) => promise.then((template2) => buildTemplateCb(template2)), Promise.resolve(template));
-}
-export {
-  HEAD_REG_EXP,
-  buildTemplate
-};

package/dist/esm-node/ssr/serverRender/renderToStream/index.js

@@ -1,40 +0,0 @@
-import { createElement } from "react";
-import { run } from "@modern-js/runtime-utils/node";
-import { time } from "@modern-js/runtime-utils/time";
-import { SSRErrors, SSRTimings } from "../tracker";
-import renderToPipe from "./renderToPipe";
-const render = ({ App, context, config }) => {
-  const { ssrContext } = context;
-  if (!ssrContext) {
-    throw new Error('The "ssrContext" must not be undefined, but received undefined');
-  }
-  return run(ssrContext.request.headers, async () => {
-    const end = time();
-    const rootElement = createElement(App, {
-      context: Object.assign(context || {}, {
-        ssr: true
-      })
-    });
-    const { tracker } = ssrContext;
-    const stream = renderToPipe(rootElement, context, config, {
-      onShellReady() {
-        const cost = end();
-        tracker.trackTiming(SSRTimings.RENDER_SHELL, cost);
-      },
-      onAllReady() {
-        const cost = end();
-        tracker.trackTiming(SSRTimings.RENDER_HTML, cost);
-      },
-      onShellError(e) {
-        tracker.trackError(SSRErrors.RENDER_SHELL, e);
-      },
-      onError(error) {
-        tracker.trackError(SSRErrors.RENDER_STREAM, error);
-      }
-    });
-    return stream;
-  });
-};
-export {
-  render
-};

package/dist/esm-node/ssr/serverRender/renderToStream/renderToPipe.worker.js

@@ -1,88 +0,0 @@
-import { RenderLevel } from "../types";
-import { ESCAPED_SHELL_STREAM_END_MARK } from "../../../common";
-import { SSRErrors } from "../tracker";
-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) {
-  let shellChunkStatus = 0;
-  const chunkVec = [];
-  const { ssrContext } = context;
-  const forUserPipe = async () => {
-    let renderToReadableStream;
-    try {
-      ({ renderToReadableStream } = require("react-dom/server"));
-    } catch (e) {
-    }
-    const { shellAfter, shellBefore } = await getTemplates(context, RenderLevel.SERVER_RENDER, pluginConfig);
-    try {
-      var _options_onShellReady, _context_ssrContext;
-      const readableOriginal = await renderToReadableStream(rootElement, {
-        ...options,
-        nonce: ssrContext === null || ssrContext === void 0 ? void 0 : ssrContext.nonce,
-        onError(error) {
-          var _options_onError;
-          options === null || options === void 0 ? void 0 : (_options_onError = options.onError) === null || _options_onError === void 0 ? void 0 : _options_onError.call(options, error);
-        }
-      });
-      options === null || options === void 0 ? void 0 : (_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);
-      });
-      if ((_context_ssrContext = context.ssrContext) === null || _context_ssrContext === void 0 ? void 0 : _context_ssrContext.isSpider) {
-        await readableOriginal.allReady;
-      }
-      const reader = readableOriginal.getReader();
-      const injectableStream = new ReadableStream({
-        start(controller) {
-          async function push() {
-            const { done, value } = await reader.read();
-            if (done) {
-              controller.close();
-              return;
-            }
-            if (shellChunkStatus !== 1) {
-              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 = 1;
-                controller.enqueue(encodeForWebStream(`${shellBefore}${concatedChunk}${shellAfter}`));
-              }
-            } else {
-              controller.enqueue(value);
-            }
-            push();
-          }
-          push();
-        }
-      });
-      return injectableStream;
-    } catch (err) {
-      ssrContext === null || ssrContext === void 0 ? void 0 : ssrContext.tracker.trackError(SSRErrors.RENDER_SHELL, err);
-      const { shellAfter: shellAfter2, shellBefore: shellBefore2 } = await getTemplates(context, RenderLevel.CLIENT_RENDER, pluginConfig);
-      const fallbackHtml = `${shellBefore2}${shellAfter2}`;
-      return fallbackHtml;
-    }
-  };
-  return forUserPipe();
-}
-let encoder;
-function encodeForWebStream(thing) {
-  if (!encoder) {
-    encoder = new TextEncoder();
-  }
-  if (typeof thing === "string") {
-    return encoder.encode(thing);
-  }
-  return thing;
-}
-var renderToPipe_worker_default = renderToPipe;
-export {
-  renderToPipe_worker_default as default
-};

package/dist/esm-node/ssr/serverRender/renderToStream/template.js

@@ -1,19 +0,0 @@
-import { buildShellAfterTemplate } from "./buildTemplate.after";
-import { buildShellBeforeTemplate } from "./bulidTemplate.before";
-const HTML_SEPARATOR = "<!--<?- html ?>-->";
-const getTemplates = async (context, renderLevel, pluginConfig, styledComponentsStyleTags) => {
-  const { ssrContext } = context;
-  const [beforeAppTemplate = "", afterAppHtmlTemplate = ""] = ssrContext.template.split(HTML_SEPARATOR) || [];
-  const builtBeforeTemplate = await buildShellBeforeTemplate(beforeAppTemplate, context, pluginConfig, styledComponentsStyleTags);
-  const builtAfterTemplate = await buildShellAfterTemplate(afterAppHtmlTemplate, {
-    context,
-    renderLevel
-  });
-  return {
-    shellBefore: builtBeforeTemplate,
-    shellAfter: builtAfterTemplate
-  };
-};
-export {
-  getTemplates
-};

package/dist/esm-node/ssr/serverRender/renderToString/buildHtml.js

@@ -1,24 +0,0 @@
-import { safeReplace } from "../utils";
-import { HTML_PLACEHOLDER, SSR_DATA_PLACEHOLDER, CHUNK_JS_PLACEHOLDER, CHUNK_CSS_PLACEHOLDER } from "../constants";
-function buildHtml(template, callbacks) {
-  return callbacks.reduce((tmp, cb) => cb(tmp), template);
-}
-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 {
-  buildHtml,
-  createReplaceChunkCss,
-  createReplaceChunkJs,
-  createReplaceHtml,
-  createReplaceSSRDataScript
-};

package/dist/esm-node/ssr/serverRender/renderToString/entry.js

@@ -1,149 +0,0 @@
-import React from "react";
-import { serializeJson } from "@modern-js/runtime-utils/node";
-import { time } from "@modern-js/runtime-utils/time";
-import { serializeErrors } from "../../../router/runtime/utils";
-import helmetReplace from "../helmet";
-import { RenderLevel } from "../types";
-import prefetch from "../../prefetch";
-import { ROUTER_DATA_JSON_ID, SSR_DATA_JSON_ID } from "../constants";
-import { attributesToString } from "../utils";
-import { SSRErrors, SSRTimings } from "../tracker";
-import { createLoadableCollector } from "./loadable";
-import { createRender } from "./render";
-import { createStyledCollector } from "./styledComponent";
-import { buildHtml, createReplaceChunkCss, createReplaceChunkJs, createReplaceHtml, createReplaceSSRDataScript } from "./buildHtml";
-const buildTemplateData = (context, data, renderLevel, tracker, config) => {
-  const { request } = context;
-  const { unsafeHeaders } = config;
-  const headers = unsafeHeaders ? Object.fromEntries(Object.entries(request.headers).filter(([key, _]) => {
-    var _unsafeHeaders_map;
-    return unsafeHeaders === null || unsafeHeaders === void 0 ? void 0 : (_unsafeHeaders_map = unsafeHeaders.map((header) => header.toLowerCase())) === null || _unsafeHeaders_map === void 0 ? void 0 : _unsafeHeaders_map.includes(key.toLowerCase());
-  })) : void 0;
-  return {
-    data,
-    context: {
-      request: {
-        params: request.params,
-        query: request.query,
-        pathname: request.pathname,
-        host: request.host,
-        url: request.url,
-        headers
-      },
-      reporter: {
-        sessionId: tracker.sessionId
-      }
-    },
-    renderLevel
-  };
-};
-class Entry {
-  async renderToHtml(context) {
-    var _ssrContext_redirection, _ssrContext_redirection1, _ssrContext_redirection2;
-    const ssrContext = context.ssrContext;
-    if ((_ssrContext_redirection = ssrContext.redirection) === null || _ssrContext_redirection === void 0 ? void 0 : _ssrContext_redirection.url) {
-      return "";
-    }
-    const prefetchData = await this.prefetch(context);
-    if ((_ssrContext_redirection1 = ssrContext.redirection) === null || _ssrContext_redirection1 === void 0 ? void 0 : _ssrContext_redirection1.url) {
-      return "";
-    }
-    if (this.result.renderLevel >= RenderLevel.SERVER_PREFETCH) {
-      this.result.html = await this.renderToString(context);
-    }
-    if ((_ssrContext_redirection2 = ssrContext.redirection) === null || _ssrContext_redirection2 === void 0 ? void 0 : _ssrContext_redirection2.url) {
-      return "";
-    }
-    const { routerContext } = context;
-    const routerData = routerContext ? {
-      loaderData: routerContext.loaderData,
-      errors: serializeErrors(routerContext.errors)
-    } : void 0;
-    const templateData = buildTemplateData(ssrContext, prefetchData, this.result.renderLevel, this.tracker, this.pluginConfig);
-    const ssrDataScripts = this.getSSRDataScript(templateData, routerData);
-    const html = buildHtml(this.template, [
-      createReplaceChunkCss(this.result.chunksMap.css),
-      createReplaceChunkJs(this.result.chunksMap.js),
-      createReplaceSSRDataScript(ssrDataScripts),
-      createReplaceHtml(this.result.html || ""),
-      ...this.htmlModifiers
-    ]);
-    const helmetData = this.result.helmet;
-    return helmetData ? helmetReplace(html, helmetData) : html;
-  }
-  async prefetch(context) {
-    let prefetchData;
-    try {
-      prefetchData = await prefetch(this.App, context, this.pluginConfig, this.tracker);
-      this.result.renderLevel = RenderLevel.SERVER_PREFETCH;
-    } catch (e) {
-      this.result.renderLevel = RenderLevel.CLIENT_RENDER;
-    }
-    return prefetchData || {};
-  }
-  async renderToString(context) {
-    let html = "";
-    const end = time();
-    const { ssrContext } = context;
-    try {
-      const App = React.createElement(this.App, {
-        context: Object.assign(context, {
-          ssr: true
-        })
-      });
-      html = await createRender(App, this.result).addCollector(createStyledCollector(this.result)).addCollector(createLoadableCollector({
-        stats: ssrContext.loadableStats,
-        result: this.result,
-        entryName: this.entryName,
-        config: this.pluginConfig,
-        nonce: this.nonce,
-        template: this.template,
-        routeManifest: this.routeManifest
-      })).finish();
-      const cost = end();
-      this.tracker.trackTiming(SSRTimings.RENDER_HTML, cost);
-      this.result.renderLevel = RenderLevel.SERVER_RENDER;
-    } catch (e) {
-      this.tracker.trackError(SSRErrors.RENDER_HTML, e);
-    }
-    return html;
-  }
-  getSSRDataScript(templateData, routerData) {
-    const useInlineScript = this.pluginConfig.inlineScript !== false;
-    const ssrData = serializeJson(templateData);
-    const attrsStr = attributesToString({
-      nonce: this.nonce
-    });
-    let ssrDataScripts = useInlineScript ? `<script${attrsStr}>window._SSR_DATA = ${ssrData}</script>` : `<script type="application/json" id="${SSR_DATA_JSON_ID}">${ssrData}</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;
-  }
-  constructor(options) {
-    const { ctx, config } = options;
-    const { entryName, template, nonce } = ctx;
-    this.template = template;
-    this.entryName = entryName;
-    this.App = options.App;
-    this.pluginConfig = config;
-    this.routeManifest = ctx.routeManifest;
-    this.tracker = ctx.tracker;
-    this.htmlModifiers = ctx.htmlModifiers;
-    this.nonce = nonce;
-    this.result = {
-      renderLevel: RenderLevel.CLIENT_RENDER,
-      html: "",
-      chunksMap: {
-        js: "",
-        css: ""
-      }
-    };
-  }
-}
-export {
-  Entry as default
-};

package/dist/esm-node/ssr/serverRender/renderToString/index.js

@@ -1,17 +0,0 @@
-import { run } from "@modern-js/runtime-utils/node";
-import SSREntry from "./entry";
-const render = ({ App, context, config }) => {
-  const ssrContext = context.ssrContext;
-  return run(ssrContext.request.headers, async () => {
-    const entry = new SSREntry({
-      ctx: ssrContext,
-      App,
-      config
-    });
-    const html = await entry.renderToHtml(context);
-    return html;
-  });
-};
-export {
-  render
-};

package/dist/esm-node/ssr/serverRender/renderToString/render.js

@@ -1,27 +0,0 @@
-import ReactDomServer from "react-dom/server";
-import ReactHelmet from "react-helmet";
-class Render {
-  addCollector(collector) {
-    this.collectors.push(collector);
-    return this;
-  }
-  async finish() {
-    const App = this.collectors.reduce((pre, collector) => collector.collect(pre), this.App);
-    const html = ReactDomServer.renderToString(App);
-    const helmetData = ReactHelmet.renderStatic();
-    this.renderResult.helmet = helmetData;
-    await Promise.all(this.collectors.map((component) => component.effect()));
-    return html;
-  }
-  constructor(App, result) {
-    this.collectors = [];
-    this.App = App;
-    this.renderResult = result;
-  }
-}
-function createRender(App, result) {
-  return new Render(App, result);
-}
-export {
-  createRender
-};

package/dist/esm-node/ssr/serverRender/renderToString/styledComponent.js

@@ -1,20 +0,0 @@
-import { ServerStyleSheet } from "styled-components";
-class StyledCollector {
-  collect(comopnent) {
-    return this.sheet.collectStyles(comopnent);
-  }
-  effect() {
-    const css = this.sheet.getStyleTags();
-    this.result.chunksMap.css += css;
-  }
-  constructor(result) {
-    this.sheet = new ServerStyleSheet();
-    this.result = result;
-  }
-}
-function createStyledCollector(result) {
-  return new StyledCollector(result);
-}
-export {
-  createStyledCollector
-};

package/dist/esm-node/ssr/serverRender/tracker.js

@@ -1,87 +0,0 @@
-var SSRTimings;
-(function(SSRTimings2) {
-  SSRTimings2[SSRTimings2["PRERENDER"] = 0] = "PRERENDER";
-  SSRTimings2[SSRTimings2["RENDER_HTML"] = 1] = "RENDER_HTML";
-  SSRTimings2[SSRTimings2["RENDER_SHELL"] = 2] = "RENDER_SHELL";
-  SSRTimings2[SSRTimings2["USE_LOADER"] = 3] = "USE_LOADER";
-})(SSRTimings || (SSRTimings = {}));
-var SSRErrors;
-(function(SSRErrors2) {
-  SSRErrors2[SSRErrors2["PRERENDER"] = 0] = "PRERENDER";
-  SSRErrors2[SSRErrors2["USE_LOADER"] = 1] = "USE_LOADER";
-  SSRErrors2[SSRErrors2["RENDER_HTML"] = 2] = "RENDER_HTML";
-  SSRErrors2[SSRErrors2["RENDER_STREAM"] = 3] = "RENDER_STREAM";
-  SSRErrors2[SSRErrors2["RENDER_SHELL"] = 4] = "RENDER_SHELL";
-})(SSRErrors || (SSRErrors = {}));
-const errors = {
-  [0]: {
-    reporter: "App Prerender",
-    logger: "App Prerender"
-  },
-  [1]: {
-    reporter: "App run useLoader",
-    logger: "App run useLoader"
-  },
-  [2]: {
-    reporter: "App Render To HTML",
-    logger: "App Render To HTML"
-  },
-  [3]: {
-    reporter: "App Render To Streaming",
-    logger: "An error occurs during streaming SSR"
-  },
-  [4]: {}
-};
-const timings = {
-  [0]: {
-    reporter: "ssr-prerender",
-    serverTiming: "ssr-prerender",
-    logger: "App Prerender cost = %d ms"
-  },
-  [1]: {
-    reporter: "ssr-render-html",
-    serverTiming: "ssr-render-html",
-    logger: "App Render To HTML cost = %d ms"
-  },
-  [2]: {
-    reporter: "ssr-render-shell",
-    logger: "App Render To Shell cost = %d ms"
-  },
-  [3]: {
-    reporter: "use-loader",
-    serverTiming: "use-loader",
-    logger: "App run useLoader cost = %d ms"
-  }
-};
-function getHeadersWithoutCookie(headers) {
-  const _headers = {
-    ...headers,
-    cookie: void 0
-  };
-  delete _headers.cookie;
-  return _headers;
-}
-function createSSRTracker({ reporter, serverTiming, logger, request }) {
-  const tracker = {
-    get sessionId() {
-      return reporter === null || reporter === void 0 ? void 0 : reporter.sessionId;
-    },
-    trackError(key, e) {
-      const { reporter: reporterContent, logger: loggerContent } = errors[key];
-      reporterContent && (reporter === null || reporter === void 0 ? void 0 : reporter.reportError(`SSR Error - ${reporterContent}`, e));
-      loggerContent && logger.error(`SSR Error - ${loggerContent}, error = %s, req.url = %s, req.headers = %o`, e instanceof Error ? e.stack || e.message : e, request.pathname, getHeadersWithoutCookie(request.headers));
-    },
-    trackTiming(key, cost) {
-      const { reporter: reporterName, serverTiming: serverTimingName, logger: loggerName } = timings[key];
-      reporterName && (reporter === null || reporter === void 0 ? void 0 : reporter.reportTiming(reporterName, cost));
-      serverTimingName && serverTiming.addServeTiming(serverTimingName, cost);
-      loggerName && logger.debug(`SSR Debug - ${loggerName}, req.url = %s`, cost, request.pathname);
-    }
-  };
-  return tracker;
-}
-export {
-  SSRErrors,
-  SSRTimings,
-  createSSRTracker
-};

package/dist/esm-node/ssr/serverRender/utils.js

@@ -1,17 +0,0 @@
-function attributesToString(attributes) {
-  return Object.entries(attributes).reduce((str, [key, value]) => {
-    return value === void 0 ? str : `${str} ${key}="${value}"`;
-  }, "");
-}
-function safeReplace(source, searchValue, replaceValue) {
-  return source.replace(searchValue, () => replaceValue);
-}
-function checkIsNode() {
-  var _process_release;
-  return typeof process !== "undefined" && ((_process_release = process.release) === null || _process_release === void 0 ? void 0 : _process_release.name) === "node";
-}
-export {
-  attributesToString,
-  checkIsNode,
-  safeReplace
-};