@modern-js/runtime 2.39.2 → 2.40.0

package/dist/cjs/cli/index.js

@@ -85,29 +85,6 @@ const runtimePlugin = () => ({
           }
         };
       },
-      validateSchema() {
-        return [
-          {
-            target: "runtime",
-            schema: {
-              type: "object",
-              additionalProperties: false
-            }
-          },
-          {
-            target: "runtimeByEntries",
-            schema: {
-              type: "object",
-              patternProperties: {
-                [import_utils.ENTRY_NAME_PATTERN]: {
-                  type: "object"
-                }
-              },
-              additionalProperties: false
-            }
-          }
-        ];
-      },
       async beforeRestart() {
         (0, import_utils.cleanRequireCache)([
           require.resolve("../state/cli"),

package/dist/cjs/router/cli/index.js

@@ -53,19 +53,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/cjs/ssr/prefetch.js

@@ -25,25 +25,36 @@ var import_jsx_runtime = require("react/jsx-runtime");
 var import_server = require("react-dom/server");
 var import_node = require("@modern-js/runtime-utils/node");
 var import_server2 = require("@loadable/server");
-const prefetch = async (App, context, config) => (0, import_node.run)(context.ssrContext.request.headers, async () => {
+var import_time = require("@modern-js/runtime-utils/time");
+var import_tracker = require("./serverRender/tracker");
+const prefetch = async (App, context, config, tracker) => (0, import_node.run)(context.ssrContext.request.headers, async () => {
   var _context_store;
   const { ssrContext } = context;
   const { loadableStats } = ssrContext;
   if (!config.disablePrerender) {
-    if (loadableStats) {
-      const extractor = new import_server2.ChunkExtractor({
-        stats: loadableStats,
-        entrypoints: [
-          ssrContext.entryName
-        ].filter(Boolean)
-      });
-      (0, import_server.renderToStaticMarkup)(extractor.collectChunks(/* @__PURE__ */ (0, import_jsx_runtime.jsx)(App, {
-        context
-      })));
-    } else {
-      (0, import_server.renderToStaticMarkup)(/* @__PURE__ */ (0, import_jsx_runtime.jsx)(App, {
-        context
-      }));
+    try {
+      const end = (0, import_time.time)();
+      if (loadableStats) {
+        const extractor = new import_server2.ChunkExtractor({
+          stats: loadableStats,
+          entrypoints: [
+            ssrContext.entryName
+          ].filter(Boolean)
+        });
+        (0, import_server.renderToStaticMarkup)(extractor.collectChunks(/* @__PURE__ */ (0, import_jsx_runtime.jsx)(App, {
+          context
+        })));
+      } else {
+        (0, import_server.renderToStaticMarkup)(/* @__PURE__ */ (0, import_jsx_runtime.jsx)(App, {
+          context
+        }));
+      }
+      const cost = end();
+      tracker.trackTiming(import_tracker.SSRTimings.PRERENDER, cost);
+    } catch (e) {
+      const error = e;
+      tracker.trackError(import_tracker.SSRErrors.PRERENDER, error);
+      throw e;
     }
   }
   if (!context.loaderManager.hasPendingLoaders()) {
@@ -52,7 +63,17 @@ const prefetch = async (App, context, config) => (0, import_node.run)(context.ss
       i18nData: context.__i18nData__
     };
   }
-  const loadersData = await context.loaderManager.awaitPendingLoaders();
+  let loadersData = {};
+  try {
+    const end = (0, import_time.time)();
+    loadersData = await context.loaderManager.awaitPendingLoaders();
+    const cost = end();
+    tracker.trackTiming(import_tracker.SSRTimings.USE_LOADER, cost);
+  } catch (e) {
+    const error = e;
+    tracker.trackError(import_tracker.SSRErrors.USE_LOADER, error);
+    throw e;
+  }
   Object.keys(loadersData).forEach((id) => {
     const data = loadersData[id];
     if (data._error) {

package/dist/cjs/ssr/serverRender/renderToStream/index.js

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

package/dist/cjs/ssr/serverRender/renderToString/entry.js

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

package/dist/cjs/ssr/serverRender/renderToString/index.js

@@ -32,9 +32,7 @@ __export(renderToString_exports, {
 });
 module.exports = __toCommonJS(renderToString_exports);
 var import_node = require("@modern-js/runtime-utils/node");
-var import_time = require("@modern-js/runtime-utils/time");
 var import_prerender = require("../../react/prerender");
-var import_tracker = require("../tracker");
 var import_entry = __toESM(require("./entry"));
 const render = ({ App, context, config }) => {
   const ssrContext = context.ssrContext;
@@ -45,10 +43,7 @@ const render = ({ App, context, config }) => {
       config
     });
     entry.metrics.emitCounter("app.visit.count", 1);
-    const end = (0, import_time.time)();
     const html = await entry.renderToHtml(context);
-    const cost = end();
-    entry.tracker.trackTiming(import_tracker.SSRTimings.SSR_RENDER_TOTAL, cost);
     const cacheConfig = import_prerender.PreRender.config();
     if (cacheConfig) {
       context.ssrContext.cacheConfig = cacheConfig;

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

@@ -52,6 +52,12 @@ const checkIsInline = (chunk, enableInline) => {
     return false;
   }
 };
+const readAsset = async (chunk) => {
+  const fs = await Promise.resolve().then(() => __toESM(require("node:fs/promises")));
+  const path = await Promise.resolve().then(() => __toESM(require("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";
@@ -114,14 +120,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 Promise.resolve().then(() => __toESM(require("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("");
@@ -134,13 +139,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 Promise.resolve().then(() => __toESM(require("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/cjs/ssr/serverRender/tracker.js

@@ -25,23 +25,29 @@ __export(tracker_exports, {
 module.exports = __toCommonJS(tracker_exports);
 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",
@@ -58,26 +64,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/cjs/state/cli/index.js

@@ -79,19 +79,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/esm/cli/index.js

@@ -1,8 +1,7 @@
 import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
-import { _ as _define_property } from "@swc/helpers/_/_define_property";
 import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
 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";
@@ -55,27 +54,6 @@ var runtimePlugin = function() {
             }
           };
         },
-        validateSchema: function validateSchema() {
-          return [
-            {
-              target: "runtime",
-              schema: {
-                type: "object",
-                additionalProperties: false
-              }
-            },
-            {
-              target: "runtimeByEntries",
-              schema: {
-                type: "object",
-                patternProperties: _define_property({}, ENTRY_NAME_PATTERN, {
-                  type: "object"
-                }),
-                additionalProperties: false
-              }
-            }
-          ];
-        },
         beforeRestart: function beforeRestart() {
           return _async_to_generator(function() {
             return _ts_generator(this, function(_state) {

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

@@ -32,19 +32,6 @@ var routerPlugin = function() {
             }
           };
         },
-        validateSchema: function validateSchema() {
-          return [
-            {
-              target: "runtime.router",
-              schema: {
-                type: [
-                  "boolean",
-                  "object"
-                ]
-              }
-            }
-          ];
-        },
         modifyEntryImports: function modifyEntryImports(param) {
           var entrypoint = param.entrypoint, imports = param.imports;
           var entryName = entrypoint.entryName, isMainEntry = entrypoint.isMainEntry, fileSystemRoutes = entrypoint.fileSystemRoutes;

package/dist/esm/ssr/prefetch.js

@@ -4,33 +4,44 @@ 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";
 var prefetch = function() {
-  var _ref = _async_to_generator(function(App, context, config) {
+  var _ref = _async_to_generator(function(App, context, config, tracker) {
     return _ts_generator(this, function(_state) {
       return [
         2,
         run(context.ssrContext.request.headers, /* @__PURE__ */ _async_to_generator(function() {
-          var _context_store, ssrContext, loadableStats, extractor, loadersData;
+          var _context_store, ssrContext, loadableStats, end, extractor, cost, error, loadersData, end1, cost1, e, error1;
           return _ts_generator(this, function(_state2) {
             switch (_state2.label) {
               case 0:
                 ssrContext = context.ssrContext;
                 loadableStats = ssrContext.loadableStats;
                 if (!config.disablePrerender) {
-                  if (loadableStats) {
-                    extractor = new ChunkExtractor({
-                      stats: loadableStats,
-                      entrypoints: [
-                        ssrContext.entryName
-                      ].filter(Boolean)
-                    });
-                    renderToStaticMarkup(extractor.collectChunks(/* @__PURE__ */ _jsx(App, {
-                      context
-                    })));
-                  } else {
-                    renderToStaticMarkup(/* @__PURE__ */ _jsx(App, {
-                      context
-                    }));
+                  try {
+                    end = time();
+                    if (loadableStats) {
+                      extractor = new ChunkExtractor({
+                        stats: loadableStats,
+                        entrypoints: [
+                          ssrContext.entryName
+                        ].filter(Boolean)
+                      });
+                      renderToStaticMarkup(extractor.collectChunks(/* @__PURE__ */ _jsx(App, {
+                        context
+                      })));
+                    } else {
+                      renderToStaticMarkup(/* @__PURE__ */ _jsx(App, {
+                        context
+                      }));
+                    }
+                    cost = end();
+                    tracker.trackTiming(SSRTimings.PRERENDER, cost);
+                  } catch (e2) {
+                    error = e2;
+                    tracker.trackError(SSRErrors.PRERENDER, error);
+                    throw e2;
                   }
                 }
                 if (!context.loaderManager.hasPendingLoaders()) {
@@ -42,12 +53,34 @@ var prefetch = function() {
                     }
                   ];
                 }
+                loadersData = {};
+                _state2.label = 1;
+              case 1:
+                _state2.trys.push([
+                  1,
+                  3,
+                  ,
+                  4
+                ]);
+                end1 = time();
                 return [
                   4,
                   context.loaderManager.awaitPendingLoaders()
                 ];
-              case 1:
+              case 2:
                 loadersData = _state2.sent();
+                cost1 = end1();
+                tracker.trackTiming(SSRTimings.USE_LOADER, cost1);
+                return [
+                  3,
+                  4
+                ];
+              case 3:
+                e = _state2.sent();
+                error1 = e;
+                tracker.trackError(SSRErrors.USE_LOADER, error1);
+                throw e;
+              case 4:
                 Object.keys(loadersData).forEach(function(id) {
                   var data = loadersData[id];
                   if (data._error) {
@@ -72,7 +105,7 @@ var prefetch = function() {
       ];
     });
   });
-  return function prefetch2(App, context, config) {
+  return function prefetch2(App, context, config, tracker) {
     return _ref.apply(this, arguments);
   };
 }();

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

@@ -29,11 +29,11 @@ var render = function(param) {
             ssrContext.cacheConfig = cacheConfig;
           }
           var cost = end();
-          tracker.trackTiming(SSRTimings.SSR_RENDER_SHELL, cost);
+          tracker.trackTiming(SSRTimings.RENDER_SHELL, cost);
         },
         onAllReady: function onAllReady() {
           var cost = end();
-          tracker.trackTiming(SSRTimings.SSR_RENDER_TOTAL, cost);
+          tracker.trackTiming(SSRTimings.RENDER_HTML, cost);
         },
         onShellError: function onShellError(e) {
           tracker.trackError(SSRErrors.RENDER_SHELL, e);

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

@@ -152,41 +152,35 @@ var Entry = /* @__PURE__ */ function() {
       value: function prefetch1(context) {
         var _this = this;
         return _async_to_generator(function() {
-          var prefetchData, end, prefetchCost, e;
+          var prefetchData, e;
           return _ts_generator(this, function(_state) {
             switch (_state.label) {
               case 0:
-                end = time();
-                _state.label = 1;
-              case 1:
                 _state.trys.push([
-                  1,
-                  3,
+                  0,
+                  2,
                   ,
-                  4
+                  3
                 ]);
                 return [
                   4,
-                  prefetch(_this.App, context, _this.pluginConfig)
+                  prefetch(_this.App, context, _this.pluginConfig, _this.tracker)
                 ];
-              case 2:
+              case 1:
                 prefetchData = _state.sent();
                 _this.result.renderLevel = RenderLevel.SERVER_PREFETCH;
-                prefetchCost = end();
-                _this.tracker.trackTiming(SSRTimings.SSR_PREFETCH, prefetchCost);
                 return [
                   3,
-                  4
+                  3
                 ];
-              case 3:
+              case 2:
                 e = _state.sent();
                 _this.result.renderLevel = RenderLevel.CLIENT_RENDER;
-                _this.tracker.trackError(SSRErrors.PREFETCH, e);
                 return [
                   3,
-                  4
+                  3
                 ];
-              case 4:
+              case 3:
                 return [
                   2,
                   prefetchData || {}
@@ -236,7 +230,7 @@ var Entry = /* @__PURE__ */ function() {
               case 2:
                 html = _state.sent();
                 cost = end();
-                _this.tracker.trackTiming(SSRTimings.SSR_RENDER_HTML, cost);
+                _this.tracker.trackTiming(SSRTimings.RENDER_HTML, cost);
                 _this.result.renderLevel = RenderLevel.SERVER_RENDER;
                 return [
                   3,

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

@@ -1,15 +1,13 @@
 import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
 import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
 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";
 var render = function(param) {
   var App = param.App, context = param.context, config = param.config;
   var ssrContext = context.ssrContext;
   return run(ssrContext.request.headers, /* @__PURE__ */ _async_to_generator(function() {
-    var entry, end, html, cost, cacheConfig;
+    var entry, html, cacheConfig;
     return _ts_generator(this, function(_state) {
       switch (_state.label) {
         case 0:
@@ -19,15 +17,12 @@ var render = function(param) {
             config
           });
           entry.metrics.emitCounter("app.visit.count", 1);
-          end = time();
           return [
             4,
             entry.renderToHtml(context)
           ];
         case 1:
           html = _state.sent();
-          cost = end();
-          entry.tracker.trackTiming(SSRTimings.SSR_RENDER_TOTAL, cost);
           cacheConfig = PreRender.config();
           if (cacheConfig) {
             context.ssrContext.cacheConfig = cacheConfig;