@modern-js/runtime 2.54.6 → 2.56.0

package/dist/esm-node/core/server/utils.js

@@ -0,0 +1,60 @@
+import { isRouteErrorResponse } from "@modern-js/runtime-utils/remix-router";
+function attributesToString(attributes) {
+  return Object.entries(attributes).reduce((str, [key, value]) => {
+    return value === void 0 ? str : `${str} ${key}="${value}"`;
+  }, "");
+}
+function safeReplace(source, searchValue, replaceValue) {
+  return source.replace(searchValue, () => replaceValue);
+}
+function checkIsNode() {
+  var _process_release;
+  return typeof process !== "undefined" && ((_process_release = process.release) === null || _process_release === void 0 ? void 0 : _process_release.name) === "node";
+}
+function serializeErrors(errors) {
+  if (!errors) {
+    return null;
+  }
+  const entries = Object.entries(errors);
+  const serialized = {};
+  for (const [key, val] of entries) {
+    if (isRouteErrorResponse(val)) {
+      serialized[key] = {
+        ...val,
+        __type: "RouteErrorResponse"
+      };
+    } else if (val instanceof Error) {
+      serialized[key] = {
+        message: val.message,
+        stack: val.stack,
+        __type: "Error"
+      };
+    } else {
+      serialized[key] = val;
+    }
+  }
+  return serialized;
+}
+function getSSRConfigByEntry(entryName, ssr, ssrByEntries, staticGenerate) {
+  if (staticGenerate) {
+    return true;
+  }
+  if (ssrByEntries === null || ssrByEntries === void 0 ? void 0 : ssrByEntries[entryName]) {
+    return ssrByEntries[entryName];
+  }
+  return ssr;
+}
+function getSSRMode(ssrConfig) {
+  if (typeof ssrConfig === "boolean") {
+    return ssrConfig ? "string" : false;
+  }
+  return (ssrConfig === null || ssrConfig === void 0 ? void 0 : ssrConfig.mode) === "stream" ? "stream" : "string";
+}
+export {
+  attributesToString,
+  checkIsNode,
+  getSSRConfigByEntry,
+  getSSRMode,
+  safeReplace,
+  serializeErrors
+};

package/dist/esm-node/core/utils/merge.js

@@ -0,0 +1,29 @@
+function isObject(obj) {
+  return obj && typeof obj === "object" && !Array.isArray(obj);
+}
+function merge(target, ...sources) {
+  if (!sources.length) {
+    return target;
+  }
+  const source = sources.shift();
+  if (isObject(target) && isObject(source)) {
+    for (const key in source) {
+      if (isObject(source[key])) {
+        if (!target[key]) {
+          Object.assign(target, {
+            [key]: {}
+          });
+        }
+        merge(target[key], source[key]);
+      } else {
+        Object.assign(target, {
+          [key]: source[key]
+        });
+      }
+    }
+  }
+  return merge(target, ...sources);
+}
+export {
+  merge
+};

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

@@ -1,6 +1,7 @@
 import path from "path";
 import { fs, getEntryOptions, isRouterV5, isSSGEntry, isUseSSRBundle, logger } from "@modern-js/utils";
 import { FILE_SYSTEM_ROUTES_FILE_NAME } from "../constants";
+import { ENTRY_POINT_RUNTIME_GLOBAL_CONTEXT_FILE_NAME } from "../../../cli/constants";
 import * as templates from "./templates";
 import { getClientRoutes, getClientRoutesLegacy } from "./getClientRoutes";
 import { getServerLoadersFile, getServerCombinedModueFile } from "./utils";
@@ -10,16 +11,13 @@ const generateCode = async (appContext, config, entrypoints, api) => {
   const hookRunners = api.useHookRunners();
   const isV5 = isRouterV5(config);
   const getRoutes = isV5 ? getClientRoutesLegacy : getClientRoutes;
-  const importsStatemets = /* @__PURE__ */ new Map();
   const oldVersion = typeof (config === null || config === void 0 ? void 0 : config.runtime.router) === "object" ? Boolean((config === null || config === void 0 ? void 0 : config.runtime.router).oldVersion) : false;
   await Promise.all(entrypoints.map(generateEntryCode));
-  return {
-    importsStatemets
-  };
   async function generateEntryCode(entrypoint) {
-    const { entryName, isMainEntry, isAutoMount, fileSystemRoutes } = entrypoint;
+    const { entryName, isMainEntry, isAutoMount, pageRoutesEntry, nestedRoutesEntry } = entrypoint;
+    const { metaName } = api.useAppContext();
     if (isAutoMount) {
-      if (fileSystemRoutes) {
+      if (pageRoutesEntry || nestedRoutesEntry) {
         var _config_output;
         let initialRoutes = [];
         let nestedRoutes = null;
@@ -69,6 +67,7 @@ const generateCode = async (appContext, config, entrypoints, api) => {
         const { code } = await hookRunners.beforeGenerateRoutes({
           entrypoint,
           code: await templates.fileSystemRoutes({
+            metaName,
             routes,
             ssrMode: useSSG ? "string" : mode,
             nestedRoutesEntry: entrypoint.nestedRoutesEntry,
@@ -95,6 +94,10 @@ const generateCode = async (appContext, config, entrypoints, api) => {
     }
   }
 };
+function generatorRegisterCode(internalDirectory, entryName, code) {
+  fs.outputFileSync(path.resolve(internalDirectory, `./${entryName}/${ENTRY_POINT_RUNTIME_GLOBAL_CONTEXT_FILE_NAME}`), code, "utf8");
+}
 export {
-  generateCode
+  generateCode,
+  generatorRegisterCode
 };

package/dist/esm-node/router/cli/code/templates.js

@@ -1,8 +1,8 @@
 import path from "path";
-import { fs, getEntryOptions, isSSGEntry, slash } from "@modern-js/utils";
+import { findExists, formatImportPath, fs, getEntryOptions, isSSGEntry, slash } from "@modern-js/utils";
 import { ROUTE_MODULES } from "@modern-js/utils/universal/constants";
-import { TEMP_LOADERS_DIR } from "../constants";
-import { getServerLoadersFile } from "./utils";
+import { APP_CONFIG_NAME, APP_INIT_EXPORTED, TEMP_LOADERS_DIR } from "../constants";
+import { getPathWithoutExt, getServerLoadersFile, parseModule, replaceWithAlias } from "./utils";
 const routesForServer = ({ routes }) => {
   const loaders = [];
   const actions = [];
@@ -85,7 +85,7 @@ const routesForServer = ({ routes }) => {
 };
 const createMatchReg = (keyword) => new RegExp(`("${keyword}":\\s)"([^
 ]+)"`, "g");
-const fileSystemRoutes = async ({ routes, ssrMode, nestedRoutesEntry, entryName, internalDirectory, splitRouteChunks = true }) => {
+const fileSystemRoutes = async ({ metaName, routes, ssrMode, nestedRoutesEntry, entryName, internalDirectory, splitRouteChunks = true }) => {
   const components = [];
   const loadings = [];
   const errors = [];
@@ -96,7 +96,7 @@ const fileSystemRoutes = async ({ routes, ssrMode, nestedRoutesEntry, entryName,
   const loadersMapFile = path.join(internalDirectory, entryName, TEMP_LOADERS_DIR, "map.json");
   const importLazyCode = `
     import { lazy } from "react";
-    import loadable, { lazy as loadableLazy } from "@modern-js/runtime/loadable"
+    import loadable, { lazy as loadableLazy } from "@${metaName}/runtime/loadable"
   `;
   let rootLayoutCode = ``;
   const getDataLoaderPath = ({ loaderId, clientData, action, inline, routeId }) => {
@@ -295,7 +295,7 @@ const fileSystemRoutes = async ({ routes, ssrMode, nestedRoutesEntry, entryName,
   await fs.ensureFile(loadersMapFile);
   await fs.writeJSON(loadersMapFile, loadersMap);
   const importRuntimeRouterCode = `
-    import { createShouldRevalidate, handleRouteModule,  handleRouteModuleError} from '@modern-js/runtime/router';
+    import { createShouldRevalidate, handleRouteModule,  handleRouteModuleError} from '@${metaName}/runtime/router';
   `;
   const routeModulesCode = `
     if(typeof document !== 'undefined'){
@@ -328,8 +328,62 @@ function ssrLoaderCombinedModule(entrypoints, entrypoint, config, appContext) {
   }
   return null;
 }
+const runtimeGlobalContext = async ({ metaName, srcDirectory, nestedRoutesEntry, internalSrcAlias, globalApp }) => {
+  const imports = [
+    `import { setGlobalContext } from '@${metaName}/runtime/context';`
+  ];
+  if (nestedRoutesEntry) {
+    const rootLayoutPath = path.join(nestedRoutesEntry, "layout");
+    const rootLayoutFile = findExists([
+      ".js",
+      ".ts",
+      ".jsx",
+      ".tsx"
+    ].map((ext) => `${rootLayoutPath}${ext}`));
+    if (rootLayoutFile) {
+      const rootLayoutBuffer = await fs.readFile(rootLayoutFile);
+      const rootLayout = rootLayoutBuffer.toString();
+      const [, moduleExports] = await parseModule({
+        source: rootLayout.toString(),
+        filename: rootLayoutFile
+      });
+      const hasAppConfig = moduleExports.some((e) => e.n === APP_CONFIG_NAME);
+      const hasAppInit = moduleExports.some((e) => e.n === APP_INIT_EXPORTED);
+      const layoutPath = formatImportPath(getPathWithoutExt(replaceWithAlias(srcDirectory, rootLayoutFile, internalSrcAlias)));
+      if (hasAppConfig) {
+        imports.push(`import { config as appConfig } from '${layoutPath}';`);
+      } else {
+        imports.push(`let appConfig;`);
+      }
+      if (hasAppInit) {
+        imports.push(`import { init as appInit } from '${layoutPath}';`);
+      } else {
+        imports.push(`let appInit;`);
+      }
+    }
+  } else {
+    imports.push(`let appConfig;`);
+    imports.push(`let appInit;`);
+  }
+  if (globalApp) {
+    imports.push(`import layoutApp from '${formatImportPath(globalApp.replace(srcDirectory, internalSrcAlias))}';`);
+  } else {
+    imports.push(`let layoutApp;`);
+  }
+  return `${imports.join("\n")}
+
+import { routes } from './routes.js';
+
+setGlobalContext({
+  layoutApp,
+  routes,
+  appInit,
+  appConfig,
+});`;
+};
 export {
   fileSystemRoutes,
   routesForServer,
+  runtimeGlobalContext,
   ssrLoaderCombinedModule
 };

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

@@ -10,6 +10,8 @@ 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 APP_CONFIG_NAME = "config";
+const APP_INIT_EXPORTED = "init";
 const NESTED_ROUTE = {
   LAYOUT_FILE: "layout",
   LAYOUT_CONFIG_FILE: "layout.config",
@@ -32,6 +34,8 @@ const NESTED_ROUTE = {
 };
 export {
   ACTION_EXPORT_NAME,
+  APP_CONFIG_NAME,
+  APP_INIT_EXPORTED,
   FILE_SYSTEM_ROUTES_COMPONENTS_DIR,
   FILE_SYSTEM_ROUTES_DYNAMIC_REGEXP,
   FILE_SYSTEM_ROUTES_FILE_NAME,

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

@@ -18,31 +18,30 @@ const modifyEntrypoints = (entrypoints, config = {}) => {
     if (!entrypoint.isAutoMount) {
       return entrypoint;
     }
+    if (entrypoint === null || entrypoint === void 0 ? void 0 : entrypoint.isCustomSourceEntry) {
+      if (entrypoint.fileSystemRoutes) {
+        if (isRouterV5(config)) {
+          throw Error("Custom entries with conventional routing not support use react router v5!");
+        }
+        entrypoint.nestedRoutesEntry = entrypoint.entry;
+      }
+      return entrypoint;
+    }
     const isHasApp = hasApp(entrypoint.absoluteEntryDir);
     if (isHasApp) {
       return entrypoint;
     }
-    const isHasNestedRoutes = hasNestedRoutes(entrypoint.absoluteEntryDir);
     const isHasPages = hasPages(entrypoint.absoluteEntryDir);
-    if (!isHasNestedRoutes && !isHasPages && !entrypoint.fileSystemRoutes) {
-      return entrypoint;
-    }
-    if (entrypoint.fileSystemRoutes && !isRouterV5(config)) {
-      entrypoint.nestedRoutesEntry = entrypoint.entry;
-    } else if (!entrypoint.fileSystemRoutes) {
+    if (isHasPages) {
+      entrypoint.pageRoutesEntry = path.join(entrypoint.absoluteEntryDir, PAGES_DIR_NAME);
       entrypoint.fileSystemRoutes = {
+        ...entrypoint.fileSystemRoutes,
         globalApp: findExists(JS_EXTENSIONS.map((ext) => path.resolve(entrypoint.absoluteEntryDir, `./${PAGES_DIR_NAME}/${FILE_SYSTEM_ROUTES_GLOBAL_LAYOUT}${ext}`)))
       };
-      if (isHasPages) {
-        entrypoint.entry = path.join(entrypoint.absoluteEntryDir, PAGES_DIR_NAME);
-        entrypoint.pageRoutesEntry = entrypoint.entry;
-      }
-      if (isHasNestedRoutes) {
-        entrypoint.entry = path.join(entrypoint.absoluteEntryDir, NESTED_ROUTES_DIR);
-        entrypoint.nestedRoutesEntry = entrypoint.entry;
-      }
-    } else {
-      throw Error("Custom entries with conventional routing not support use react router v5!");
+    }
+    const isHasNestedRoutes = hasNestedRoutes(entrypoint.absoluteEntryDir);
+    if (isHasNestedRoutes) {
+      entrypoint.nestedRoutesEntry = path.join(entrypoint.absoluteEntryDir, NESTED_ROUTES_DIR);
     }
     return entrypoint;
   });

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

@@ -2,17 +2,32 @@ import path from "path";
 import { cloneDeep } from "@modern-js/utils/lodash";
 import { modifyEntrypoints } from "./entry";
 import { isPageComponentFile } from "./code/utils";
+import * as templates from "./code/templates";
 let originEntrypoints = [];
 async function handleModifyEntrypoints(api, entrypoints) {
   const config = api.useResolvedConfigContext();
-  const newEntryPoints = modifyEntrypoints(entrypoints, config);
+  return modifyEntrypoints(entrypoints, config);
+}
+async function handleGeneratorEntryCode(api, entrypoints) {
   const appContext = api.useAppContext();
+  const { internalDirectory } = api.useAppContext();
   const resolvedConfig = api.useResolvedConfigContext();
-  appContext.entrypoints = newEntryPoints;
-  originEntrypoints = cloneDeep(newEntryPoints);
-  const { generateCode } = await import("./code");
+  const { generatorRegisterCode, generateCode } = await import("./code");
+  originEntrypoints = cloneDeep(entrypoints);
   await generateCode(appContext, resolvedConfig, entrypoints, api);
-  return newEntryPoints;
+  await Promise.all(entrypoints.map(async (entrypoint) => {
+    if (entrypoint.nestedRoutesEntry || entrypoint.pageRoutesEntry) {
+      var _entrypoint_fileSystemRoutes;
+      generatorRegisterCode(internalDirectory, entrypoint.entryName, await templates.runtimeGlobalContext({
+        metaName: appContext.metaName,
+        srcDirectory: appContext.srcDirectory,
+        nestedRoutesEntry: entrypoint.nestedRoutesEntry,
+        internalSrcAlias: appContext.internalSrcAlias,
+        globalApp: (_entrypoint_fileSystemRoutes = entrypoint.fileSystemRoutes) === null || _entrypoint_fileSystemRoutes === void 0 ? void 0 : _entrypoint_fileSystemRoutes.globalApp
+      }));
+    }
+  }));
+  return entrypoints;
 }
 async function handleFileChange(api, e) {
   const appContext = api.useAppContext();
@@ -32,5 +47,6 @@ async function handleFileChange(api, e) {
 }
 export {
   handleFileChange,
+  handleGeneratorEntryCode,
   handleModifyEntrypoints
 };

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

@@ -1,19 +1,38 @@
-import { getEntryOptions, createRuntimeExportsUtils, isRouterV5 as isV5 } from "@modern-js/utils";
+import { createRuntimeExportsUtils, getEntryOptions, isRouterV5 as isV5 } from "@modern-js/utils";
 import { isRouteEntry } from "./entry";
-import { handleFileChange, handleModifyEntrypoints } from "./handler";
+import { handleFileChange, handleGeneratorEntryCode, handleModifyEntrypoints } from "./handler";
 import { isRouteEntry as isRouteEntry2 } from "./entry";
 import { handleFileChange as handleFileChange2, handleModifyEntrypoints as handleModifyEntrypoints2 } from "./handler";
-const PLUGIN_IDENTIFIER = "router";
-const ROUTES_IDENTIFIER = "routes";
 const routerPlugin = () => ({
   name: "@modern-js/plugin-router",
   required: [
     "@modern-js/runtime"
   ],
   setup: (api) => {
-    const runtimeConfigMap = /* @__PURE__ */ new Map();
-    let pluginsExportsUtils;
     return {
+      _internalRuntimePlugins({ entrypoint, plugins }) {
+        var _getEntryOptions;
+        const { packageName, serverRoutes, metaName } = api.useAppContext();
+        const serverBase = serverRoutes.filter((route) => route.entryName === entrypoint.entryName).map((route) => route.urlPath).sort((a, b) => a.length - b.length > 0 ? -1 : 1);
+        const userConfig = api.useResolvedConfigContext();
+        const routerConfig = (_getEntryOptions = getEntryOptions(entrypoint.entryName, entrypoint.isMainEntry, userConfig.runtime, userConfig.runtimeByEntries, packageName)) === null || _getEntryOptions === void 0 ? void 0 : _getEntryOptions.router;
+        if (routerConfig && !isV5(userConfig)) {
+          plugins.push({
+            name: "router",
+            path: `@${metaName}/runtime/router`,
+            config: typeof routerConfig === "boolean" ? {
+              serverBase
+            } : {
+              ...routerConfig,
+              serverBase
+            }
+          });
+        }
+        return {
+          entrypoint,
+          plugins
+        };
+      },
       checkEntryPoint({ path, entry }) {
         return {
           path,
@@ -21,8 +40,6 @@ const routerPlugin = () => ({
         };
       },
       config() {
-        const appContext = api.useAppContext();
-        pluginsExportsUtils = createRuntimeExportsUtils(appContext.internalDirectory, "plugins");
         return {
           source: {
             include: [
@@ -32,10 +49,7 @@ const routerPlugin = () => ({
               /node_modules\/react-router/,
               /node_modules\/react-router-dom/,
               /node_modules\/@remix-run\/router/
-            ],
-            alias: {
-              "@modern-js/runtime/plugins": pluginsExportsUtils.getPath()
-            }
+            ]
           }
         };
       },
@@ -45,56 +59,15 @@ const routerPlugin = () => ({
           entrypoints: newEntryPoints
         };
       },
-      modifyEntryImports({ entrypoint, imports }) {
-        const { entryName, isMainEntry, fileSystemRoutes } = entrypoint;
-        const userConfig = api.useResolvedConfigContext();
-        const { packageName } = api.useAppContext();
-        const runtimeConfig = getEntryOptions(entryName, isMainEntry, userConfig.runtime, userConfig.runtimeByEntries, packageName);
-        runtimeConfigMap.set(entryName, runtimeConfig);
-        if (runtimeConfig === null || runtimeConfig === void 0 ? void 0 : runtimeConfig.router) {
-          if (!isV5(userConfig)) {
-            imports.push({
-              value: "@modern-js/runtime/plugins",
-              specifiers: [
-                {
-                  imported: PLUGIN_IDENTIFIER
-                }
-              ]
-            });
-          }
-        } else if (fileSystemRoutes) {
-          throw new Error(`should enable runtime.router for entry ${entryName}`);
-        }
-        return {
-          entrypoint,
-          imports
-        };
-      },
-      modifyEntryRuntimePlugins({ entrypoint, plugins }) {
-        const { entryName, fileSystemRoutes } = entrypoint;
-        const { serverRoutes } = api.useAppContext();
-        const userConfig = api.useResolvedConfigContext();
-        const runtimeConfig = runtimeConfigMap.get(entryName);
-        if (runtimeConfig.router && !isV5(userConfig)) {
-          const serverBase = serverRoutes.filter((route) => route.entryName === entryName).map((route) => route.urlPath).sort((a, b) => a.length - b.length > 0 ? -1 : 1);
-          plugins.push({
-            name: PLUGIN_IDENTIFIER,
-            options: JSON.stringify({
-              serverBase,
-              ...runtimeConfig.router,
-              routesConfig: fileSystemRoutes ? `{ ${ROUTES_IDENTIFIER}, globalApp: App }` : void 0
-            }).replace(/"routesConfig"\s*:\s*"((\S|\s)+)"/g, '"routesConfig": $1,')
-          });
-        }
-        return {
-          entrypoint,
-          plugins
-        };
+      async generateEntryCode({ entrypoints }) {
+        await handleGeneratorEntryCode(api, entrypoints);
       },
       addRuntimeExports() {
         const userConfig = api.useResolvedConfigContext();
+        const { internalDirectory, metaName } = api.useAppContext();
+        const pluginsExportsUtils = createRuntimeExportsUtils(internalDirectory, "plugins");
         if (!isV5(userConfig)) {
-          pluginsExportsUtils.addExport(`export { default as router } from '@modern-js/runtime/router'`);
+          pluginsExportsUtils.addExport(`export { default as router } from '@${metaName}/runtime/router'`);
         }
       },
       async fileChange(e) {

package/dist/esm-node/router/runtime/PrefetchLink.js

@@ -70,7 +70,7 @@ async function loadRouteModule(route, routeAssets) {
   }
   try {
     await Promise.all(chunkIds.map((chunkId) => {
-      return __webpack_chunk_load__ === null || __webpack_chunk_load__ === void 0 ? void 0 : __webpack_chunk_load__(String(chunkId));
+      return __webpack_chunk_load__ === null || __webpack_chunk_load__ === void 0 ? void 0 : __webpack_chunk_load__(chunkId);
     }));
   } catch (error) {
     console.error(error);

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

@@ -20,5 +20,6 @@ export {
   handleRouteModuleError,
   modifyRoutes,
   renderRoutes,
+  routerPlugin,
   useRouteLoaderData
 };

package/dist/esm-node/router/runtime/plugin.js

@@ -1,8 +1,8 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { useContext, useMemo } from "react";
 import { createBrowserRouter, createHashRouter, RouterProvider, createRoutesFromElements, useMatches, useLocation, useHref } from "@modern-js/runtime-utils/router";
-import hoistNonReactStatics from "hoist-non-react-statics";
 import { parsedJSONFromElement } from "@modern-js/runtime-utils/parsed";
+import { getGlobalLayoutApp, getGlobalRoutes } from "../../core/context";
 import { RuntimeReactContext } from "../../core";
 import { modifyRoutes as modifyRoutesHook } from "./hooks";
 import { deserializeErrors, renderRoutes, urlJoin } from "./utils";
@@ -19,19 +19,14 @@ function modifyRoutes(modifyFunction) {
     console.error("It is not allowed to modify routes config after create router.");
   }
 }
-const routerPlugin = ({
-  serverBase = [],
-  supportHtml5History = true,
-  basename = "",
-  // when the current child app has multiple entries, there is a problem,
-  // so we have added a new parameter, the parameter will replace basename and baseUrl after the major version.
-  originalBaseUrl = "",
-  routesConfig,
-  createRoutes
-}) => {
+const routerPlugin = ({ serverBase = [], supportHtml5History = true, basename = "", routesConfig, createRoutes }) => {
   const select = (pathname) => serverBase.find((baseUrl) => pathname.search(baseUrl) === 0) || "/";
   let routes = [];
-  finalRouteConfig = routesConfig;
+  finalRouteConfig = {
+    routes: getGlobalRoutes(),
+    globalApp: getGlobalLayoutApp(),
+    ...routesConfig
+  };
   window._SERVER_DATA = parsedJSONFromElement("__MODERN_SERVER_DATA__");
   return {
     name: "@modern-js/plugin-router",
@@ -56,7 +51,7 @@ const routerPlugin = ({
           });
         },
         hoc: ({ App, config }, next) => {
-          if (!finalRouteConfig && !createRoutes) {
+          if (!finalRouteConfig.routes && !createRoutes) {
             return next({
               App,
               config
@@ -64,8 +59,8 @@ const routerPlugin = ({
           }
           const getRouteApp = () => {
             const useCreateRouter = (props) => {
-              var _window__SERVER_DATA;
-              const baseUrl = originalBaseUrl || ((_window__SERVER_DATA = window._SERVER_DATA) === null || _window__SERVER_DATA === void 0 ? void 0 : _window__SERVER_DATA.router.baseUrl) || select(location.pathname);
+              var _config_router, _window__SERVER_DATA;
+              const baseUrl = ((config === null || config === void 0 ? void 0 : (_config_router = config.router) === null || _config_router === void 0 ? void 0 : _config_router.basename) || ((_window__SERVER_DATA = window._SERVER_DATA) === null || _window__SERVER_DATA === void 0 ? void 0 : _window__SERVER_DATA.router.baseUrl) || select(location.pathname)).replace(/^\/*/, "/");
               const _basename = baseUrl === "/" ? urlJoin(baseUrl, basename) : baseUrl;
               let hydrationData = window._ROUTER_DATA;
               const runtimeContext = useContext(RuntimeReactContext);
@@ -119,24 +114,12 @@ const routerPlugin = ({
             return (props) => {
               beforeCreateRouter = false;
               const router = useCreateRouter(props);
-              return /* @__PURE__ */ _jsx(App, {
-                ...props,
-                children: /* @__PURE__ */ _jsx(RouterProvider, {
-                  router
-                })
+              return /* @__PURE__ */ _jsx(RouterProvider, {
+                router
               });
             };
           };
-          let RouteApp = getRouteApp();
-          if (App) {
-            RouteApp = hoistNonReactStatics(RouteApp, App);
-          }
-          if (routesConfig === null || routesConfig === void 0 ? void 0 : routesConfig.globalApp) {
-            return next({
-              App: hoistNonReactStatics(RouteApp, routesConfig.globalApp),
-              config
-            });
-          }
+          const RouteApp = getRouteApp();
           return next({
             App: RouteApp,
             config