@modern-js/runtime 2.43.0 → 2.45.0

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

@@ -120,24 +120,20 @@ const ssrPlugin = () => ({
       },
       modifyEntryRuntimePlugins({ entrypoint, plugins, bundlerConfigs }) {
         if (ssrConfigMap.get(entrypoint.entryName)) {
-          var _bundlerConfigs_find_output, _bundlerConfigs_find, _config_server, _config_server1;
+          var _bundlerConfigs_find_output, _bundlerConfigs_find;
           const chunkLoadingGlobal = bundlerConfigs === null || bundlerConfigs === void 0 ? void 0 : (_bundlerConfigs_find = bundlerConfigs.find((config2) => config2.name === "client")) === null || _bundlerConfigs_find === void 0 ? void 0 : (_bundlerConfigs_find_output = _bundlerConfigs_find.output) === null || _bundlerConfigs_find_output === void 0 ? void 0 : _bundlerConfigs_find_output.chunkLoadingGlobal;
           const config = api.useResolvedConfigContext();
           const { enableInlineScripts, enableInlineStyles } = config.output;
           const { crossorigin, scriptLoading } = config.html;
-          const disablePrerender = typeof ((_config_server = config.server) === null || _config_server === void 0 ? void 0 : _config_server.ssr) === "object" ? Boolean(config.server.ssr.disablePrerender) : false;
-          const unsafeHeaders = typeof ((_config_server1 = config.server) === null || _config_server1 === void 0 ? void 0 : _config_server1.ssr) === "object" ? config.server.ssr.unsafeHeaders : void 0;
           plugins.push({
             name: PLUGIN_IDENTIFIER,
             options: JSON.stringify({
+              scriptLoading,
               ...ssrConfigMap.get(entrypoint.entryName) || {},
               crossorigin,
-              scriptLoading,
               chunkLoadingGlobal,
-              disablePrerender,
               enableInlineScripts: typeof enableInlineScripts === "function" ? void 0 : enableInlineScripts,
-              enableInlineStyles: typeof enableInlineStyles === "function" ? void 0 : enableInlineStyles,
-              unsafeHeaders
+              enableInlineStyles: typeof enableInlineStyles === "function" ? void 0 : enableInlineStyles
             })
           });
         }

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

@@ -54,8 +54,7 @@ const prefetch = async (App, context, config, tracker) => run(context.ssrContext
   Object.keys(loadersData).forEach((id) => {
     const data = loadersData[id];
     if (data._error) {
-      ssrContext.logger.error("App Prefetch Loader", data._error);
-      ssrContext.metrics.emitCounter("app.prefetch.loader.error", 1);
+      ssrContext.logger.error("App Load use-loader", data._error);
       delete data._error;
     }
   });

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

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

package/dist/esm-node/ssr/serverRender/renderToStream/bulidTemplate.before.js

@@ -2,9 +2,26 @@ import ReactHelmet from "react-helmet";
 import { matchRoutes } from "@modern-js/runtime-utils/router";
 import helmetReplace from "../helmet";
 import { CHUNK_CSS_PLACEHOLDER } from "../constants";
-import { safeReplace } from "../utils";
+import { checkIsNode, safeReplace } from "../utils";
 import { HEAD_REG_EXP, buildTemplate } from "./buildTemplate.share";
-function getHeadTemplate(beforeEntryTemplate, context) {
+const readAsset = async (chunk) => {
+  const fs = await import("fs/promises");
+  const path = await import("path");
+  const filepath = path.join(__dirname, chunk);
+  return fs.readFile(filepath, "utf-8");
+};
+const checkIsInline = (chunk, enableInline) => {
+  if (process.env.NODE_ENV === "production") {
+    if (enableInline instanceof RegExp) {
+      return enableInline.test(chunk);
+    } else {
+      return Boolean(enableInline);
+    }
+  } else {
+    return false;
+  }
+};
+function getHeadTemplate(beforeEntryTemplate, context, pluginConfig) {
   const callbacks = [
     (headTemplate2) => {
       const helmetData = ReactHelmet.renderStatic();
@@ -18,9 +35,10 @@ function getHeadTemplate(beforeEntryTemplate, context) {
     return "";
   }
   return buildTemplate(headTemplate, callbacks);
-  function injectCss(headTemplate2) {
-    return safeReplace(headTemplate2, CHUNK_CSS_PLACEHOLDER, getCssChunks());
-    function getCssChunks() {
+  async function injectCss(headTemplate2) {
+    const css = await getCssChunks();
+    return safeReplace(headTemplate2, CHUNK_CSS_PLACEHOLDER, css);
+    async function getCssChunks() {
       const { routeManifest, routerContext, routes } = context;
       if (!routeManifest || !routerContext || !routes) {
         return "";
@@ -42,15 +60,23 @@ function getHeadTemplate(beforeEntryTemplate, context) {
           }
         }
       });
-      const styleLinks = cssChunks.map((chunk) => {
-        return `<link href="${chunk}" rel="stylesheet" />`;
-      });
-      return `${styleLinks.join("")}`;
+      const { enableInlineStyles } = pluginConfig;
+      const styles = await Promise.all(cssChunks.map(async (chunk) => {
+        const link = `<link href="${chunk}" rel="stylesheet" />`;
+        if (checkIsNode() && checkIsInline(chunk, enableInlineStyles)) {
+          return readAsset(chunk).then((content) => `<style>${content}</style>`).catch((_) => {
+            return link;
+          });
+        } else {
+          return link;
+        }
+      }));
+      return `${styles.join("")}`;
     }
   }
 }
-function buildShellBeforeTemplate(beforeAppTemplate, context) {
-  const headTemplate = getHeadTemplate(beforeAppTemplate, context);
+async function buildShellBeforeTemplate(beforeAppTemplate, context, pluginConfig) {
+  const headTemplate = await getHeadTemplate(beforeAppTemplate, context, pluginConfig);
   return beforeAppTemplate.replace(HEAD_REG_EXP, headTemplate);
 }
 export {

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

@@ -3,7 +3,7 @@ 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 }) => {
+const render = ({ App, context, config }) => {
   const { ssrContext } = context;
   if (!ssrContext) {
     throw new Error('The "ssrContext" must not be undefined, but received undefined');
@@ -16,7 +16,7 @@ const render = ({ App, context }) => {
       })
     });
     const { tracker } = ssrContext;
-    const pipe = renderToPipe(rootElement, context, {
+    const pipe = renderToPipe(rootElement, context, config, {
       onShellReady() {
         const cost = end();
         tracker.trackTiming(SSRTimings.RENDER_SHELL, cost);

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

@@ -7,7 +7,7 @@ var ShellChunkStatus;
   ShellChunkStatus2[ShellChunkStatus2["START"] = 0] = "START";
   ShellChunkStatus2[ShellChunkStatus2["FINIESH"] = 1] = "FINIESH";
 })(ShellChunkStatus || (ShellChunkStatus = {}));
-function renderToPipe(rootElement, context, options) {
+function renderToPipe(rootElement, context, pluginConfig, options) {
   let shellChunkStatus = 0;
   const { ssrContext } = context;
   const chunkVec = [];
@@ -22,41 +22,43 @@ function renderToPipe(rootElement, context, options) {
         ...options,
         nonce: ssrContext === null || ssrContext === void 0 ? void 0 : ssrContext.nonce,
         onShellReady() {
-          var _options_onShellReady;
-          const { shellAfter, shellBefore } = getTemplates(context, RenderLevel.SERVER_RENDER);
-          options === null || options === void 0 ? void 0 : (_options_onShellReady = options.onShellReady) === null || _options_onShellReady === void 0 ? void 0 : _options_onShellReady.call(options);
-          const injectableTransform = new Transform({
-            transform(chunk, _encoding, callback) {
-              try {
-                if (shellChunkStatus !== 1) {
-                  chunkVec.push(chunk.toString());
-                  let concatedChunk = chunkVec.join("");
-                  if (concatedChunk.endsWith(ESCAPED_SHELL_STREAM_END_MARK)) {
-                    concatedChunk = concatedChunk.replace(ESCAPED_SHELL_STREAM_END_MARK, "");
-                    shellChunkStatus = 1;
-                    this.push(`${shellBefore}${concatedChunk}${shellAfter}`);
+          getTemplates(context, RenderLevel.SERVER_RENDER, pluginConfig).then(({ shellAfter, shellBefore }) => {
+            var _options_onShellReady;
+            options === null || options === void 0 ? void 0 : (_options_onShellReady = options.onShellReady) === null || _options_onShellReady === void 0 ? void 0 : _options_onShellReady.call(options);
+            const injectableTransform = new Transform({
+              transform(chunk, _encoding, callback) {
+                try {
+                  if (shellChunkStatus !== 1) {
+                    chunkVec.push(chunk.toString());
+                    let concatedChunk = chunkVec.join("");
+                    if (concatedChunk.endsWith(ESCAPED_SHELL_STREAM_END_MARK)) {
+                      concatedChunk = concatedChunk.replace(ESCAPED_SHELL_STREAM_END_MARK, "");
+                      shellChunkStatus = 1;
+                      this.push(`${shellBefore}${concatedChunk}${shellAfter}`);
+                    }
+                  } else {
+                    this.push(chunk);
+                  }
+                  callback();
+                } catch (e) {
+                  if (e instanceof Error) {
+                    callback(e);
+                  } else {
+                    callback(new Error("Received unkown error when streaming"));
                   }
-                } else {
-                  this.push(chunk);
-                }
-                callback();
-              } catch (e) {
-                if (e instanceof Error) {
-                  callback(e);
-                } else {
-                  callback(new Error("Received unkown error when streaming"));
                 }
               }
-            }
+            });
+            resolve(pipe(injectableTransform).pipe(stream));
           });
-          resolve(pipe(injectableTransform).pipe(stream));
         },
         onShellError(error) {
-          var _options_onShellError;
-          const { shellAfter, shellBefore } = getTemplates(context, RenderLevel.CLIENT_RENDER);
-          const fallbackHtml = `${shellBefore}${shellAfter}`;
-          resolve(fallbackHtml);
-          options === null || options === void 0 ? void 0 : (_options_onShellError = options.onShellError) === null || _options_onShellError === void 0 ? void 0 : _options_onShellError.call(options, error);
+          getTemplates(context, RenderLevel.CLIENT_RENDER, pluginConfig).then(({ shellAfter, shellBefore }) => {
+            var _options_onShellError;
+            const fallbackHtml = `${shellBefore}${shellAfter}`;
+            resolve(fallbackHtml);
+            options === null || options === void 0 ? void 0 : (_options_onShellError = options.onShellError) === null || _options_onShellError === void 0 ? void 0 : _options_onShellError.call(options, error);
+          });
         }
       });
     });

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

@@ -7,7 +7,7 @@ var ShellChunkStatus;
   ShellChunkStatus2[ShellChunkStatus2["START"] = 0] = "START";
   ShellChunkStatus2[ShellChunkStatus2["FINIESH"] = 1] = "FINIESH";
 })(ShellChunkStatus || (ShellChunkStatus = {}));
-function renderToPipe(rootElement, context, options) {
+function renderToPipe(rootElement, context, pluginConfig, options) {
   let shellChunkStatus = 0;
   const chunkVec = [];
   const { ssrContext } = context;
@@ -17,7 +17,7 @@ function renderToPipe(rootElement, context, options) {
       ({ renderToReadableStream } = require("react-dom/server"));
     } catch (e) {
     }
-    const { shellAfter, shellBefore } = getTemplates(context, RenderLevel.SERVER_RENDER);
+    const { shellAfter, shellBefore } = await getTemplates(context, RenderLevel.SERVER_RENDER, pluginConfig);
     try {
       const readableOriginal = await renderToReadableStream(rootElement, {
         ...options,
@@ -56,7 +56,7 @@ function renderToPipe(rootElement, context, options) {
       return injectableStream;
     } catch (err) {
       ssrContext === null || ssrContext === void 0 ? void 0 : ssrContext.tracker.trackError(SSRErrors.RENDER_SHELL, err);
-      const { shellAfter: shellAfter2, shellBefore: shellBefore2 } = getTemplates(context, RenderLevel.CLIENT_RENDER);
+      const { shellAfter: shellAfter2, shellBefore: shellBefore2 } = await getTemplates(context, RenderLevel.CLIENT_RENDER, pluginConfig);
       const fallbackHtml = `${shellBefore2}${shellAfter2}`;
       return fallbackHtml;
     }

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

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

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

@@ -128,7 +128,6 @@ class Entry {
   constructor(options) {
     _define_property(this, "entryName", void 0);
     _define_property(this, "result", void 0);
-    _define_property(this, "metrics", void 0);
     _define_property(this, "tracker", void 0);
     _define_property(this, "template", void 0);
     _define_property(this, "App", void 0);
@@ -144,7 +143,6 @@ class Entry {
     this.pluginConfig = config;
     this.routeManifest = ctx.routeManifest;
     this.tracker = ctx.tracker;
-    this.metrics = ctx.metrics;
     this.htmlModifiers = ctx.htmlModifiers;
     this.nonce = nonce;
     this.result = {

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

@@ -8,7 +8,6 @@ const render = ({ App, context, config }) => {
       App,
       config
     });
-    entry.metrics.emitCounter("app.visit.count", 1);
     const html = await entry.renderToHtml(context);
     return html;
   });

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

@@ -1,6 +1,6 @@
 import { _ as _define_property } from "@swc/helpers/_/_define_property";
 import { ChunkExtractor } from "@loadable/server";
-import { attributesToString } from "../utils";
+import { attributesToString, checkIsNode } from "../utils";
 const extname = (uri) => {
   if (typeof uri !== "string" || !uri.includes(".")) {
     return "";
@@ -25,10 +25,6 @@ const readAsset = async (chunk) => {
   const filepath = path.resolve(__dirname, chunk.filename);
   return fs.readFile(filepath, "utf-8");
 };
-const checkIsNode = () => {
-  var _process_release;
-  return typeof process !== "undefined" && ((_process_release = process.release) === null || _process_release === void 0 ? void 0 : _process_release.name) === "node";
-};
 class LoadableCollector {
   get existsAssets() {
     var _routeManifest_routeAssets_entryName, _routeManifest_routeAssets;
@@ -76,7 +72,8 @@ class LoadableCollector {
     const { scriptLoading = "defer", enableInlineScripts } = config;
     const scriptLoadingAtr = {
       defer: scriptLoading === "defer" ? true : void 0,
-      type: scriptLoading === "module" ? "module" : void 0
+      type: scriptLoading === "module" ? "module" : void 0,
+      async: scriptLoading === "async" ? true : void 0
     };
     const attributes = attributesToString(this.generateAttributes({
       nonce,
@@ -88,7 +85,7 @@ class LoadableCollector {
       return !jsChunkReg.test(template) && !((_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 (checkIsInline(chunk, enableInlineScripts) && checkIsNode()) {
+      if (checkIsNode() && checkIsInline(chunk, enableInlineScripts)) {
         return readAsset(chunk).then((content) => `<script>${content}</script>`).catch((_) => {
           return script;
         });
@@ -107,7 +104,7 @@ class LoadableCollector {
       return !cssChunkReg.test(template) && !((_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 (checkIsInline(chunk, enableInlineStyles) && checkIsNode()) {
+      if (checkIsNode() && checkIsInline(chunk, enableInlineStyles)) {
         return readAsset(chunk).then((content) => `<style>${content}</style>`).catch((_) => {
           return link;
         });

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

@@ -16,69 +16,57 @@ var SSRErrors;
 const errors = {
   [0]: {
     reporter: "App Prerender",
-    logger: "App Prerender",
-    metrics: "app.prerender.error"
+    logger: "App Prerender"
   },
   [1]: {
     reporter: "App run useLoader",
-    logger: "App run useLoader",
-    metrics: "app.useloader.error"
+    logger: "App run useLoader"
   },
   [2]: {
     reporter: "App Render To HTML",
-    logger: "App Render To HTML",
-    metrics: "app.render.html.error"
+    logger: "App Render To HTML"
   },
   [3]: {
     reporter: "App Render To Streaming",
-    logger: "An error occurs during streaming SSR",
-    metrics: "app.render.streaming.error"
+    logger: "An error occurs during streaming SSR"
   },
-  [4]: {
-    metrics: "app.render.streaming.shell.error"
-  }
+  [4]: {}
 };
 const timings = {
   [0]: {
     reporter: "ssr-prerender",
     serverTiming: "ssr-prerender",
-    metrics: "app.prerender.cost",
     logger: "App Prerender cost = %d ms"
   },
   [1]: {
     reporter: "ssr-render-html",
     serverTiming: "ssr-render-html",
-    metrics: "app.render.html.cost",
     logger: "App Render To HTML cost = %d ms"
   },
   [2]: {
     reporter: "ssr-render-shell",
-    metrics: "app.render.shell.cost",
     logger: "App Render To Shell cost = %d ms"
   },
   [3]: {
     reporter: "use-loader",
     serverTiming: "use-loader",
-    metrics: "app.useloader.cost",
     logger: "App run useLoader cost = %d ms"
   }
 };
-function createSSRTracker({ reporter, serverTiming, metrics, logger }) {
+function createSSRTracker({ reporter, serverTiming, logger }) {
   const tracker = {
     get sessionId() {
       return reporter.sessionId;
     },
     trackError(key, e) {
-      const { reporter: reporterContent, metrics: metricsContent, logger: loggerContent } = errors[key];
+      const { reporter: reporterContent, logger: loggerContent } = errors[key];
       reporterContent && reporter.reportError(`SSR Error - ${reporterContent}`, e);
-      metricsContent && metrics.emitCounter(metricsContent, 1);
       loggerContent && logger.error(loggerContent, e);
     },
     trackTiming(key, cost) {
-      const { reporter: reporterName, serverTiming: serverTimingName, logger: loggerName, metrics: metricsName } = timings[key];
+      const { reporter: reporterName, serverTiming: serverTimingName, logger: loggerName } = timings[key];
       reporterName && reporter.reportTiming(reporterName, cost);
       serverTimingName && serverTiming.addServeTiming(serverTimingName, cost);
-      metricsName && metrics.emitTimer(metricsName, cost);
       loggerName && logger.debug(loggerName, cost);
     }
   };

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

@@ -6,7 +6,12 @@ function attributesToString(attributes) {
 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
 };

package/dist/types/ssr/serverRender/renderToStream/buildTemplate.after.d.ts

@@ -3,5 +3,5 @@ type BuildShellAfterTemplateOptions = {
     context: RuntimeContext;
     renderLevel: RenderLevel;
 };
-export declare function buildShellAfterTemplate(afterAppTemplate: string, options: BuildShellAfterTemplateOptions): string;
+export declare function buildShellAfterTemplate(afterAppTemplate: string, options: BuildShellAfterTemplateOptions): Promise<string>;
 export {};

package/dist/types/ssr/serverRender/renderToStream/buildTemplate.share.d.ts

@@ -1,3 +1,3 @@
 export declare const HEAD_REG_EXP: RegExp;
-export type BuildTemplateCb = (headTemplate: string) => string;
-export declare function buildTemplate(template: string, callbacks: BuildTemplateCb[]): string;
+export type BuildTemplateCb = (headTemplate: string) => string | Promise<string>;
+export declare function buildTemplate(template: string, callbacks: BuildTemplateCb[]): Promise<string>;

package/dist/types/ssr/serverRender/renderToStream/bulidTemplate.before.d.ts

@@ -1,2 +1,2 @@
-import { RuntimeContext } from '../types';
-export declare function buildShellBeforeTemplate(beforeAppTemplate: string, context: RuntimeContext): string;
+import { RuntimeContext, SSRPluginConfig } from '../types';
+export declare function buildShellBeforeTemplate(beforeAppTemplate: string, context: RuntimeContext, pluginConfig: SSRPluginConfig): Promise<string>;

package/dist/types/ssr/serverRender/renderToStream/index.d.ts

@@ -1,3 +1,3 @@
 /// <reference types="node" />
 import { ServerRenderOptions } from '../types';
-export declare const render: ({ App, context }: ServerRenderOptions) => Promise<import("./renderToPipe").Pipe<import("stream").Writable>>;
+export declare const render: ({ App, context, config }: ServerRenderOptions) => Promise<import("./renderToPipe").Pipe<import("stream").Writable>>;

package/dist/types/ssr/serverRender/renderToStream/renderToPipe.d.ts

@@ -2,7 +2,7 @@
 /// <reference types="react" />
 import { Writable } from 'stream';
 import type { RenderToPipeableStreamOptions } from 'react-dom/server';
-import { RuntimeContext } from '../types';
+import { RuntimeContext, SSRPluginConfig } from '../types';
 export type Pipe<T extends Writable> = (output: T) => Promise<T | string>;
-declare function renderToPipe(rootElement: React.ReactElement, context: RuntimeContext, options?: RenderToPipeableStreamOptions): Pipe<Writable>;
+declare function renderToPipe(rootElement: React.ReactElement, context: RuntimeContext, pluginConfig: SSRPluginConfig, options?: RenderToPipeableStreamOptions): Pipe<Writable>;
 export default renderToPipe;

package/dist/types/ssr/serverRender/renderToStream/renderToPipe.worker.d.ts

@@ -2,7 +2,7 @@
 /// <reference types="react" />
 import type { Writable } from 'stream';
 import type { RenderToReadableStreamOptions } from 'react-dom/server';
-import { RuntimeContext } from '../types';
+import { RuntimeContext, SSRPluginConfig } from '../types';
 export type Pipe<T extends Writable> = (output: T) => Promise<T | string>;
-declare function renderToPipe(rootElement: React.ReactElement, context: RuntimeContext, options?: RenderToReadableStreamOptions): Promise<string | ReadableStream<any>>;
+declare function renderToPipe(rootElement: React.ReactElement, context: RuntimeContext, pluginConfig: SSRPluginConfig, options?: RenderToReadableStreamOptions): Promise<string | ReadableStream<any>>;
 export default renderToPipe;

package/dist/types/ssr/serverRender/renderToStream/template.d.ts

@@ -1,6 +1,6 @@
-import { RenderLevel, RuntimeContext } from '../types';
+import { RenderLevel, RuntimeContext, SSRPluginConfig } from '../types';
 export type InjectTemplate = {
     shellBefore: string;
     shellAfter: string;
 };
-export declare const getTemplates: (context: RuntimeContext, renderLevel: RenderLevel) => InjectTemplate;
+export declare const getTemplates: (context: RuntimeContext, renderLevel: RenderLevel, pluginConfig: SSRPluginConfig) => Promise<InjectTemplate>;

package/dist/types/ssr/serverRender/renderToString/entry.d.ts

@@ -8,7 +8,6 @@ type EntryOptions = {
 export default class Entry {
     entryName: string;
     result: RenderResult;
-    metrics: SSRServerContext['metrics'];
     tracker: SSRTracker;
     private readonly template;
     private readonly App;

package/dist/types/ssr/serverRender/tracker.d.ts

@@ -13,7 +13,7 @@ export declare enum SSRErrors {
     RENDER_STREAM = 3,
     RENDER_SHELL = 4
 }
-export declare function createSSRTracker({ reporter, serverTiming, metrics, logger, }: BaseSSRServerContext): {
+export declare function createSSRTracker({ reporter, serverTiming, logger, }: BaseSSRServerContext): {
     readonly sessionId: string | undefined;
     trackError(key: SSRErrors, e: Error): void;
     trackTiming(key: SSRTimings, cost: number): void;

package/dist/types/ssr/serverRender/types.d.ts

@@ -30,7 +30,7 @@ export type ModernSSRReactComponent = React.ComponentType<any>;
 export { RuntimeContext };
 export type SSRPluginConfig = {
     crossorigin?: boolean | 'anonymous' | 'use-credentials';
-    scriptLoading?: 'defer' | 'blocking' | 'module';
+    scriptLoading?: 'defer' | 'blocking' | 'module' | 'async';
     enableInlineStyles?: boolean | RegExp;
     enableInlineScripts?: boolean | RegExp;
     disablePrerender?: boolean;

package/dist/types/ssr/serverRender/utils.d.ts

@@ -6,3 +6,4 @@ export declare function attributesToString(attributes: Record<string, any>): str
  * @returns
  */
 export declare function safeReplace(source: string, searchValue: string | RegExp, replaceValue: string): string;
+export declare function checkIsNode(): boolean;

package/package.json

@@ -15,7 +15,7 @@
     "modern",
     "modern.js"
   ],
-  "version": "2.43.0",
+  "version": "2.45.0",
   "engines": {
     "node": ">=14.17.6"
   },
@@ -171,10 +171,10 @@
     "react-side-effect": "^2.1.1",
     "styled-components": "^5.3.1",
     "@swc/helpers": "0.5.3",
-    "@modern-js/plugin": "2.43.0",
-    "@modern-js/runtime-utils": "2.43.0",
-    "@modern-js/utils": "2.43.0",
-    "@modern-js/types": "2.43.0"
+    "@modern-js/plugin": "2.45.0",
+    "@modern-js/types": "2.45.0",
+    "@modern-js/utils": "2.45.0",
+    "@modern-js/runtime-utils": "2.45.0"
   },
   "peerDependencies": {
     "react": ">=17",
@@ -195,11 +195,11 @@
     "ts-jest": "^29.1.0",
     "typescript": "^5",
     "webpack": "^5.89.0",
-    "@modern-js/app-tools": "2.43.0",
-    "@modern-js/server-core": "2.43.0",
-    "@scripts/jest-config": "2.43.0",
-    "@modern-js/core": "2.43.0",
-    "@scripts/build": "2.43.0"
+    "@modern-js/app-tools": "2.45.0",
+    "@modern-js/core": "2.45.0",
+    "@modern-js/server-core": "2.45.0",
+    "@scripts/build": "2.45.0",
+    "@scripts/jest-config": "2.45.0"
   },
   "sideEffects": false,
   "publishConfig": {