@modern-js/runtime 2.54.6 → 2.55.0

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/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

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

@@ -1,28 +1,17 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
 import { useContext } from "react";
 import { createStaticHandler } from "@modern-js/runtime-utils/remix-router";
 import { createStaticRouter, StaticRouterProvider } from "@modern-js/runtime-utils/node/router";
-import hoistNonReactStatics from "hoist-non-react-statics";
 import { createRoutesFromElements } from "@modern-js/runtime-utils/router";
 import { reporterCtx, createRequestContext } from "@modern-js/runtime-utils/node";
 import { time } from "@modern-js/runtime-utils/time";
 import { LOADER_REPORTER_NAME } from "@modern-js/utils/universal/constants";
 import { JSX_SHELL_STREAM_END_MARK } from "../../common";
 import { RuntimeReactContext } from "../../core";
+import { getGlobalLayoutApp, getGlobalRoutes } from "../../core/context";
 import { renderRoutes, urlJoin } from "./utils";
 import { modifyRoutes as modifyRoutesHook } from "./hooks";
 import DeferredDataScripts from "./DeferredDataScripts.node";
-function createFetchRequest(req) {
-  const origin = `${req.protocol}://${req.host}`;
-  const url = new URL(req.originalUrl || req.url, origin);
-  const controller = new AbortController();
-  const init = {
-    method: req.method,
-    headers: createFetchHeaders(req.headers),
-    signal: controller.signal
-  };
-  return new Request(url.href, init);
-}
 function createFetchHeaders(requestHeaders) {
   const headers = new Headers();
   for (const [key, values] of Object.entries(requestHeaders || {})) {
@@ -38,29 +27,34 @@ function createFetchHeaders(requestHeaders) {
   }
   return headers;
 }
-const routerPlugin = ({ basename = "", originalBaseUrl = "", routesConfig, createRoutes }) => {
+const routerPlugin = ({ basename = "", routesConfig, createRoutes }) => {
   return {
     name: "@modern-js/plugin-router",
     registerHook: {
       modifyRoutes: modifyRoutesHook
     },
     setup: (api) => {
+      const finalRouteConfig = {
+        routes: getGlobalRoutes(),
+        globalApp: getGlobalLayoutApp(),
+        ...routesConfig
+      };
       return {
         async init({ context }, next) {
-          var _context_ssrContext;
-          if (!routesConfig && !createRoutes) {
+          var _context_ssrContext, _context_ssrContext_onTiming, _context_ssrContext1;
+          if (!finalRouteConfig.routes && !createRoutes) {
             return next({
               context
             });
           }
           const { request, mode: ssrMode, nonce, loaderFailureMode = "errorBoundary" } = context.ssrContext;
-          const baseUrl = originalBaseUrl || request.baseUrl;
+          const { baseUrl } = request;
           const _basename = baseUrl === "/" ? urlJoin(baseUrl, basename) : baseUrl;
-          const { reporter, serverTiming } = context.ssrContext;
+          const { reporter } = context.ssrContext;
           const requestContext = createRequestContext((_context_ssrContext = context.ssrContext) === null || _context_ssrContext === void 0 ? void 0 : _context_ssrContext.loaderContext);
           requestContext.set(reporterCtx, reporter);
           let routes = createRoutes ? createRoutes() : createRoutesFromElements(renderRoutes({
-            routesConfig,
+            routesConfig: finalRouteConfig,
             ssrMode,
             props: {
               nonce
@@ -72,14 +66,13 @@ const routerPlugin = ({ basename = "", originalBaseUrl = "", routesConfig, creat
           const { query } = createStaticHandler(routes, {
             basename: _basename
           });
-          const remixRequest = createFetchRequest(request);
+          const remixRequest = context.ssrContext.request.raw;
           const end = time();
           const routerContext = await query(remixRequest, {
             requestContext
           });
           const cost = end();
-          reporter === null || reporter === void 0 ? void 0 : reporter.reportTiming(LOADER_REPORTER_NAME, cost);
-          serverTiming.addServeTiming(LOADER_REPORTER_NAME, cost);
+          (_context_ssrContext1 = context.ssrContext) === null || _context_ssrContext1 === void 0 ? void 0 : (_context_ssrContext_onTiming = _context_ssrContext1.onTiming) === null || _context_ssrContext_onTiming === void 0 ? void 0 : _context_ssrContext_onTiming.call(_context_ssrContext1, LOADER_REPORTER_NAME, cost);
           if (routerContext instanceof Response) {
             return routerContext;
           }
@@ -91,24 +84,22 @@ const routerPlugin = ({ basename = "", originalBaseUrl = "", routesConfig, creat
           context.remixRouter = router;
           context.routerContext = routerContext;
           context.routes = routes;
-          context.routeManifest = context.ssrContext.routeManifest;
           return next({
             context
           });
         },
         hoc: ({ App, config }, next) => {
-          if (!routesConfig) {
+          if (!finalRouteConfig) {
             return next({
               App,
               config
             });
           }
           const getRouteApp = () => {
-            return (props) => {
+            return () => {
               const { remixRouter, routerContext, ssrContext } = useContext(RuntimeReactContext);
               const { nonce, mode } = ssrContext;
-              return /* @__PURE__ */ _jsxs(App, {
-                ...props,
+              return /* @__PURE__ */ _jsxs(_Fragment, {
                 children: [
                   /* @__PURE__ */ _jsx(StaticRouterProvider, {
                     router: remixRouter,
@@ -125,12 +116,6 @@ const routerPlugin = ({ basename = "", originalBaseUrl = "", routesConfig, creat
             };
           };
           const RouteApp = getRouteApp();
-          if (routesConfig === null || routesConfig === void 0 ? void 0 : routesConfig.globalApp) {
-            return next({
-              App: hoistNonReactStatics(RouteApp, routesConfig.globalApp),
-              config
-            });
-          }
           return next({
             App: RouteApp,
             config

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

@@ -1,4 +1,4 @@
-import { getEntryOptions, createRuntimeExportsUtils } from "@modern-js/utils";
+import { createRuntimeExportsUtils, getEntryOptions } from "@modern-js/utils";
 const PLUGIN_IDENTIFIER = "state";
 const statePlugin = () => ({
   name: "@modern-js/plugin-state",
@@ -6,48 +6,18 @@ const statePlugin = () => ({
     "@modern-js/runtime"
   ],
   setup: (api) => {
-    const stateConfigMap = /* @__PURE__ */ new Map();
-    let pluginsExportsUtils;
     return {
-      config() {
-        const appContext = api.useAppContext();
-        pluginsExportsUtils = createRuntimeExportsUtils(appContext.internalDirectory, "plugins");
-        return {
-          source: {
-            alias: {
-              "@modern-js/runtime/plugins": pluginsExportsUtils.getPath()
-            }
-          }
-        };
-      },
-      modifyEntryImports({ entrypoint, imports }) {
+      _internalRuntimePlugins({ entrypoint, plugins }) {
         var _getEntryOptions;
         const { entryName, isMainEntry } = entrypoint;
         const userConfig = api.useResolvedConfigContext();
-        const { packageName } = api.useAppContext();
+        const { packageName, metaName } = api.useAppContext();
         const stateConfig = (_getEntryOptions = getEntryOptions(entryName, isMainEntry, userConfig.runtime, userConfig.runtimeByEntries, packageName)) === null || _getEntryOptions === void 0 ? void 0 : _getEntryOptions.state;
-        stateConfigMap.set(entryName, stateConfig);
         if (stateConfig) {
-          imports.push({
-            value: "@modern-js/runtime/plugins",
-            specifiers: [
-              {
-                imported: PLUGIN_IDENTIFIER
-              }
-            ]
-          });
-        }
-        return {
-          entrypoint,
-          imports
-        };
-      },
-      modifyEntryRuntimePlugins({ entrypoint, plugins }) {
-        const stateOptions = stateConfigMap.get(entrypoint.entryName);
-        if (stateOptions) {
           plugins.push({
             name: PLUGIN_IDENTIFIER,
-            options: `${JSON.stringify(stateConfigMap.get(entrypoint.entryName))}`
+            path: `@${metaName}/runtime/model`,
+            config: typeof stateConfig === "boolean" ? {} : stateConfig
           });
         }
         return {
@@ -56,7 +26,9 @@ const statePlugin = () => ({
         };
       },
       addRuntimeExports() {
-        pluginsExportsUtils.addExport(`export { default as state } from '@modern-js/runtime/model'`);
+        const { internalDirectory, metaName } = api.useAppContext();
+        const pluginsExportsUtils = createRuntimeExportsUtils(internalDirectory, "plugins");
+        pluginsExportsUtils.addExport(`export { default as state } from '@${metaName}/runtime/model'`);
       }
     };
   }

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

@@ -2,7 +2,6 @@ import { jsx as _jsx } from "react/jsx-runtime";
 import { useContext } from "react";
 import { createStore } from "@modern-js-reduck/store";
 import { Provider } from "@modern-js-reduck/react";
-import hoistNonReactStatics from "hoist-non-react-statics";
 import { immer, effects, autoActions, devtools } from "../plugins";
 import { RuntimeReactContext } from "../../core";
 import { isBrowser } from "../../common";
@@ -30,7 +29,7 @@ const getStoreConfig = (config) => {
   storeConfig.plugins = plugins;
   return storeConfig;
 };
-const state = (config) => ({
+const statePlugin = (config) => ({
   name: "@modern-js/plugin-state",
   setup: () => {
     const storeConfig = getStoreConfig(config);
@@ -47,7 +46,7 @@ const state = (config) => ({
           });
         };
         return next({
-          App: hoistNonReactStatics(getStateApp, App),
+          App: getStateApp,
           config: config2
         });
       },
@@ -73,8 +72,9 @@ const state = (config) => ({
     };
   }
 });
-var plugin_default = state;
+var plugin_default = statePlugin;
 export * from "../plugins";
 export {
-  plugin_default as default
+  plugin_default as default,
+  statePlugin
 };

package/dist/types/cli/alias.d.ts

@@ -0,0 +1,7 @@
+import { Entrypoint } from '@modern-js/types';
+import type { RsbuildPlugin } from '@rsbuild/core';
+export declare const builderPluginAlias: ({ entrypoints, internalDirectory, metaName, }: {
+    entrypoints: Entrypoint[];
+    internalDirectory: string;
+    metaName: string;
+}) => RsbuildPlugin;

package/dist/types/cli/code.d.ts

@@ -0,0 +1,10 @@
+import type { AppTools, IAppContext, NormalizedConfig, RuntimePlugin } from '@modern-js/app-tools';
+import { Entrypoint } from '@modern-js/types';
+import type { MaybeAsync } from '@modern-js/plugin';
+export declare const generateCode: (entrypoints: Entrypoint[], appContext: IAppContext, config: NormalizedConfig<AppTools>, onCollectRuntimePlugins: (params: {
+    entrypoint: Entrypoint;
+    plugins: RuntimePlugin[];
+}) => MaybeAsync<{
+    entrypoint: Entrypoint;
+    plugins: RuntimePlugin[];
+}>) => Promise<void>;

package/dist/types/cli/constants.d.ts

@@ -1 +1,8 @@
 export declare const APP_FILE_NAME = "App";
+export declare const ENTRY_POINT_FILE_NAME = "index.jsx";
+export declare const SERVER_ENTRY_POINT_FILE_NAME = "index.server.jsx";
+export declare const INDEX_FILE_NAME = "index";
+export declare const ENTRY_BOOTSTRAP_FILE_NAME = "bootstrap.jsx";
+export declare const ENTRY_POINT_RUNTIME_REGISTER_FILE_NAME = "runtime-register.js";
+export declare const ENTRY_POINT_RUNTIME_GLOBAL_CONTEXT_FILE_NAME = "runtime-global-context.js";
+export declare const ENTRY_POINT_REGISTER_FILE_NAME = "register.js";

package/dist/types/cli/index.d.ts

@@ -1,4 +1,11 @@
 import type { CliPlugin, AppTools } from '@modern-js/app-tools';
+import { statePlugin } from '../state/cli';
+import { routerPlugin } from '../router/cli';
+import { documentPlugin } from '../document/cli';
+import { ssrPlugin } from './ssr';
 export { isRuntimeEntry } from './entry';
-export declare const runtimePlugin: () => CliPlugin<AppTools>;
+export { statePlugin, ssrPlugin, routerPlugin, documentPlugin };
+export declare const runtimePlugin: (params?: {
+    plugins?: CliPlugin<AppTools>[];
+}) => CliPlugin<AppTools>;
 export default runtimePlugin;

package/dist/types/cli/template.d.ts

@@ -0,0 +1,27 @@
+import type { RuntimePlugin } from '@modern-js/app-tools';
+export declare const index: ({ srcDirectory, internalSrcAlias, metaName, entry, entryName, customEntry, customBootstrap, mountId, }: {
+    srcDirectory: string;
+    internalSrcAlias: string;
+    metaName: string;
+    entry: string;
+    entryName: string;
+    customEntry?: boolean | undefined;
+    customBootstrap?: string | false | undefined;
+    mountId?: string | undefined;
+}) => string;
+export declare const register: () => string;
+export declare const runtimeRegister: ({ entryName, srcDirectory, internalSrcAlias, metaName, runtimeConfigFile, runtimePlugins, }: {
+    entryName: string;
+    srcDirectory: string;
+    internalSrcAlias: string;
+    metaName: string;
+    runtimeConfigFile: string | false;
+    runtimePlugins: RuntimePlugin[];
+}) => string;
+export declare const runtimeGlobalContext: ({ srcDirectory, internalSrcAlias, metaName, entry, customEntry, }: {
+    srcDirectory: string;
+    internalSrcAlias: string;
+    metaName: string;
+    entry: string;
+    customEntry?: boolean | undefined;
+}) => string;

package/dist/types/cli/template.server.d.ts

@@ -0,0 +1,15 @@
+type ServerIndexOptinos = GenHandlerCodeOptions & {
+    entryName: string;
+};
+export declare const serverIndex: (options: ServerIndexOptinos) => string;
+type GenHandlerCodeOptions = {
+    customServerEntry?: string | false;
+    srcDirectory: string;
+    internalSrcAlias: string;
+    entry: string;
+} & TransformServerEntryOptions;
+type TransformServerEntryOptions = {
+    metaName?: string;
+    mode: 'string' | 'stream';
+};
+export {};

package/dist/types/common.d.ts

@@ -1,8 +1,17 @@
 import type { StateConfig } from './state';
+import type { Plugin } from './core/plugin';
 export declare const isBrowser: () => boolean;
 export interface AppConfig {
     state?: StateConfig | boolean;
     [key: string]: any;
 }
+export interface RuntimeConfig {
+    state?: StateConfig;
+    stateByEntries?: {
+        [name: string]: StateConfig;
+    };
+    plugins?: Plugin[];
+    [key: string]: any;
+}
 export declare const JSX_SHELL_STREAM_END_MARK = "<!--<?- SHELL_STREAM_END ?>-->";
 export declare const ESCAPED_SHELL_STREAM_END_MARK = "&lt;!--&lt;?- SHELL_STREAM_END ?&gt;--&gt;";

package/dist/types/core/browser/hydrate.d.ts

@@ -0,0 +1,5 @@
+import React from 'react';
+import { Root } from 'react-dom/client';
+import { RuntimeContext } from '../context';
+export declare const isReact18: () => boolean;
+export declare function hydrateRoot(App: React.ReactElement, context: RuntimeContext, ModernRender: (App: React.ReactElement) => Promise<HTMLElement | Root>, ModernHydrate: (App: React.ReactElement, callback?: () => void) => Promise<HTMLElement | Root>): Promise<HTMLElement | Root>;

package/dist/types/core/browser/index.d.ts

@@ -0,0 +1,2 @@
+import React from 'react';
+export declare function render(App: React.ReactElement, id?: HTMLElement | string): Promise<HTMLElement | import("react-dom/client").Root>;

package/dist/types/core/config.d.ts

@@ -1,14 +1,13 @@
 import type React from 'react';
-import { AppConfig } from '../common';
-import { Plugin } from './plugin';
+import { AppConfig, RuntimeConfig } from '../common';
 export declare const getConfig: (Component: React.ComponentType<any>) => AppConfig | undefined;
+/**
+ * @deprecated
+ * define config in modern.runtime.ts file
+ */
 export declare const defineConfig: (Component: React.ComponentType<any>, config: AppConfig) => React.ComponentType<any>;
-interface RuntimeConfig {
-    plugins: Plugin[];
-}
 /**
  * This function helps you to autocomplete configuration types.
  * It accepts a direct config object, or a function that returns a config.
  */
 export declare const defineRuntimeConfig: (config: RuntimeConfig) => RuntimeConfig;
-export {};

package/dist/types/core/constants.d.ts

@@ -0,0 +1,5 @@
+export declare enum RenderLevel {
+    CLIENT_RENDER = 0,
+    SERVER_PREFETCH = 1,
+    SERVER_RENDER = 2
+}

package/dist/types/core/context/index.d.ts

@@ -1 +1,34 @@
-export { RuntimeReactContext } from './runtime';
+/// <reference types="react" />
+import type { NestedRoute, PageRoute } from '@modern-js/types';
+import { AppConfig } from '../../common';
+export { RuntimeReactContext, type RuntimeContext } from './runtime';
+interface GlobalContext {
+    /**
+     * App.tsx export default component
+     */
+    App?: React.ComponentType;
+    /**
+     * nest router and page router config
+     */
+    routes?: (NestedRoute | PageRoute)[];
+    /**
+     * nest router init function
+     */
+    appInit?: () => Promise<unknown>;
+    /**
+     * nest router config function
+     */
+    appConfig?: AppConfig;
+    /**
+     * page router _app.tsx export layout app
+     */
+    layoutApp?: React.ComponentType;
+}
+export declare function setGlobalContext(context: Omit<GlobalContext, 'appConfig'> & {
+    appConfig: () => AppConfig;
+}): void;
+export declare function getGlobalApp(): import("react").ComponentType<{}> | undefined;
+export declare function getGlobalRoutes(): undefined | (NestedRoute | PageRoute)[];
+export declare function getGlobalAppInit(): any;
+export declare function getGlobalAppConfig(): any;
+export declare function getGlobalLayoutApp(): import("react").ComponentType<{}> | undefined;

package/dist/types/core/context/runtime.d.ts

@@ -4,7 +4,7 @@ import { type StaticHandlerContext, type Router, type RouterState } from '@moder
 import { createLoaderManager } from '../loader/loaderManager';
 import { PluginRunner, runtime } from '../plugin';
 import { RouteManifest } from '../../router/runtime/types';
-import { SSRServerContext } from '../../ssr/serverRender/types';
+import { SSRServerContext } from '../types';
 export interface BaseRuntimeContext {
     initialData?: Record<string, unknown>;
     loaderManager: ReturnType<typeof createLoaderManager>;
@@ -40,4 +40,4 @@ export interface BaseTRuntimeContext {
 export interface TRuntimeContext extends BaseTRuntimeContext {
     [key: string]: any;
 }
-export declare const getInitialContext: (runner: PluginRunner) => RuntimeContext;
+export declare const getInitialContext: (runner: PluginRunner, isBrowser?: boolean, routeManifest?: RouteManifest) => RuntimeContext;