@modern-js/runtime 2.53.0 → 2.54.0

package/dist/cjs/router/cli/code/utils.js

@@ -0,0 +1,143 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var utils_exports = {};
+__export(utils_exports, {
+  getPathWithoutExt: () => getPathWithoutExt,
+  getServerCombinedModueFile: () => getServerCombinedModueFile,
+  getServerLoadersFile: () => getServerLoadersFile,
+  hasAction: () => hasAction,
+  hasLoader: () => hasLoader,
+  isPageComponentFile: () => isPageComponentFile,
+  parseModule: () => parseModule,
+  replaceWithAlias: () => replaceWithAlias,
+  walkDirectory: () => walkDirectory
+});
+module.exports = __toCommonJS(utils_exports);
+var import_fs = __toESM(require("fs"));
+var import_path = __toESM(require("path"));
+var import_utils = require("@modern-js/utils");
+var import_esbuild = require("esbuild");
+var import_es_module_lexer = require("es-module-lexer");
+var import_constants = require("../constants");
+const walkDirectory = (dir) => import_fs.default.readdirSync(dir).reduce((previous, filename) => {
+  const filePath = import_path.default.join(dir, filename);
+  if (import_fs.default.statSync(filePath).isDirectory()) {
+    return [
+      ...previous,
+      ...walkDirectory(filePath)
+    ];
+  } else {
+    return [
+      ...previous,
+      filePath
+    ];
+  }
+}, []);
+const isPageComponentFile = (filePath) => {
+  if (/\.(d|test|spec|e2e)\.(js|jsx|ts|tsx)$/.test(filePath)) {
+    return false;
+  }
+  if ([
+    ".js",
+    ".jsx",
+    ".ts",
+    ".tsx"
+  ].includes(import_path.default.extname(filePath))) {
+    return true;
+  }
+  return false;
+};
+const replaceWithAlias = (base, filePath, alias) => {
+  if (filePath.includes(base)) {
+    return (0, import_utils.normalizeToPosixPath)(import_path.default.join(alias, import_path.default.relative(base, filePath)));
+  } else {
+    return filePath;
+  }
+};
+const parseModule = async ({ source, filename }) => {
+  let content = source;
+  if (import_utils.JS_EXTENSIONS.some((ext) => filename.endsWith(ext))) {
+    const result = await (0, import_esbuild.transform)(content, {
+      loader: import_path.default.extname(filename).slice(1),
+      format: "esm"
+    });
+    content = result.code;
+  }
+  return (0, import_es_module_lexer.parse)(content);
+};
+const hasLoader = async (filename, source) => {
+  let content = source;
+  if (!source) {
+    content = (await import_utils.fs.readFile(filename, "utf-8")).toString();
+  }
+  if (content) {
+    const [, moduleExports] = await parseModule({
+      source: content.toString(),
+      filename
+    });
+    return moduleExports.some((e) => e.n === import_constants.LOADER_EXPORT_NAME);
+  }
+  return false;
+};
+const hasAction = async (filename, source) => {
+  let content = source;
+  if (!source) {
+    content = (await import_utils.fs.readFile(filename, "utf-8")).toString();
+  }
+  if (content) {
+    const [, moduleExports] = await parseModule({
+      source: content.toString(),
+      filename
+    });
+    return moduleExports.some((e) => e.n === import_constants.ACTION_EXPORT_NAME);
+  }
+  return false;
+};
+const getServerLoadersFile = (internalDirectory, entryName) => {
+  return import_path.default.join(internalDirectory, entryName, "route-server-loaders.js");
+};
+const getServerCombinedModueFile = (internalDirectory, entryName) => {
+  return import_path.default.join(internalDirectory, entryName, "server-loader-combined.js");
+};
+const getPathWithoutExt = (filename) => {
+  const extname = import_path.default.extname(filename);
+  return filename.slice(0, -extname.length);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getPathWithoutExt,
+  getServerCombinedModueFile,
+  getServerLoadersFile,
+  hasAction,
+  hasLoader,
+  isPageComponentFile,
+  parseModule,
+  replaceWithAlias,
+  walkDirectory
+});

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

@@ -0,0 +1,83 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var constants_exports = {};
+__export(constants_exports, {
+  ACTION_EXPORT_NAME: () => ACTION_EXPORT_NAME,
+  FILE_SYSTEM_ROUTES_COMPONENTS_DIR: () => FILE_SYSTEM_ROUTES_COMPONENTS_DIR,
+  FILE_SYSTEM_ROUTES_DYNAMIC_REGEXP: () => FILE_SYSTEM_ROUTES_DYNAMIC_REGEXP,
+  FILE_SYSTEM_ROUTES_FILE_NAME: () => FILE_SYSTEM_ROUTES_FILE_NAME,
+  FILE_SYSTEM_ROUTES_GLOBAL_LAYOUT: () => FILE_SYSTEM_ROUTES_GLOBAL_LAYOUT,
+  FILE_SYSTEM_ROUTES_IGNORED_REGEX: () => FILE_SYSTEM_ROUTES_IGNORED_REGEX,
+  FILE_SYSTEM_ROUTES_INDEX: () => FILE_SYSTEM_ROUTES_INDEX,
+  FILE_SYSTEM_ROUTES_LAYOUT: () => FILE_SYSTEM_ROUTES_LAYOUT,
+  LOADER_EXPORT_NAME: () => LOADER_EXPORT_NAME,
+  NESTED_ROUTE: () => NESTED_ROUTE,
+  NESTED_ROUTES_DIR: () => NESTED_ROUTES_DIR,
+  PAGES_DIR_NAME: () => PAGES_DIR_NAME,
+  TEMP_LOADERS_DIR: () => TEMP_LOADERS_DIR
+});
+module.exports = __toCommonJS(constants_exports);
+const PAGES_DIR_NAME = "pages";
+const NESTED_ROUTES_DIR = "routes";
+const FILE_SYSTEM_ROUTES_FILE_NAME = "routes.js";
+const LOADER_EXPORT_NAME = "loader";
+const ACTION_EXPORT_NAME = "action";
+const TEMP_LOADERS_DIR = "__loaders__";
+const FILE_SYSTEM_ROUTES_LAYOUT = "_layout";
+const FILE_SYSTEM_ROUTES_GLOBAL_LAYOUT = "_app";
+const FILE_SYSTEM_ROUTES_INDEX = "index";
+const FILE_SYSTEM_ROUTES_IGNORED_REGEX = /\.(d|test|spec|e2e)\.(js|jsx|ts|tsx)$/;
+const FILE_SYSTEM_ROUTES_DYNAMIC_REGEXP = /^\[(\S+)\]([*+?]?)$/;
+const FILE_SYSTEM_ROUTES_COMPONENTS_DIR = "internal_components";
+const NESTED_ROUTE = {
+  LAYOUT_FILE: "layout",
+  LAYOUT_CONFIG_FILE: "layout.config",
+  LAYOUT_LOADER_FILE: "layout.loader",
+  LAYOUT_DATA_FILE: "layout.data",
+  LAYOUT_CLIENT_LOADER: "layout.data.client",
+  PAGE_FILE: "page",
+  PAGE_CONFIG_FILE: "page.config",
+  PAGE_LOADER_FILE: "page.loader",
+  PAGE_DATA_FILE: "page.data",
+  PAGE_CLIENT_LOADER: "page.data.client",
+  SPLATE_FILE: "$",
+  SPLATE_CONFIG_FILE: "$.config",
+  SPLATE_LOADER_FILE: "$.loader",
+  SPLATE_DATA_FILE: "$.data",
+  SPLATE_CLIENT_DATA: "$.data.client",
+  LOADING_FILE: "loading",
+  ERROR_FILE: "error",
+  LOADER_FILE: "loader"
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ACTION_EXPORT_NAME,
+  FILE_SYSTEM_ROUTES_COMPONENTS_DIR,
+  FILE_SYSTEM_ROUTES_DYNAMIC_REGEXP,
+  FILE_SYSTEM_ROUTES_FILE_NAME,
+  FILE_SYSTEM_ROUTES_GLOBAL_LAYOUT,
+  FILE_SYSTEM_ROUTES_IGNORED_REGEX,
+  FILE_SYSTEM_ROUTES_INDEX,
+  FILE_SYSTEM_ROUTES_LAYOUT,
+  LOADER_EXPORT_NAME,
+  NESTED_ROUTE,
+  NESTED_ROUTES_DIR,
+  PAGES_DIR_NAME,
+  TEMP_LOADERS_DIR
+});

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

@@ -0,0 +1,87 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var entry_exports = {};
+__export(entry_exports, {
+  hasNestedRoutes: () => hasNestedRoutes,
+  hasPages: () => hasPages,
+  isRouteEntry: () => isRouteEntry,
+  modifyEntrypoints: () => modifyEntrypoints
+});
+module.exports = __toCommonJS(entry_exports);
+var import_path = __toESM(require("path"));
+var import_utils = require("@modern-js/utils");
+var import_constants = require("./constants");
+const hasPages = (dir) => import_utils.fs.existsSync(import_path.default.join(dir, import_constants.PAGES_DIR_NAME));
+const hasNestedRoutes = (dir) => import_utils.fs.existsSync(import_path.default.join(dir, import_constants.NESTED_ROUTES_DIR));
+const isRouteEntry = (dir) => {
+  if (hasNestedRoutes(dir)) {
+    return import_path.default.join(dir, import_constants.NESTED_ROUTES_DIR);
+  }
+  if (hasPages(dir)) {
+    return import_path.default.join(dir, import_constants.PAGES_DIR_NAME);
+  }
+  return false;
+};
+const modifyEntrypoints = (entrypoints, config = {}) => {
+  return entrypoints.map((entrypoint) => {
+    if (!entrypoint.isAutoMount) {
+      return entrypoint;
+    }
+    const isHasNestedRoutes = hasNestedRoutes(entrypoint.absoluteEntryDir);
+    const isHasPages = hasPages(entrypoint.absoluteEntryDir);
+    if (!isHasNestedRoutes && !isHasPages) {
+      return entrypoint;
+    }
+    if (entrypoint.fileSystemRoutes && !(0, import_utils.isRouterV5)(config)) {
+      entrypoint.nestedRoutesEntry = entrypoint.entry;
+    } else if (!entrypoint.fileSystemRoutes) {
+      entrypoint.fileSystemRoutes = {
+        globalApp: (0, import_utils.findExists)(import_utils.JS_EXTENSIONS.map((ext) => import_path.default.resolve(entrypoint.absoluteEntryDir, `./${import_constants.PAGES_DIR_NAME}/${import_constants.FILE_SYSTEM_ROUTES_GLOBAL_LAYOUT}${ext}`)))
+      };
+      if (isHasPages) {
+        entrypoint.entry = import_path.default.join(entrypoint.absoluteEntryDir, import_constants.PAGES_DIR_NAME);
+        entrypoint.pageRoutesEntry = entrypoint.entry;
+      }
+      if (isHasNestedRoutes) {
+        entrypoint.entry = import_path.default.join(entrypoint.absoluteEntryDir, import_constants.NESTED_ROUTES_DIR);
+        entrypoint.nestedRoutesEntry = entrypoint.entry;
+      }
+    } else {
+      throw Error("Custom entries with conventional routing not support use react router v5!");
+    }
+    return entrypoint;
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  hasNestedRoutes,
+  hasPages,
+  isRouteEntry,
+  modifyEntrypoints
+});

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

@@ -0,0 +1,71 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var handler_exports = {};
+__export(handler_exports, {
+  handleFileChange: () => handleFileChange,
+  handleModifyEntrypoints: () => handleModifyEntrypoints
+});
+module.exports = __toCommonJS(handler_exports);
+var import_path = __toESM(require("path"));
+var import_lodash = require("@modern-js/utils/lodash");
+var import_entry = require("./entry");
+var import_utils = require("./code/utils");
+let originEntrypoints = [];
+async function handleModifyEntrypoints(api, entrypoints) {
+  const config = api.useResolvedConfigContext();
+  const newEntryPoints = (0, import_entry.modifyEntrypoints)(entrypoints, config);
+  const appContext = api.useAppContext();
+  const resolvedConfig = api.useResolvedConfigContext();
+  appContext.entrypoints = newEntryPoints;
+  originEntrypoints = (0, import_lodash.cloneDeep)(newEntryPoints);
+  const { generateCode } = await Promise.resolve().then(() => __toESM(require("./code")));
+  await generateCode(appContext, resolvedConfig, entrypoints, api);
+  return newEntryPoints;
+}
+async function handleFileChange(api, e) {
+  const appContext = api.useAppContext();
+  const { appDirectory, entrypoints } = appContext;
+  const { filename, eventType } = e;
+  const nestedRouteEntries = entrypoints.map((point) => point.nestedRoutesEntry).filter(Boolean);
+  const pagesDir = entrypoints.map((point) => point.entry).filter((entry) => entry && !import_path.default.extname(entry)).concat(nestedRouteEntries);
+  const isPageFile = (name) => pagesDir.some((pageDir) => name.includes(pageDir));
+  const absoluteFilePath = import_path.default.resolve(appDirectory, filename);
+  const isRouteComponent = isPageFile(absoluteFilePath) && (0, import_utils.isPageComponentFile)(absoluteFilePath);
+  if (isRouteComponent && (eventType === "add" || eventType === "unlink")) {
+    const resolvedConfig = api.useResolvedConfigContext();
+    const { generateCode } = await Promise.resolve().then(() => __toESM(require("./code")));
+    const entrypoints2 = (0, import_lodash.cloneDeep)(originEntrypoints);
+    await generateCode(appContext, resolvedConfig, entrypoints2, api);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  handleFileChange,
+  handleModifyEntrypoints
+});

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

@@ -19,10 +19,17 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var cli_exports = {};
 __export(cli_exports, {
   default: () => cli_default,
+  handleFileChange: () => import_handler2.handleFileChange,
+  handleModifyEntrypoints: () => import_handler2.handleModifyEntrypoints,
+  isRouteEntry: () => import_entry2.isRouteEntry,
   routerPlugin: () => routerPlugin
 });
 module.exports = __toCommonJS(cli_exports);
 var import_utils = require("@modern-js/utils");
+var import_entry = require("./entry");
+var import_handler = require("./handler");
+var import_entry2 = require("./entry");
+var import_handler2 = require("./handler");
 const PLUGIN_IDENTIFIER = "router";
 const ROUTES_IDENTIFIER = "routes";
 const routerPlugin = () => ({
@@ -34,6 +41,12 @@ const routerPlugin = () => ({
     const runtimeConfigMap = /* @__PURE__ */ new Map();
     let pluginsExportsUtils;
     return {
+      checkEntryPoint({ path, entry }) {
+        return {
+          path,
+          entry: entry || (0, import_entry.isRouteEntry)(path)
+        };
+      },
       config() {
         const appContext = api.useAppContext();
         pluginsExportsUtils = (0, import_utils.createRuntimeExportsUtils)(appContext.internalDirectory, "plugins");
@@ -53,6 +66,12 @@ const routerPlugin = () => ({
           }
         };
       },
+      async modifyEntrypoints({ entrypoints }) {
+        const newEntryPoints = await (0, import_handler.handleModifyEntrypoints)(api, entrypoints);
+        return {
+          entrypoints: newEntryPoints
+        };
+      },
       modifyEntryImports({ entrypoint, imports }) {
         const { entryName, isMainEntry, fileSystemRoutes } = entrypoint;
         const userConfig = api.useResolvedConfigContext();
@@ -104,6 +123,9 @@ const routerPlugin = () => ({
         if (!(0, import_utils.isRouterV5)(userConfig)) {
           pluginsExportsUtils.addExport(`export { default as router } from '@modern-js/runtime/router'`);
         }
+      },
+      async fileChange(e) {
+        await (0, import_handler.handleFileChange)(api, e);
       }
     };
   }
@@ -111,5 +133,8 @@ const routerPlugin = () => ({
 var cli_default = routerPlugin;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  handleFileChange,
+  handleModifyEntrypoints,
+  isRouteEntry,
   routerPlugin
 });

package/dist/cjs/router/runtime/plugin.js

@@ -91,10 +91,11 @@ const routerPlugin = ({
             context
           });
         },
-        hoc: ({ App }, next) => {
+        hoc: ({ App, config }, next) => {
           if (!finalRouteConfig && !createRoutes) {
             return next({
-              App
+              App,
+              config
             });
           }
           const getRouteApp = () => {
@@ -168,11 +169,13 @@ const routerPlugin = ({
           }
           if (routesConfig === null || routesConfig === void 0 ? void 0 : routesConfig.globalApp) {
             return next({
-              App: (0, import_hoist_non_react_statics.default)(RouteApp, routesConfig.globalApp)
+              App: (0, import_hoist_non_react_statics.default)(RouteApp, routesConfig.globalApp),
+              config
             });
           }
           return next({
-            App: RouteApp
+            App: RouteApp,
+            config
           });
         },
         pickContext: ({ context, pickedContext }, next) => {

package/dist/cjs/router/runtime/plugin.node.js

@@ -88,7 +88,7 @@ const routerPlugin = ({ basename = "", originalBaseUrl = "", routesConfig, creat
               context
             });
           }
-          const { request, mode: ssrMode, nonce } = context.ssrContext;
+          const { request, mode: ssrMode, nonce, loaderFailureMode = "errorBoundary" } = context.ssrContext;
           const baseUrl = originalBaseUrl || request.baseUrl;
           const _basename = baseUrl === "/" ? (0, import_utils.urlJoin)(baseUrl, basename) : baseUrl;
           const { reporter, serverTiming } = context.ssrContext;
@@ -118,6 +118,10 @@ const routerPlugin = ({ basename = "", originalBaseUrl = "", routesConfig, creat
           if (routerContext instanceof Response) {
             return routerContext;
           }
+          if (routerContext.statusCode >= 500 && routerContext.statusCode < 600 && loaderFailureMode === "clientRender") {
+            routerContext.statusCode = 200;
+            throw routerContext.errors[0];
+          }
           const router = (0, import_router.createStaticRouter)(routes, routerContext);
           context.remixRouter = router;
           context.routerContext = routerContext;
@@ -127,10 +131,11 @@ const routerPlugin = ({ basename = "", originalBaseUrl = "", routesConfig, creat
             context
           });
         },
-        hoc: ({ App }, next) => {
+        hoc: ({ App, config }, next) => {
           if (!routesConfig) {
             return next({
-              App
+              App,
+              config
             });
           }
           const getRouteApp = () => {
@@ -157,11 +162,13 @@ const routerPlugin = ({ basename = "", originalBaseUrl = "", routesConfig, creat
           const RouteApp = getRouteApp();
           if (routesConfig === null || routesConfig === void 0 ? void 0 : routesConfig.globalApp) {
             return next({
-              App: (0, import_hoist_non_react_statics.default)(RouteApp, routesConfig.globalApp)
+              App: (0, import_hoist_non_react_statics.default)(RouteApp, routesConfig.globalApp),
+              config
             });
           }
           return next({
-            App: RouteApp
+            App: RouteApp,
+            config
           });
         },
         pickContext: ({ context, pickedContext }, next) => {

package/dist/cjs/ssr/index.node.js

@@ -54,6 +54,7 @@ const ssr = (config = {}) => ({
         context.ssrContext.request = (0, import_utils.formatServer)(request);
         context.ssrContext.mode = config.mode;
         context.ssrContext.tracker = (0, import_tracker.createSSRTracker)(context.ssrContext);
+        context.ssrContext.loaderFailureMode = config.loaderFailureMode;
         if (!context.ssrContext.htmlModifiers) {
           context.ssrContext.htmlModifiers = [];
         }

package/dist/cjs/state/runtime/plugin.js

@@ -70,7 +70,7 @@ const state = (config) => ({
   setup: () => {
     const storeConfig = getStoreConfig(config);
     return {
-      hoc({ App }, next) {
+      hoc({ App, config: config2 }, next) {
         const getStateApp = (props) => {
           const context = (0, import_react.useContext)(import_core.RuntimeReactContext);
           return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_react2.Provider, {
@@ -82,7 +82,8 @@ const state = (config) => ({
           });
         };
         return next({
-          App: (0, import_hoist_non_react_statics.default)(getStateApp, App)
+          App: (0, import_hoist_non_react_statics.default)(getStateApp, App),
+          config: config2
         });
       },
       init({ context }, next) {

package/dist/esm/cli/constants.js

@@ -0,0 +1,4 @@
+var APP_FILE_NAME = "App";
+export {
+  APP_FILE_NAME
+};

package/dist/esm/cli/entry.js

@@ -0,0 +1,14 @@
+import path from "path";
+import { JS_EXTENSIONS, findExists } from "@modern-js/utils";
+import { APP_FILE_NAME } from "./constants";
+var hasApp = function(dir) {
+  return findExists(JS_EXTENSIONS.map(function(ext) {
+    return path.resolve(dir, "".concat(APP_FILE_NAME).concat(ext));
+  }));
+};
+var isRuntimeEntry = function(dir) {
+  return hasApp(dir);
+};
+export {
+  isRuntimeEntry
+};

package/dist/esm/cli/index.js

@@ -5,6 +5,8 @@ import { statePlugin } from "../state/cli";
 import { ssrPlugin } from "../ssr/cli";
 import { routerPlugin } from "../router/cli";
 import { documentPlugin } from "../document/cli";
+import { isRuntimeEntry } from "./entry";
+import { isRuntimeEntry as isRuntimeEntry2 } from "./entry";
 var runtimePlugin = function() {
   return {
     name: "@modern-js/runtime",
@@ -24,6 +26,13 @@ var runtimePlugin = function() {
     ],
     setup: function(api) {
       return {
+        checkEntryPoint: function checkEntryPoint(param) {
+          var path = param.path, entry = param.entry;
+          return {
+            path,
+            entry: entry || isRuntimeEntry(path)
+          };
+        },
         config: function config() {
           var appDir = api.useAppContext().appDirectory;
           process.env.IS_REACT18 = isReact18(appDir).toString();
@@ -74,5 +83,6 @@ var runtimePlugin = function() {
 var cli_default = runtimePlugin;
 export {
   cli_default as default,
+  isRuntimeEntry2 as isRuntimeEntry,
   runtimePlugin
 };