@modern-js/runtime 2.39.2 → 2.40.0

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

@@ -31,6 +31,36 @@ var checkIsInline = function(chunk, enableInline) {
     return false;
   }
 };
+var readAsset = function() {
+  var _ref = _async_to_generator(function(chunk) {
+    var fs, path, filepath;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          return [
+            4,
+            import("node:fs/promises")
+          ];
+        case 1:
+          fs = _state.sent();
+          return [
+            4,
+            import("node:path")
+          ];
+        case 2:
+          path = _state.sent();
+          filepath = path.resolve(__dirname, chunk.filename);
+          return [
+            2,
+            fs.readFile(filepath, "utf-8")
+          ];
+      }
+    });
+  });
+  return function readAsset2(chunk) {
+    return _ref.apply(this, arguments);
+  };
+}();
 var checkIsNode = function() {
   var _process_release;
   return typeof process !== "undefined" && ((_process_release = process.release) === null || _process_release === void 0 ? void 0 : _process_release.name) === "node";
@@ -151,40 +181,27 @@ var LoadableCollector = /* @__PURE__ */ function() {
                     return !jsChunkReg.test(template) && !((_this_existsAssets = _this.existsAssets) === null || _this_existsAssets === void 0 ? void 0 : _this_existsAssets.includes(chunk.path));
                   }).map(function() {
                     var _ref = _async_to_generator(function(chunk) {
-                      var fs, filepath;
+                      var script;
                       return _ts_generator(this, function(_state2) {
-                        switch (_state2.label) {
-                          case 0:
-                            if (!(checkIsInline(chunk, enableInlineScripts) && checkIsNode()))
-                              return [
-                                3,
-                                2
-                              ];
-                            return [
-                              4,
-                              import("node:fs/promises")
-                            ];
-                          case 1:
-                            fs = _state2.sent();
-                            filepath = chunk.path;
-                            return [
-                              2,
-                              fs.readFile(filepath, "utf-8").then(function(content) {
-                                return "<script>".concat(content, "</script>");
-                              }).catch(function(_) {
-                                return "";
-                              })
-                            ];
-                          case 2:
-                            return [
-                              2,
-                              "<script".concat(attributes, ' src="').concat(chunk.url, '"></script>')
-                            ];
-                          case 3:
-                            return [
-                              2
-                            ];
+                        script = "<script".concat(attributes, ' src="').concat(chunk.url, '"></script>');
+                        if (checkIsInline(chunk, enableInlineScripts) && checkIsNode()) {
+                          return [
+                            2,
+                            readAsset(chunk).then(function(content) {
+                              return "<script>".concat(content, "</script>");
+                            }).catch(function(_) {
+                              return script;
+                            })
+                          ];
+                        } else {
+                          return [
+                            2,
+                            script
+                          ];
                         }
+                        return [
+                          2
+                        ];
                       });
                     });
                     return function(chunk) {
@@ -224,39 +241,27 @@ var LoadableCollector = /* @__PURE__ */ function() {
                     return !cssChunkReg.test(template) && !((_this_existsAssets = _this.existsAssets) === null || _this_existsAssets === void 0 ? void 0 : _this_existsAssets.includes(chunk.path));
                   }).map(function() {
                     var _ref = _async_to_generator(function(chunk) {
-                      var fs;
+                      var link;
                       return _ts_generator(this, function(_state2) {
-                        switch (_state2.label) {
-                          case 0:
-                            if (!(checkIsInline(chunk, enableInlineStyles) && checkIsNode()))
-                              return [
-                                3,
-                                2
-                              ];
-                            return [
-                              4,
-                              import("node:fs/promises")
-                            ];
-                          case 1:
-                            fs = _state2.sent();
-                            return [
-                              2,
-                              fs.readFile(chunk.path).then(function(content) {
-                                return "<style>".concat(content, "</style>");
-                              }).catch(function(_) {
-                                return "";
-                              })
-                            ];
-                          case 2:
-                            return [
-                              2,
-                              "<link".concat(atrributes, ' href="').concat(chunk.url, '" rel="stylesheet" />')
-                            ];
-                          case 3:
-                            return [
-                              2
-                            ];
+                        link = "<link".concat(atrributes, ' href="').concat(chunk.url, '" rel="stylesheet" />');
+                        if (checkIsInline(chunk, enableInlineStyles) && checkIsNode()) {
+                          return [
+                            2,
+                            readAsset(chunk).then(function(content) {
+                              return "<style>".concat(content, "</style>");
+                            }).catch(function(_) {
+                              return link;
+                            })
+                          ];
+                        } else {
+                          return [
+                            2,
+                            link
+                          ];
                         }
+                        return [
+                          2
+                        ];
                       });
                     });
                     return function(chunk) {

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

@@ -1,23 +1,28 @@
 import { _ as _define_property } from "@swc/helpers/_/_define_property";
 var SSRTimings;
 (function(SSRTimings2) {
-  SSRTimings2[SSRTimings2["SSR_RENDER_TOTAL"] = 0] = "SSR_RENDER_TOTAL";
-  SSRTimings2[SSRTimings2["SSR_PREFETCH"] = 1] = "SSR_PREFETCH";
-  SSRTimings2[SSRTimings2["SSR_RENDER_HTML"] = 2] = "SSR_RENDER_HTML";
-  SSRTimings2[SSRTimings2["SSR_RENDER_SHELL"] = 3] = "SSR_RENDER_SHELL";
+  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["PREFETCH"] = 0] = "PREFETCH";
-  SSRErrors2[SSRErrors2["RENDER_HTML"] = 1] = "RENDER_HTML";
-  SSRErrors2[SSRErrors2["RENDER_STREAM"] = 2] = "RENDER_STREAM";
-  SSRErrors2[SSRErrors2["RENDER_SHELL"] = 3] = "RENDER_SHELL";
+  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 = {}));
 var _obj;
-var errors = (_obj = {}, _define_property(_obj, SSRErrors.PREFETCH, {
-  reporter: "SSR Error - App Prefetch Render",
-  logger: "App Prefetch Render",
-  metrics: "app.prefetch.render.error"
+var errors = (_obj = {}, _define_property(_obj, SSRErrors.PRERENDER, {
+  reporter: "SSR Error - App Prerender",
+  logger: "App Prerender",
+  metrics: "app.prerender.error"
+}), _define_property(_obj, SSRErrors.USE_LOADER, {
+  reporter: "SSR Error - App run useLoader",
+  logger: "App run useLoader",
+  metrics: "app.useloader.error"
 }), _define_property(_obj, SSRErrors.RENDER_HTML, {
   reporter: "SSR Error - App Render To HTML",
   logger: "App Render To HTML",
@@ -30,23 +35,22 @@ var errors = (_obj = {}, _define_property(_obj, SSRErrors.PREFETCH, {
   metrics: "app.render.streaming.shell.error"
 }), _obj);
 var _obj1;
-var timings = (_obj1 = {}, _define_property(_obj1, SSRTimings.SSR_PREFETCH, {
-  reporter: "ssr-prefetch",
-  serverTiming: "ssr-prefetch",
-  metrics: "app.prefeth.cost",
-  logger: "App Prefetch cost = %d ms"
-}), _define_property(_obj1, SSRTimings.SSR_RENDER_HTML, {
+var timings = (_obj1 = {}, _define_property(_obj1, SSRTimings.PRERENDER, {
+  reporter: "ssr-prerender",
+  serverTiming: "ssr-prerender",
+  metrics: "app.prerender.cost",
+  logger: "App Prerender cost = %d ms"
+}), _define_property(_obj1, SSRTimings.RENDER_HTML, {
   reporter: "ssr-render-html",
   serverTiming: "ssr-render-html",
   metrics: "app.render.html.cost",
   logger: "App Render To HTML cost = %d ms"
-}), _define_property(_obj1, SSRTimings.SSR_RENDER_TOTAL, {
-  reporter: "ssr-render-total",
-  serverTiming: "ssr-render-total",
-  metrics: "app.render.cost",
-  logger: "App Render Total cost = %d ms"
-}), _define_property(_obj1, SSRTimings.SSR_RENDER_SHELL, {
+}), _define_property(_obj1, SSRTimings.RENDER_SHELL, {
   reporter: "ssr-render-shell"
+}), _define_property(_obj1, SSRTimings.USE_LOADER, {
+  reporter: "use-loader",
+  serverTiming: "use-loader",
+  logger: "App run useLoader cost = %d ms"
 }), _obj1);
 function createSSRTracker(param) {
   var reporter = param.reporter, serverTiming = param.serverTiming, metrics = param.metrics, logger = param.logger;

package/dist/esm/state/cli/index.js

@@ -58,19 +58,6 @@ var statePlugin = function() {
             plugins
           };
         },
-        validateSchema: function validateSchema() {
-          return [
-            {
-              target: "runtime.state",
-              schema: {
-                type: [
-                  "boolean",
-                  "object"
-                ]
-              }
-            }
-          ];
-        },
         addRuntimeExports: function addRuntimeExports() {
           pluginsExportsUtils.addExport("export { default as state } from '@modern-js/runtime/model'");
         }

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

@@ -1,5 +1,5 @@
 import path from "path";
-import { isReact18, cleanRequireCache, ENTRY_NAME_PATTERN } from "@modern-js/utils";
+import { isReact18, cleanRequireCache } from "@modern-js/utils";
 import { statePlugin } from "../state/cli";
 import { ssrPlugin } from "../ssr/cli";
 import { routerPlugin } from "../router/cli";
@@ -51,29 +51,6 @@ const runtimePlugin = () => ({
           }
         };
       },
-      validateSchema() {
-        return [
-          {
-            target: "runtime",
-            schema: {
-              type: "object",
-              additionalProperties: false
-            }
-          },
-          {
-            target: "runtimeByEntries",
-            schema: {
-              type: "object",
-              patternProperties: {
-                [ENTRY_NAME_PATTERN]: {
-                  type: "object"
-                }
-              },
-              additionalProperties: false
-            }
-          }
-        ];
-      },
       async beforeRestart() {
         cleanRequireCache([
           require.resolve("../state/cli"),

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

@@ -29,19 +29,6 @@ const routerPlugin = () => ({
           }
         };
       },
-      validateSchema() {
-        return [
-          {
-            target: "runtime.router",
-            schema: {
-              type: [
-                "boolean",
-                "object"
-              ]
-            }
-          }
-        ];
-      },
       modifyEntryImports({ entrypoint, imports }) {
         const { entryName, isMainEntry, fileSystemRoutes } = entrypoint;
         const userConfig = api.useResolvedConfigContext();

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

@@ -2,25 +2,36 @@ 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";
-const prefetch = async (App, context, config) => run(context.ssrContext.request.headers, async () => {
+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) {
-    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
-      }));
+    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()) {
@@ -29,7 +40,17 @@ const prefetch = async (App, context, config) => run(context.ssrContext.request.
       i18nData: context.__i18nData__
     };
   }
-  const loadersData = await context.loaderManager.awaitPendingLoaders();
+  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) {

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

@@ -24,11 +24,11 @@ const render = ({ App, context }) => {
           ssrContext.cacheConfig = cacheConfig;
         }
         const cost = end();
-        tracker.trackTiming(SSRTimings.SSR_RENDER_SHELL, cost);
+        tracker.trackTiming(SSRTimings.RENDER_SHELL, cost);
       },
       onAllReady() {
         const cost = end();
-        tracker.trackTiming(SSRTimings.SSR_RENDER_TOTAL, cost);
+        tracker.trackTiming(SSRTimings.RENDER_HTML, cost);
       },
       onShellError(e) {
         tracker.trackError(SSRErrors.RENDER_SHELL, e);

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

@@ -72,15 +72,11 @@ class Entry {
   }
   async prefetch(context) {
     let prefetchData;
-    const end = time();
     try {
-      prefetchData = await prefetch(this.App, context, this.pluginConfig);
+      prefetchData = await prefetch(this.App, context, this.pluginConfig, this.tracker);
       this.result.renderLevel = RenderLevel.SERVER_PREFETCH;
-      const prefetchCost = end();
-      this.tracker.trackTiming(SSRTimings.SSR_PREFETCH, prefetchCost);
     } catch (e) {
       this.result.renderLevel = RenderLevel.CLIENT_RENDER;
-      this.tracker.trackError(SSRErrors.PREFETCH, e);
     }
     return prefetchData || {};
   }
@@ -104,7 +100,7 @@ class Entry {
         routeManifest: this.routeManifest
       })).finish();
       const cost = end();
-      this.tracker.trackTiming(SSRTimings.SSR_RENDER_HTML, cost);
+      this.tracker.trackTiming(SSRTimings.RENDER_HTML, cost);
       this.result.renderLevel = RenderLevel.SERVER_RENDER;
     } catch (e) {
       this.tracker.trackError(SSRErrors.RENDER_HTML, e);

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

@@ -1,7 +1,5 @@
 import { run } from "@modern-js/runtime-utils/node";
-import { time } from "@modern-js/runtime-utils/time";
 import { PreRender } from "../../react/prerender";
-import { SSRTimings } from "../tracker";
 import SSREntry from "./entry";
 const render = ({ App, context, config }) => {
   const ssrContext = context.ssrContext;
@@ -12,10 +10,7 @@ const render = ({ App, context, config }) => {
       config
     });
     entry.metrics.emitCounter("app.visit.count", 1);
-    const end = time();
     const html = await entry.renderToHtml(context);
-    const cost = end();
-    entry.tracker.trackTiming(SSRTimings.SSR_RENDER_TOTAL, cost);
     const cacheConfig = PreRender.config();
     if (cacheConfig) {
       context.ssrContext.cacheConfig = cacheConfig;

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

@@ -19,6 +19,12 @@ const checkIsInline = (chunk, enableInline) => {
     return false;
   }
 };
+const readAsset = async (chunk) => {
+  const fs = await import("node:fs/promises");
+  const path = await import("node:path");
+  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";
@@ -81,14 +87,13 @@ class LoadableCollector {
       const jsChunkReg = new RegExp(`<script .*src="${chunk.url}".*>`);
       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()) {
-        const fs = await import("node:fs/promises");
-        const filepath = chunk.path;
-        return fs.readFile(filepath, "utf-8").then((content) => `<script>${content}</script>`).catch((_) => {
-          return "";
+        return readAsset(chunk).then((content) => `<script>${content}</script>`).catch((_) => {
+          return script;
         });
       } else {
-        return `<script${attributes} src="${chunk.url}"></script>`;
+        return script;
       }
     }));
     chunksMap.js += scripts.filter((script) => Boolean(script)).join("");
@@ -101,13 +106,13 @@ class LoadableCollector {
       const cssChunkReg = new RegExp(`<link .*href="${chunk.url}".*>`);
       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()) {
-        const fs = await import("node:fs/promises");
-        return fs.readFile(chunk.path).then((content) => `<style>${content}</style>`).catch((_) => {
-          return "";
+        return readAsset(chunk).then((content) => `<style>${content}</style>`).catch((_) => {
+          return link;
         });
       } else {
-        return `<link${atrributes} href="${chunk.url}" rel="stylesheet" />`;
+        return link;
       }
     }));
     chunksMap.css += css.filter((css2) => Boolean(css2)).join("");

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

@@ -1,22 +1,28 @@
 var SSRTimings;
 (function(SSRTimings2) {
-  SSRTimings2[SSRTimings2["SSR_RENDER_TOTAL"] = 0] = "SSR_RENDER_TOTAL";
-  SSRTimings2[SSRTimings2["SSR_PREFETCH"] = 1] = "SSR_PREFETCH";
-  SSRTimings2[SSRTimings2["SSR_RENDER_HTML"] = 2] = "SSR_RENDER_HTML";
-  SSRTimings2[SSRTimings2["SSR_RENDER_SHELL"] = 3] = "SSR_RENDER_SHELL";
+  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["PREFETCH"] = 0] = "PREFETCH";
-  SSRErrors2[SSRErrors2["RENDER_HTML"] = 1] = "RENDER_HTML";
-  SSRErrors2[SSRErrors2["RENDER_STREAM"] = 2] = "RENDER_STREAM";
-  SSRErrors2[SSRErrors2["RENDER_SHELL"] = 3] = "RENDER_SHELL";
+  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 = {
-  [SSRErrors.PREFETCH]: {
-    reporter: "SSR Error - App Prefetch Render",
-    logger: "App Prefetch Render",
-    metrics: "app.prefetch.render.error"
+  [SSRErrors.PRERENDER]: {
+    reporter: "SSR Error - App Prerender",
+    logger: "App Prerender",
+    metrics: "app.prerender.error"
+  },
+  [SSRErrors.USE_LOADER]: {
+    reporter: "SSR Error - App run useLoader",
+    logger: "App run useLoader",
+    metrics: "app.useloader.error"
   },
   [SSRErrors.RENDER_HTML]: {
     reporter: "SSR Error - App Render To HTML",
@@ -33,26 +39,25 @@ const errors = {
   }
 };
 const timings = {
-  [SSRTimings.SSR_PREFETCH]: {
-    reporter: "ssr-prefetch",
-    serverTiming: "ssr-prefetch",
-    metrics: "app.prefeth.cost",
-    logger: "App Prefetch cost = %d ms"
+  [SSRTimings.PRERENDER]: {
+    reporter: "ssr-prerender",
+    serverTiming: "ssr-prerender",
+    metrics: "app.prerender.cost",
+    logger: "App Prerender cost = %d ms"
   },
-  [SSRTimings.SSR_RENDER_HTML]: {
+  [SSRTimings.RENDER_HTML]: {
     reporter: "ssr-render-html",
     serverTiming: "ssr-render-html",
     metrics: "app.render.html.cost",
     logger: "App Render To HTML cost = %d ms"
   },
-  [SSRTimings.SSR_RENDER_TOTAL]: {
-    reporter: "ssr-render-total",
-    serverTiming: "ssr-render-total",
-    metrics: "app.render.cost",
-    logger: "App Render Total cost = %d ms"
-  },
-  [SSRTimings.SSR_RENDER_SHELL]: {
+  [SSRTimings.RENDER_SHELL]: {
     reporter: "ssr-render-shell"
+  },
+  [SSRTimings.USE_LOADER]: {
+    reporter: "use-loader",
+    serverTiming: "use-loader",
+    logger: "App run useLoader cost = %d ms"
   }
 };
 function createSSRTracker({ reporter, serverTiming, metrics, logger }) {

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

@@ -55,19 +55,6 @@ const statePlugin = () => ({
           plugins
         };
       },
-      validateSchema() {
-        return [
-          {
-            target: "runtime.state",
-            schema: {
-              type: [
-                "boolean",
-                "object"
-              ]
-            }
-          }
-        ];
-      },
       addRuntimeExports() {
         pluginsExportsUtils.addExport(`export { default as state } from '@modern-js/runtime/model'`);
       }

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

@@ -1,12 +1,14 @@
 import { RuntimeContext } from '../core';
+import { LoaderResult } from '../core/loader/loaderManager';
 import { SSRPluginConfig } from './serverRender/types';
-declare const prefetch: (App: React.ComponentType<any>, context: RuntimeContext, config: SSRPluginConfig) => Promise<{
+import { SSRTracker } from './serverRender/tracker';
+declare const prefetch: (App: React.ComponentType<any>, context: RuntimeContext, config: SSRPluginConfig, tracker: SSRTracker) => Promise<{
   initialData: Record<string, unknown> | undefined;
   i18nData: any;
   loadersData?: undefined;
   storeState?: undefined;
 } | {
-  loadersData: Record<string, import("../core/loader/loaderManager").LoaderResult>;
+  loadersData: Record<string, LoaderResult>;
   initialData: Record<string, unknown> | undefined;
   i18nData: any;
   storeState: any;

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

@@ -1,16 +1,17 @@
 import type { BaseSSRServerContext } from '@modern-js/types';
 export type SSRTracker = ReturnType<typeof createSSRTracker>;
 export declare enum SSRTimings {
-  SSR_RENDER_TOTAL = 0,
-  SSR_PREFETCH = 1,
-  SSR_RENDER_HTML = 2,
-  SSR_RENDER_SHELL = 3,
+  PRERENDER = 0,
+  RENDER_HTML = 1,
+  RENDER_SHELL = 2,
+  USE_LOADER = 3,
 }
 export declare enum SSRErrors {
-  PREFETCH = 0,
-  RENDER_HTML = 1,
-  RENDER_STREAM = 2,
-  RENDER_SHELL = 3,
+  PRERENDER = 0,
+  USE_LOADER = 1,
+  RENDER_HTML = 2,
+  RENDER_STREAM = 3,
+  RENDER_SHELL = 4,
 }
 export declare function createSSRTracker({
   reporter,