@modern-js/runtime 2.56.2 → 2.57.0

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

@@ -1,5 +1,6 @@
 import path from "path";
-import { fs, getEntryOptions, isRouterV5, isSSGEntry, isUseSSRBundle, logger } from "@modern-js/utils";
+import { fs, getEntryOptions, isRouterV5, isSSGEntry, isUseSSRBundle, logger, filterRoutesForServer, filterRoutesLoader } from "@modern-js/utils";
+import { cloneDeep } from "@modern-js/utils/lodash";
 import { FILE_SYSTEM_ROUTES_FILE_NAME } from "../constants";
 import { ENTRY_POINT_RUNTIME_GLOBAL_CONTEXT_FILE_NAME } from "../../../cli/constants";
 import * as templates from "./templates";
@@ -46,11 +47,14 @@ const generateCode = async (appContext, config, entrypoints, api) => {
             }
           }
         }
+        const config2 = api.useResolvedConfigContext();
+        const ssrByRouteIds = config2.server.ssrByRouteIds || [];
+        const clonedRoutes = cloneDeep(initialRoutes);
+        const markedRoutes = ssrByRouteIds.length > 0 ? markRoutes(clonedRoutes, ssrByRouteIds) : initialRoutes;
         const { routes } = await hookRunners.modifyFileSystemRoutes({
           entrypoint,
-          routes: initialRoutes
+          routes: markedRoutes
         });
-        const config2 = api.useResolvedConfigContext();
         const ssr = getEntryOptions(entryName, isMainEntry, config2.server.ssr, config2.server.ssrByEntries, packageName);
         const useSSG = isSSGEntry(config2, entryName, entrypoints);
         let mode;
@@ -77,23 +81,55 @@ const generateCode = async (appContext, config, entrypoints, api) => {
           })
         });
         if (entrypoint.nestedRoutesEntry && isUseSSRBundle(config2)) {
+          var _config_output1;
           const routesServerFile = getServerLoadersFile(internalDirectory, entryName);
+          const filtedRoutesForServer = filterRoutesForServer(routes);
+          const routesForServerLoaderMatches = filterRoutesLoader(routes);
           const code2 = templates.routesForServer({
-            routes
+            routesForServerLoaderMatches
           });
           await fs.ensureFile(routesServerFile);
           await fs.writeFile(routesServerFile, code2);
+          const serverRoutesCode = await templates.fileSystemRoutes({
+            metaName,
+            routes: filtedRoutesForServer,
+            ssrMode: useSSG ? "string" : mode,
+            nestedRoutesEntry: entrypoint.nestedRoutesEntry,
+            entryName: entrypoint.entryName,
+            internalDirectory,
+            splitRouteChunks: config2 === null || config2 === void 0 ? void 0 : (_config_output1 = config2.output) === null || _config_output1 === void 0 ? void 0 : _config_output1.splitRouteChunks
+          });
+          await fs.outputFile(path.resolve(internalDirectory, `./${entryName}/routes.server.js`), serverRoutesCode, "utf8");
         }
         const serverLoaderCombined = templates.ssrLoaderCombinedModule(entrypoints, entrypoint, config2, appContext);
         if (serverLoaderCombined) {
           const serverLoaderFile = getServerCombinedModueFile(internalDirectory, entryName);
           await fs.outputFile(serverLoaderFile, serverLoaderCombined);
         }
-        fs.outputFileSync(path.resolve(internalDirectory, `./${entryName}/${FILE_SYSTEM_ROUTES_FILE_NAME}`), code, "utf8");
+        await fs.outputFile(path.resolve(internalDirectory, `./${entryName}/${FILE_SYSTEM_ROUTES_FILE_NAME}`), code, "utf8");
       }
     }
   }
 };
+function markRoutes(routes, routeIds) {
+  return routes.map((route) => {
+    if (route.type !== "nested") {
+      return route;
+    }
+    if (route.children && route.children.length > 0) {
+      route.children = markRoutes(route.children, routeIds);
+    }
+    if (route.children && route.children.length > 0) {
+      route.inValidSSRRoute = route.children.every((child) => {
+        var _child_inValidSSRRoute;
+        return (_child_inValidSSRRoute = child.inValidSSRRoute) !== null && _child_inValidSSRRoute !== void 0 ? _child_inValidSSRRoute : false;
+      });
+    } else if (route.id) {
+      route.inValidSSRRoute = !routeIds.includes(route.id);
+    }
+    return route;
+  });
+}
 function generatorRegisterCode(internalDirectory, entryName, code) {
   fs.outputFileSync(path.resolve(internalDirectory, `./${entryName}/${ENTRY_POINT_RUNTIME_GLOBAL_CONTEXT_FILE_NAME}`), code, "utf8");
 }

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

@@ -3,7 +3,7 @@ import { findExists, formatImportPath, fs, getEntryOptions, isSSGEntry, slash }
 import { ROUTE_MODULES } from "@modern-js/utils/universal/constants";
 import { APP_CONFIG_NAME, APP_INIT_EXPORTED, TEMP_LOADERS_DIR } from "../constants";
 import { getPathWithoutExt, getServerLoadersFile, parseModule, replaceWithAlias } from "./utils";
-const routesForServer = ({ routes }) => {
+const routesForServer = ({ routesForServerLoaderMatches }) => {
   const loaders = [];
   const actions = [];
   const loadersMap = {};
@@ -46,7 +46,7 @@ const routesForServer = ({ routes }) => {
   let routesCode = `
   export const routes = [
   `;
-  for (const route of routes) {
+  for (const route of routesForServerLoaderMatches) {
     if ("type" in route) {
       const keywords = [
         "loader",
@@ -99,13 +99,14 @@ const fileSystemRoutes = async ({ metaName, routes, ssrMode, nestedRoutesEntry,
     import loadable, { lazy as loadableLazy } from "@${metaName}/runtime/loadable"
   `;
   let rootLayoutCode = ``;
-  const getDataLoaderPath = ({ loaderId, clientData, action, inline, routeId }) => {
+  const getDataLoaderPath = ({ loaderId, clientData, action, inline, routeId, inValidSSRRoute }) => {
     if (!ssrMode) {
       return "";
     }
     const clientDataStr = clientData ? `&clientData=${clientData}` : "";
+    const retain = inValidSSRRoute !== null && inValidSSRRoute !== void 0 ? inValidSSRRoute : false;
     if (nestedRoutesEntry) {
-      return `?loaderId=${loaderId}${clientDataStr}&action=${action ? slash(action) : action}&inline=${inline}&routeId=${routeId}`;
+      return `?loaderId=${loaderId}${clientDataStr}&action=${action ? slash(action) : action}&inline=${inline}&routeId=${routeId}&retain=${retain}`;
     }
     return "";
   };
@@ -139,6 +140,7 @@ const fileSystemRoutes = async ({ metaName, routes, ssrMode, nestedRoutesEntry,
         loadersMap[loader] = {
           loaderId,
           routeId: route.id,
+          inValidSSRRoute: route.inValidSSRRoute,
           filePath: route.data || route.loader,
           clientData: Boolean(route.clientData),
           route,
@@ -263,7 +265,8 @@ const fileSystemRoutes = async ({ metaName, routes, ssrMode, nestedRoutesEntry,
           clientData: loaderInfo.clientData,
           action: route.action,
           inline: loaderInfo.inline,
-          routeId: loaderInfo.routeId
+          routeId: loaderInfo.routeId,
+          inValidSSRRoute: loaderInfo.inValidSSRRoute
         })}";
 `;
       } else {
@@ -272,7 +275,8 @@ const fileSystemRoutes = async ({ metaName, routes, ssrMode, nestedRoutesEntry,
           clientData: loaderInfo.clientData,
           action: false,
           inline: loaderInfo.inline,
-          routeId: route.id
+          routeId: route.id,
+          inValidSSRRoute: loaderInfo.inValidSSRRoute
         })}";
 `;
       }
@@ -282,7 +286,8 @@ const fileSystemRoutes = async ({ metaName, routes, ssrMode, nestedRoutesEntry,
         clientData: loaderInfo.clientData,
         action: false,
         inline: loaderInfo.inline,
-        routeId: loaderInfo.routeId
+        routeId: loaderInfo.routeId,
+        inValidSSRRoute: loaderInfo.inValidSSRRoute
       })}";
 `;
     }
@@ -382,7 +387,7 @@ const runtimeGlobalContext = async ({ metaName, srcDirectory, nestedRoutesEntry,
   }
   return `${imports.join("\n")}
 
-import { routes } from './routes.js';
+import { routes } from './routes';
 
 setGlobalContext({
   layoutApp,

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

@@ -1,4 +1,5 @@
-import { createRuntimeExportsUtils, getEntryOptions, isRouterV5 as isV5 } from "@modern-js/utils";
+import path from "node:path";
+import { createRuntimeExportsUtils, filterRoutesForServer, fs, getEntryOptions, isRouterV5 as isV5, NESTED_ROUTE_SPEC_FILE } from "@modern-js/utils";
 import { isRouteEntry } from "./entry";
 import { handleFileChange, handleGeneratorEntryCode, handleModifyEntrypoints } from "./handler";
 import { isRouteEntry as isRouteEntry2 } from "./entry";
@@ -9,6 +10,8 @@ const routerPlugin = () => ({
     "@modern-js/runtime"
   ],
   setup: (api) => {
+    const nestedRoutes = {};
+    const nestedRoutesForServer = {};
     return {
       _internalRuntimePlugins({ entrypoint, plugins }) {
         var _getEntryOptions;
@@ -33,10 +36,10 @@ const routerPlugin = () => ({
           plugins
         };
       },
-      checkEntryPoint({ path, entry }) {
+      checkEntryPoint({ path: path2, entry }) {
         return {
-          path,
-          entry: entry || isRouteEntry(path)
+          path: path2,
+          entry: entry || isRouteEntry(path2)
         };
       },
       config() {
@@ -72,6 +75,22 @@ const routerPlugin = () => ({
       },
       async fileChange(e) {
         await handleFileChange(api, e);
+      },
+      async modifyFileSystemRoutes({ entrypoint, routes }) {
+        nestedRoutes[entrypoint.entryName] = routes;
+        nestedRoutesForServer[entrypoint.entryName] = filterRoutesForServer(routes);
+        return {
+          entrypoint,
+          routes
+        };
+      },
+      async beforeGenerateRoutes({ entrypoint, code }) {
+        const { distDirectory } = api.useAppContext();
+        await fs.outputJSON(path.resolve(distDirectory, NESTED_ROUTE_SPEC_FILE), nestedRoutesForServer);
+        return {
+          entrypoint,
+          code
+        };
       }
     };
   }

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

@@ -2,6 +2,7 @@ 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 { parsedJSONFromElement } from "@modern-js/runtime-utils/parsed";
+import { merge } from "@modern-js/runtime-utils/merge";
 import { getGlobalLayoutApp, getGlobalRoutes } from "../../core/context";
 import { RuntimeReactContext } from "../../core";
 import { modifyRoutes as modifyRoutesHook } from "./hooks";
@@ -19,23 +20,17 @@ function modifyRoutes(modifyFunction) {
     console.error("It is not allowed to modify routes config after create router.");
   }
 }
-const routerPlugin = ({ serverBase = [], supportHtml5History = true, basename = "", routesConfig, createRoutes }) => {
-  const select = (pathname) => serverBase.find((baseUrl) => pathname.search(baseUrl) === 0) || "/";
-  let routes = [];
-  finalRouteConfig = {
-    routes: getGlobalRoutes(),
-    globalApp: getGlobalLayoutApp(),
-    ...routesConfig
-  };
-  window._SERVER_DATA = parsedJSONFromElement("__MODERN_SERVER_DATA__");
+const routerPlugin = (userConfig = {}) => {
   return {
     name: "@modern-js/plugin-router",
     registerHook: {
       modifyRoutes: modifyRoutesHook
     },
     setup: (api) => {
+      let routes = [];
+      window._SERVER_DATA = parsedJSONFromElement("__MODERN_SERVER_DATA__");
       return {
-        init({ context }, next) {
+        beforeRender(context) {
           context.router = {
             useMatches,
             useLocation,
@@ -46,24 +41,26 @@ const routerPlugin = ({ serverBase = [], supportHtml5History = true, basename =
               return routes;
             }
           });
-          return next({
-            context
-          });
         },
-        hoc: ({ App, config }, next) => {
+        wrapRoot: (App) => {
+          const pluginConfig = api.useRuntimeConfigContext();
+          const { serverBase = [], supportHtml5History = true, basename = "", routesConfig, createRoutes } = merge(pluginConfig.router || {}, userConfig);
+          const select = (pathname) => serverBase.find((baseUrl) => pathname.search(baseUrl) === 0) || "/";
+          finalRouteConfig = {
+            routes: getGlobalRoutes(),
+            globalApp: getGlobalLayoutApp(),
+            ...routesConfig
+          };
           if (!finalRouteConfig.routes && !createRoutes) {
-            return next({
-              App,
-              config
-            });
+            return App;
           }
           const getRouteApp = () => {
             const useCreateRouter = (props) => {
-              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(/^\/*/, "/");
+              var _window__SERVER_DATA;
+              const runtimeContext = useContext(RuntimeReactContext);
+              const baseUrl = (runtimeContext._internalRouterBaseName || ((_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);
               const { unstable_getBlockNavState: getBlockNavState } = runtimeContext;
               return useMemo(() => {
                 if (hydrationData === null || hydrationData === void 0 ? void 0 : hydrationData.errors) {
@@ -100,7 +97,8 @@ const routerPlugin = ({ serverBase = [], supportHtml5History = true, basename =
                   get() {
                     return router;
                   },
-                  configurable: true
+                  configurable: true,
+                  enumerable: true
                 });
                 return router;
               }, [
@@ -119,33 +117,24 @@ const routerPlugin = ({ serverBase = [], supportHtml5History = true, basename =
               });
             };
           };
-          const RouteApp = getRouteApp();
-          return next({
-            App: RouteApp,
-            config
-          });
+          return getRouteApp();
         },
-        pickContext: ({ context, pickedContext }, next) => {
-          const { remixRouter } = context;
+        pickContext: (pickedContext) => {
+          const { remixRouter } = pickedContext;
           if (!remixRouter) {
-            return next({
-              context,
-              pickedContext
-            });
+            return pickedContext;
           }
           const router = {
+            ...pickedContext.router,
             navigate: remixRouter.navigate,
             get location() {
               return remixRouter.state.location;
             }
           };
-          return next({
-            context,
-            pickedContext: {
-              ...pickedContext,
-              router
-            }
-          });
+          return {
+            ...pickedContext,
+            router
+          };
         }
       };
     }

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

@@ -6,6 +6,7 @@ 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 { merge } from "@modern-js/runtime-utils/merge";
 import { JSX_SHELL_STREAM_END_MARK } from "../../common";
 import { RuntimeReactContext } from "../../core";
 import { getGlobalLayoutApp, getGlobalRoutes } from "../../core/context";
@@ -22,25 +23,26 @@ function createRemixReuqest(request) {
     signal: controller.signal
   });
 }
-const routerPlugin = ({ basename = "", routesConfig, createRoutes }) => {
+const routerPlugin = (userConfig = {}) => {
   return {
     name: "@modern-js/plugin-router",
     registerHook: {
       modifyRoutes: modifyRoutesHook
     },
     setup: (api) => {
-      const finalRouteConfig = {
-        routes: getGlobalRoutes(),
-        globalApp: getGlobalLayoutApp(),
-        ...routesConfig
-      };
+      let finalRouteConfig = {};
       return {
-        async init({ context }, next) {
+        async beforeRender(context, interrupt) {
           var _context_ssrContext, _context_ssrContext_onTiming, _context_ssrContext1;
+          const pluginConfig = api.useRuntimeConfigContext();
+          const { basename = "", routesConfig, createRoutes } = merge(pluginConfig.router || {}, userConfig);
+          finalRouteConfig = {
+            routes: getGlobalRoutes(),
+            globalApp: getGlobalLayoutApp(),
+            ...routesConfig
+          };
           if (!finalRouteConfig.routes && !createRoutes) {
-            return next({
-              context
-            });
+            return;
           }
           const { request, mode: ssrMode, nonce, loaderFailureMode = "errorBoundary" } = context.ssrContext;
           const { baseUrl } = request;
@@ -69,7 +71,7 @@ const routerPlugin = ({ basename = "", routesConfig, createRoutes }) => {
           const cost = end();
           (_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;
+            return interrupt(routerContext);
           }
           if (routerContext.statusCode >= 500 && routerContext.statusCode < 600 && loaderFailureMode === "clientRender") {
             routerContext.statusCode = 200;
@@ -79,20 +81,15 @@ const routerPlugin = ({ basename = "", routesConfig, createRoutes }) => {
           context.remixRouter = router;
           context.routerContext = routerContext;
           context.routes = routes;
-          return next({
-            context
-          });
         },
-        hoc: ({ App, config }, next) => {
+        wrapRoot: (App) => {
           if (!finalRouteConfig) {
-            return next({
-              App,
-              config
-            });
+            return App;
           }
           const getRouteApp = () => {
             return () => {
-              const { remixRouter, routerContext, ssrContext } = useContext(RuntimeReactContext);
+              const context = useContext(RuntimeReactContext);
+              const { remixRouter, routerContext, ssrContext } = context;
               const { nonce, mode } = ssrContext;
               return /* @__PURE__ */ _jsxs(_Fragment, {
                 children: [
@@ -101,6 +98,8 @@ const routerPlugin = ({ basename = "", routesConfig, createRoutes }) => {
                     context: routerContext,
                     hydrate: false
                   }),
+                  mode === "stream" && // ROUTER_DATA will inject in `packages/runtime/plugin-runtime/src/core/server/string/ssrData.ts` in string ssr
+                  // So we can inject it only when streaming ssr
                   /* @__PURE__ */ _jsx(DeferredDataScripts, {
                     nonce,
                     context: routerContext
@@ -110,19 +109,12 @@ const routerPlugin = ({ basename = "", routesConfig, createRoutes }) => {
               });
             };
           };
-          const RouteApp = getRouteApp();
-          return next({
-            App: RouteApp,
-            config
-          });
+          return getRouteApp();
         },
-        pickContext: ({ context, pickedContext }, next) => {
-          const { remixRouter } = context;
+        pickContext: (pickedContext) => {
+          const { remixRouter } = pickedContext;
           if (!remixRouter) {
-            return next({
-              context,
-              pickedContext
-            });
+            return pickedContext;
           }
           const router = {
             navigate: remixRouter.navigate,
@@ -130,13 +122,10 @@ const routerPlugin = ({ basename = "", routesConfig, createRoutes }) => {
               return remixRouter.state.location;
             }
           };
-          return next({
-            context,
-            pickedContext: {
-              ...pickedContext,
-              router
-            }
-          });
+          return {
+            ...pickedContext,
+            router
+          };
         }
       };
     }

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

@@ -2,6 +2,7 @@ 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 { merge } from "@modern-js/runtime-utils/merge";
 import { immer, effects, autoActions, devtools } from "../plugins";
 import { RuntimeReactContext } from "../../core";
 import { isBrowser } from "../../common";
@@ -29,12 +30,12 @@ const getStoreConfig = (config) => {
   storeConfig.plugins = plugins;
   return storeConfig;
 };
-const statePlugin = (config) => ({
+const statePlugin = (userConfig = {}) => ({
   name: "@modern-js/plugin-state",
-  setup: () => {
-    const storeConfig = getStoreConfig(config);
+  setup: (api) => {
+    let storeConfig;
     return {
-      hoc({ App, config: config2 }, next) {
+      wrapRoot(App) {
         const getStateApp = (props) => {
           const context = useContext(RuntimeReactContext);
           return /* @__PURE__ */ _jsx(Provider, {
@@ -45,29 +46,17 @@ const statePlugin = (config) => ({
             })
           });
         };
-        return next({
-          App: getStateApp,
-          config: config2
-        });
+        return getStateApp;
       },
-      init({ context }, next) {
+      beforeRender(context) {
+        const pluginConfig = api.useRuntimeConfigContext();
+        const config = merge(pluginConfig.state || {}, userConfig);
+        storeConfig = getStoreConfig(config);
         if (isBrowser()) {
           var _window__SSR_DATA_data, _window__SSR_DATA, _window;
           storeConfig.initialState = storeConfig.initialState || ((_window = window) === null || _window === void 0 ? void 0 : (_window__SSR_DATA = _window._SSR_DATA) === null || _window__SSR_DATA === void 0 ? void 0 : (_window__SSR_DATA_data = _window__SSR_DATA.data) === null || _window__SSR_DATA_data === void 0 ? void 0 : _window__SSR_DATA_data.storeState) || {};
         }
         context.store = createStore(storeConfig);
-        return next({
-          context
-        });
-      },
-      pickContext({ context, pickedContext }, next) {
-        return next({
-          context,
-          pickedContext: {
-            ...pickedContext,
-            store: context.store
-          }
-        });
       }
     };
   }

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

@@ -11,7 +11,7 @@ export type CreateAppOptions = {
     runtime?: typeof runtime;
     props?: any;
 };
-export declare const createApp: ({ plugins, runtime, props: globalProps, }: CreateAppOptions) => (App?: React.ComponentType<any>) => React.ComponentType<any>;
+export declare const createApp: ({ plugins, runtime, props: globalProps, }: CreateAppOptions) => (App?: React.ComponentType<any>) => ({ _internal_context, ...props }: any) => JSX.Element;
 type BootStrap<T = unknown> = (App: React.ComponentType, id: string | HTMLElement | RuntimeContext, root?: any, ReactDOM?: {
     render?: Renderer;
     hydrate?: Renderer;

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

@@ -25,7 +25,7 @@ interface GlobalContext {
     layoutApp?: React.ComponentType;
 }
 export declare function setGlobalContext(context: Omit<GlobalContext, 'appConfig'> & {
-    appConfig: () => AppConfig;
+    appConfig?: () => AppConfig;
 }): void;
 export declare function getGlobalApp(): import("react").ComponentType<{}> | undefined;
 export declare function getGlobalRoutes(): undefined | (NestedRoute | PageRoute)[];

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

@@ -27,7 +27,7 @@ export interface RuntimeContext extends BaseRuntimeContext {
 }
 export declare const RuntimeReactContext: import("react").Context<RuntimeContext>;
 export declare const ServerRouterContext: import("react").Context<any>;
-export interface BaseTRuntimeContext {
+export interface BaseTRuntimeContext extends Partial<BaseRuntimeContext> {
     initialData?: Record<string, unknown>;
     request?: SSRServerContext['request'];
     response?: SSRServerContext['response'];

package/dist/types/core/plugin/base.d.ts

@@ -1,50 +1,40 @@
 /// <reference types="react" />
 import { PluginOptions, Setup } from '@modern-js/plugin';
 import { RuntimeContext, TRuntimeContext } from '../context/runtime';
+import type { RuntimeConfig } from './index';
+export declare const RuntimeConfigContext: import("@modern-js/plugin").Context<RuntimeConfig>;
+export declare const useRuntimeConfigContext: () => RuntimeConfig;
 export interface AppProps {
 }
 declare const runtimeHooks: {
-    hoc: import("@modern-js/plugin").Pipeline<{
-        App: React.ComponentType<any>;
-        config: Record<string, any>;
-    }, import("react").ComponentType<any>>;
-    init: import("@modern-js/plugin").AsyncPipeline<{
-        context: RuntimeContext;
-    }, unknown>;
-    pickContext: import("@modern-js/plugin").Pipeline<{
-        context: RuntimeContext;
-        pickedContext: TRuntimeContext;
-    }, TRuntimeContext>;
+    beforeRender: import("@modern-js/plugin").AsyncInterruptWorkflow<RuntimeContext, void>;
+    wrapRoot: import("@modern-js/plugin").Waterfall<import("react").ComponentType<any>>;
+    pickContext: import("@modern-js/plugin").Waterfall<TRuntimeContext>;
+    modifyRuntimeConfig: import("@modern-js/plugin").SyncParallelWorkflow<void, Record<string, any>>;
+};
+declare const runtimePluginAPI: {
+    useRuntimeConfigContext: () => RuntimeConfig;
 };
 /** All hooks of runtime plugin. */
 export type RuntimeHooks = typeof runtimeHooks;
+export type RuntimePluginAPI = typeof runtimePluginAPI;
 /** Plugin options of a runtime plugin. */
-export type Plugin = PluginOptions<RuntimeHooks, Setup<RuntimeHooks>>;
+export type Plugin = PluginOptions<RuntimeHooks, Setup<RuntimeHooks, RuntimePluginAPI>>;
 export declare const createRuntime: () => import("@modern-js/plugin").Manager<{
-    hoc: import("@modern-js/plugin").Pipeline<{
-        App: React.ComponentType<any>;
-        config: Record<string, any>;
-    }, import("react").ComponentType<any>>;
-    init: import("@modern-js/plugin").AsyncPipeline<{
-        context: RuntimeContext;
-    }, unknown>;
-    pickContext: import("@modern-js/plugin").Pipeline<{
-        context: RuntimeContext;
-        pickedContext: TRuntimeContext;
-    }, TRuntimeContext>;
-}, Record<string, never>>;
+    beforeRender: import("@modern-js/plugin").AsyncInterruptWorkflow<RuntimeContext, void>;
+    wrapRoot: import("@modern-js/plugin").Waterfall<import("react").ComponentType<any>>;
+    pickContext: import("@modern-js/plugin").Waterfall<TRuntimeContext>;
+    modifyRuntimeConfig: import("@modern-js/plugin").SyncParallelWorkflow<void, Record<string, any>>;
+}, {
+    useRuntimeConfigContext: () => RuntimeConfig;
+}>;
 export declare const runtime: import("@modern-js/plugin").Manager<{
-    hoc: import("@modern-js/plugin").Pipeline<{
-        App: React.ComponentType<any>;
-        config: Record<string, any>;
-    }, import("react").ComponentType<any>>;
-    init: import("@modern-js/plugin").AsyncPipeline<{
-        context: RuntimeContext;
-    }, unknown>;
-    pickContext: import("@modern-js/plugin").Pipeline<{
-        context: RuntimeContext;
-        pickedContext: TRuntimeContext;
-    }, TRuntimeContext>;
-}, Record<string, never>>;
+    beforeRender: import("@modern-js/plugin").AsyncInterruptWorkflow<RuntimeContext, void>;
+    wrapRoot: import("@modern-js/plugin").Waterfall<import("react").ComponentType<any>>;
+    pickContext: import("@modern-js/plugin").Waterfall<TRuntimeContext>;
+    modifyRuntimeConfig: import("@modern-js/plugin").SyncParallelWorkflow<void, Record<string, any>>;
+}, {
+    useRuntimeConfigContext: () => RuntimeConfig;
+}>;
 export type PluginRunner = ReturnType<typeof runtime.init>;
 export {};