@modern-js/runtime 2.63.7 → 2.64.0

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

@@ -5,7 +5,7 @@ import { normalizePathname } from "@modern-js/runtime-utils/url";
 import { useContext, useMemo } from "react";
 import { RuntimeReactContext } from "../../core";
 import { getGlobalLayoutApp, getGlobalRoutes } from "../../core/context";
-import { modifyRoutes as modifyRoutesHook } from "./hooks";
+import { modifyRoutes as modifyRoutesHook, onBeforeCreateRoutes as onBeforeCreateRoutesHook } from "./hooks";
 import { deserializeErrors, renderRoutes, urlJoin } from "./utils";
 let finalRouteConfig = {
   routes: []
@@ -23,121 +23,120 @@ function modifyRoutes(modifyFunction) {
 const routerPlugin = (userConfig = {}) => {
   return {
     name: "@modern-js/plugin-router",
-    registerHook: {
-      modifyRoutes: modifyRoutesHook
+    registryHooks: {
+      modifyRoutes: modifyRoutesHook,
+      onBeforeCreateRoutes: onBeforeCreateRoutesHook
     },
     setup: (api) => {
       let routes = [];
-      return {
-        beforeRender(context) {
-          if (window._SSR_DATA && userConfig.unstable_reloadOnURLMismatch) {
-            var _ssrContext_request;
-            const { ssrContext } = context;
-            const currentPathname = normalizePathname(window.location.pathname);
-            const initialPathname = (ssrContext === null || ssrContext === void 0 ? void 0 : (_ssrContext_request = ssrContext.request) === null || _ssrContext_request === void 0 ? void 0 : _ssrContext_request.pathname) && normalizePathname(ssrContext.request.pathname);
-            if (initialPathname && initialPathname !== currentPathname) {
-              const errorMsg = `The initial URL ${initialPathname} and the URL ${currentPathname} to be hydrated do not match, reload.`;
-              console.error(errorMsg);
-              window.location.reload();
-            }
+      api.onBeforeRender((context) => {
+        if (window._SSR_DATA && userConfig.unstable_reloadOnURLMismatch) {
+          var _ssrContext_request;
+          const { ssrContext } = context;
+          const currentPathname = normalizePathname(window.location.pathname);
+          const initialPathname = (ssrContext === null || ssrContext === void 0 ? void 0 : (_ssrContext_request = ssrContext.request) === null || _ssrContext_request === void 0 ? void 0 : _ssrContext_request.pathname) && normalizePathname(ssrContext.request.pathname);
+          if (initialPathname && initialPathname !== currentPathname) {
+            const errorMsg = `The initial URL ${initialPathname} and the URL ${currentPathname} to be hydrated do not match, reload.`;
+            console.error(errorMsg);
+            window.location.reload();
           }
-          context.router = {
-            useMatches,
-            useLocation,
-            useHref
-          };
-          Object.defineProperty(context, "routes", {
-            get() {
-              return routes;
-            }
-          });
-        },
-        wrapRoot: (App) => {
-          const pluginConfig = api.useRuntimeConfigContext();
-          const { serverBase = [], supportHtml5History = true, basename = "", routesConfig, createRoutes, future } = 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 App;
+        }
+        context.router = {
+          useMatches,
+          useLocation,
+          useHref
+        };
+        Object.defineProperty(context, "routes", {
+          get() {
+            return routes;
           }
-          const getRouteApp = () => {
-            const useCreateRouter = (props) => {
-              const runtimeContext = useContext(RuntimeReactContext);
-              const baseUrl = select(location.pathname).replace(/^\/*/, "/");
-              const _basename = baseUrl === "/" ? urlJoin(baseUrl, runtimeContext._internalRouterBaseName || basename) : baseUrl;
-              let hydrationData = window._ROUTER_DATA;
-              const { unstable_getBlockNavState: getBlockNavState } = runtimeContext;
-              return useMemo(() => {
-                if (hydrationData === null || hydrationData === void 0 ? void 0 : hydrationData.errors) {
-                  hydrationData = {
-                    ...hydrationData,
-                    errors: deserializeErrors(hydrationData.errors)
-                  };
-                }
-                routes = createRoutes ? createRoutes() : createRoutesFromElements(renderRoutes({
-                  routesConfig: finalRouteConfig,
-                  props
-                }));
-                const runner = api.useHookRunners();
-                routes = runner.modifyRoutes(routes);
-                const router = supportHtml5History ? createBrowserRouter(routes, {
-                  basename: _basename,
-                  hydrationData
-                }) : createHashRouter(routes, {
-                  basename: _basename,
-                  hydrationData
-                });
-                const originSubscribe = router.subscribe;
-                router.subscribe = (listener) => {
-                  const wrapedListener = (...args) => {
-                    const blockRoute = getBlockNavState ? getBlockNavState() : false;
-                    if (blockRoute) {
-                      return;
-                    }
-                    return listener(...args);
-                  };
-                  return originSubscribe(wrapedListener);
+        });
+      });
+      api.wrapRoot((App) => {
+        const pluginConfig = api.getRuntimeConfig();
+        const { serverBase = [], supportHtml5History = true, basename = "", routesConfig, createRoutes, future } = 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 App;
+        }
+        const getRouteApp = () => {
+          const useCreateRouter = (props) => {
+            const runtimeContext = useContext(RuntimeReactContext);
+            const baseUrl = select(location.pathname).replace(/^\/*/, "/");
+            const _basename = baseUrl === "/" ? urlJoin(baseUrl, runtimeContext._internalRouterBaseName || basename) : baseUrl;
+            let hydrationData = window._ROUTER_DATA;
+            const { unstable_getBlockNavState: getBlockNavState } = runtimeContext;
+            return useMemo(() => {
+              if (hydrationData === null || hydrationData === void 0 ? void 0 : hydrationData.errors) {
+                hydrationData = {
+                  ...hydrationData,
+                  errors: deserializeErrors(hydrationData.errors)
                 };
-                return router;
-              }, [
-                finalRouteConfig,
-                props,
-                _basename,
-                hydrationData,
-                getBlockNavState
-              ]);
-            };
-            const Null = () => null;
-            return (props) => {
-              beforeCreateRouter = false;
-              const router = useCreateRouter(props);
-              const routerWrapper = (
-                // To match the node tree about https://github.com/web-infra-dev/modern.js/blob/v2.59.0/packages/runtime/plugin-runtime/src/router/runtime/plugin.node.tsx#L150-L168
-                // According to react [useId generation algorithm](https://github.com/facebook/react/pull/22644), `useId` will generate id with the react node react struct.
-                // To void hydration failed, we must guarantee that the node tree when browser hydrate must have same struct with node tree when ssr render.
-                /* @__PURE__ */ _jsxs(_Fragment, {
-                  children: [
-                    /* @__PURE__ */ _jsx(RouterProvider, {
-                      router,
-                      future
-                    }),
-                    /* @__PURE__ */ _jsx(Null, {}),
-                    /* @__PURE__ */ _jsx(Null, {})
-                  ]
-                })
-              );
-              return App ? /* @__PURE__ */ _jsx(App, {
-                children: routerWrapper
-              }) : routerWrapper;
-            };
+              }
+              routes = createRoutes ? createRoutes() : createRoutesFromElements(renderRoutes({
+                routesConfig: finalRouteConfig,
+                props
+              }));
+              const hooks = api.getHooks();
+              routes = hooks.modifyRoutes.call(routes);
+              const router = supportHtml5History ? createBrowserRouter(routes, {
+                basename: _basename,
+                hydrationData
+              }) : createHashRouter(routes, {
+                basename: _basename,
+                hydrationData
+              });
+              const originSubscribe = router.subscribe;
+              router.subscribe = (listener) => {
+                const wrapedListener = (...args) => {
+                  const blockRoute = getBlockNavState ? getBlockNavState() : false;
+                  if (blockRoute) {
+                    return;
+                  }
+                  return listener(...args);
+                };
+                return originSubscribe(wrapedListener);
+              };
+              return router;
+            }, [
+              finalRouteConfig,
+              props,
+              _basename,
+              hydrationData,
+              getBlockNavState
+            ]);
           };
-          return getRouteApp();
-        }
-      };
+          const Null = () => null;
+          return (props) => {
+            beforeCreateRouter = false;
+            const router = useCreateRouter(props);
+            const routerWrapper = (
+              // To match the node tree about https://github.com/web-infra-dev/modern.js/blob/v2.59.0/packages/runtime/plugin-runtime/src/router/runtime/plugin.node.tsx#L150-L168
+              // According to react [useId generation algorithm](https://github.com/facebook/react/pull/22644), `useId` will generate id with the react node react struct.
+              // To void hydration failed, we must guarantee that the node tree when browser hydrate must have same struct with node tree when ssr render.
+              /* @__PURE__ */ _jsxs(_Fragment, {
+                children: [
+                  /* @__PURE__ */ _jsx(RouterProvider, {
+                    router,
+                    future
+                  }),
+                  /* @__PURE__ */ _jsx(Null, {}),
+                  /* @__PURE__ */ _jsx(Null, {})
+                ]
+              })
+            );
+            return App ? /* @__PURE__ */ _jsx(App, {
+              children: routerWrapper
+            }) : routerWrapper;
+          };
+        };
+        return getRouteApp();
+      });
     }
   };
 };

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

@@ -11,7 +11,7 @@ import { JSX_SHELL_STREAM_END_MARK } from "../../common";
 import { RuntimeReactContext } from "../../core";
 import { getGlobalLayoutApp, getGlobalRoutes } from "../../core/context";
 import DeferredDataScripts from "./DeferredDataScripts.node";
-import { beforeCreateRoutes as beforeCreateRoutesHook, modifyRoutes as modifyRoutesHook } from "./hooks";
+import { modifyRoutes as modifyRoutesHook, onBeforeCreateRoutes as onBeforeCreateRoutesHook } from "./hooks";
 import { renderRoutes, urlJoin } from "./utils";
 function createRemixReuqest(request) {
   const method = "GET";
@@ -26,102 +26,100 @@ function createRemixReuqest(request) {
 const routerPlugin = (userConfig = {}) => {
   return {
     name: "@modern-js/plugin-router",
-    registerHook: {
+    registryHooks: {
       modifyRoutes: modifyRoutesHook,
-      beforeCreateRoutes: beforeCreateRoutesHook
+      onBeforeCreateRoutes: onBeforeCreateRoutesHook
     },
     setup: (api) => {
       let finalRouteConfig = {};
-      return {
-        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;
-          }
-          const { request, mode: ssrMode, nonce, loaderFailureMode = "errorBoundary" } = context.ssrContext;
-          const { baseUrl } = request;
-          const _basename = baseUrl === "/" ? urlJoin(baseUrl, basename) : baseUrl;
-          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);
-          const runner = api.useHookRunners();
-          await runner.beforeCreateRoutes(context);
-          let routes = createRoutes ? createRoutes() : createRoutesFromElements(renderRoutes({
-            routesConfig: finalRouteConfig,
-            ssrMode,
-            props: {
-              nonce
-            },
-            reporter
-          }));
-          routes = runner.modifyRoutes(routes);
-          const { query } = createStaticHandler(routes, {
-            basename: _basename
-          });
-          const remixRequest = createRemixReuqest(context.ssrContext.request.raw);
-          const end = time();
-          const routerContext = await query(remixRequest, {
-            requestContext
-          });
-          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 interrupt(routerContext);
-          }
-          const errors = Object.values(routerContext.errors || {});
-          if (
-            // TODO: if loaderFailureMode is not 'errroBoundary', error log will not be printed.
-            errors.length > 0 && loaderFailureMode === "clientRender"
-          ) {
-            routerContext.statusCode = 200;
-            throw errors[0];
-          }
-          const router = createStaticRouter(routes, routerContext);
-          context.routerContext = routerContext;
-          context.remixRouter = router;
-          context.routes = routes;
-        },
-        wrapRoot: (App) => {
-          if (!finalRouteConfig) {
-            return App;
-          }
-          const getRouteApp = () => {
-            return () => {
-              const context = useContext(RuntimeReactContext);
-              const { remixRouter, routerContext, ssrContext } = context;
-              const { nonce, mode, useJsonScript } = ssrContext;
-              const routerWrapper = /* @__PURE__ */ _jsxs(_Fragment, {
-                children: [
-                  /* @__PURE__ */ _jsx(StaticRouterProvider, {
-                    router: remixRouter,
-                    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,
-                    useJsonScript
-                  }),
-                  mode === "stream" && JSX_SHELL_STREAM_END_MARK
-                ]
-              });
-              return App ? /* @__PURE__ */ _jsx(App, {
-                children: routerWrapper
-              }) : routerWrapper;
-            };
-          };
-          return getRouteApp();
+      api.onBeforeRender(async (context, interrupt) => {
+        var _context_ssrContext, _context_ssrContext_onTiming, _context_ssrContext1;
+        const pluginConfig = api.getRuntimeConfig();
+        const { basename = "", routesConfig, createRoutes } = merge(pluginConfig.router || {}, userConfig);
+        finalRouteConfig = {
+          routes: getGlobalRoutes(),
+          globalApp: getGlobalLayoutApp(),
+          ...routesConfig
+        };
+        if (!finalRouteConfig.routes && !createRoutes) {
+          return;
+        }
+        const { request, mode: ssrMode, nonce, loaderFailureMode = "errorBoundary" } = context.ssrContext;
+        const { baseUrl } = request;
+        const _basename = baseUrl === "/" ? urlJoin(baseUrl, basename) : baseUrl;
+        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);
+        const hooks = api.getHooks();
+        await hooks.onBeforeCreateRoutes.call(context);
+        let routes = createRoutes ? createRoutes() : createRoutesFromElements(renderRoutes({
+          routesConfig: finalRouteConfig,
+          ssrMode,
+          props: {
+            nonce
+          },
+          reporter
+        }));
+        routes = hooks.modifyRoutes.call(routes);
+        const { query } = createStaticHandler(routes, {
+          basename: _basename
+        });
+        const remixRequest = createRemixReuqest(context.ssrContext.request.raw);
+        const end = time();
+        const routerContext = await query(remixRequest, {
+          requestContext
+        });
+        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 interrupt(routerContext);
         }
-      };
+        const errors = Object.values(routerContext.errors || {});
+        if (
+          // TODO: if loaderFailureMode is not 'errroBoundary', error log will not be printed.
+          errors.length > 0 && loaderFailureMode === "clientRender"
+        ) {
+          routerContext.statusCode = 200;
+          throw errors[0];
+        }
+        const router = createStaticRouter(routes, routerContext);
+        context.routerContext = routerContext;
+        context.remixRouter = router;
+        context.routes = routes;
+      });
+      api.wrapRoot((App) => {
+        if (!finalRouteConfig) {
+          return App;
+        }
+        const getRouteApp = () => {
+          return () => {
+            const context = useContext(RuntimeReactContext);
+            const { remixRouter, routerContext, ssrContext } = context;
+            const { nonce, mode, useJsonScript } = ssrContext;
+            const routerWrapper = /* @__PURE__ */ _jsxs(_Fragment, {
+              children: [
+                /* @__PURE__ */ _jsx(StaticRouterProvider, {
+                  router: remixRouter,
+                  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,
+                  useJsonScript
+                }),
+                mode === "stream" && JSX_SHELL_STREAM_END_MARK
+              ]
+            });
+            return App ? /* @__PURE__ */ _jsx(App, {
+              children: routerWrapper
+            }) : routerWrapper;
+          };
+        };
+        return getRouteApp();
+      });
     }
   };
 };

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

@@ -1,5 +1,5 @@
 import type React from 'react';
 import type { Root } from 'react-dom/client';
-import type { RuntimeContext } from '../context';
+import type { RuntimeContext } from '../context/runtime';
 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/compat/hooks.d.ts

@@ -0,0 +1,4 @@
+import type { RuntimeContext } from '../context';
+export declare function transformHookRunner(hookRunnerName: string): string;
+export declare function handleSetupResult(setupResult: Record<string, (...args: any) => any>, api: Record<string, any>): void;
+export declare function getHookRunners(runtimeContext: RuntimeContext): Record<string, any>;

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

@@ -0,0 +1,2 @@
+import type { RuntimePluginFuture } from '../plugin/types';
+export declare const compatPlugin: () => RuntimePluginFuture;

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

@@ -1,17 +1,18 @@
+import type { RuntimePlugin } from '@modern-js/plugin-v2';
 import React from 'react';
 import type { Renderer } from 'react-dom';
 import type { createRoot, hydrateRoot } from 'react-dom/client';
-import { type RuntimeContext, type TRuntimeContext } from './context/runtime';
-import { type Plugin, type runtime } from './plugin';
+import { type RuntimeContext } from './context/runtime';
+import { type Plugin } from './plugin';
+import type { RuntimeExtends } from './plugin/types';
 export type CreateAppOptions = {
-    plugins: Plugin[];
+    plugins: (Plugin | RuntimePlugin<RuntimeExtends>)[];
     /**
      * In the test cases, we need to execute multiple createApp instances simultaneously, and they must not share the runtime.
      */
-    runtime?: typeof runtime;
     props?: any;
 };
-export declare const createApp: ({ plugins, runtime, props: globalProps, }: CreateAppOptions) => (App?: React.ComponentType<any>) => (props: any) => React.JSX.Element;
+export declare const createApp: ({ plugins, props: globalProps, }: CreateAppOptions) => (App?: React.ComponentType<any>) => (props: any) => React.JSX.Element;
 type BootStrap<T = unknown> = (App: React.ComponentType, id: string | HTMLElement | RuntimeContext, root?: any, ReactDOM?: {
     render?: Renderer;
     hydrate?: Renderer;
@@ -19,5 +20,5 @@ type BootStrap<T = unknown> = (App: React.ComponentType, id: string | HTMLElemen
     hydrateRoot?: typeof hydrateRoot;
 }) => Promise<T>;
 export declare const bootstrap: BootStrap;
-export declare const useRuntimeContext: () => TRuntimeContext;
+export declare const useRuntimeContext: () => RuntimeContext;
 export {};

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

@@ -1,7 +1,9 @@
 /// <reference types="react" />
+import type { InternalRuntimeContext } from '@modern-js/plugin-v2';
 import type { NestedRoute, PageRoute } from '@modern-js/types';
 import type { AppConfig } from '../../common';
-export { RuntimeReactContext, type RuntimeContext, getInitialContext, } from './runtime';
+import type { RuntimeExtends } from '../plugin/types';
+export { type RuntimeContext, RuntimeReactContext, getInitialContext, } from './runtime';
 interface GlobalContext {
     /**
      * App.tsx export default component
@@ -23,10 +25,13 @@ interface GlobalContext {
      * page router _app.tsx export layout app
      */
     layoutApp?: React.ComponentType;
+    internalRuntimeContext?: InternalRuntimeContext<RuntimeExtends>;
 }
-export declare function setGlobalContext(context: Omit<GlobalContext, 'appConfig'> & {
+export declare function setGlobalContext(context: Omit<GlobalContext, 'appConfig' | 'internalRuntimeContext'> & {
     appConfig?: () => AppConfig;
 }): void;
+export declare function setGlobalInternalRuntimeContext(context: InternalRuntimeContext<RuntimeExtends>): void;
+export declare function getGlobalInternalRuntimeContext(): InternalRuntimeContext<Required<import("@modern-js/plugin-v2").RuntimePluginExtends<import("../plugin/types").RuntimeConfig, import("./runtime").RuntimeContext, {}, {}>>>;
 export declare function getGlobalApp(): import("react").ComponentType<{}> | undefined;
 export declare function getGlobalRoutes(): undefined | (NestedRoute | PageRoute)[];
 export declare function getGlobalAppInit(): any;

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

@@ -3,13 +3,11 @@ import type { Store } from '@modern-js-reduck/store';
 import type { StaticHandlerContext } from '@modern-js/runtime-utils/remix-router';
 import type { RouteManifest } from '../../router/runtime/types';
 import { createLoaderManager } from '../loader/loaderManager';
-import type { PluginRunner, runtime } from '../plugin';
 import type { SSRServerContext, TSSRContext } from '../types';
 interface BaseRuntimeContext {
     initialData?: Record<string, unknown>;
     loaderManager: ReturnType<typeof createLoaderManager>;
     isBrowser: boolean;
-    runner: ReturnType<typeof runtime.init>;
     ssrContext?: SSRServerContext;
     store?: Store;
     routeManifest: RouteManifest;
@@ -35,5 +33,5 @@ export interface TRuntimeContext extends Partial<BaseRuntimeContext> {
     store?: Store;
     [key: string]: any;
 }
-export declare const getInitialContext: (runner: PluginRunner, isBrowser?: boolean, routeManifest?: RouteManifest) => RuntimeContext;
+export declare const getInitialContext: (isBrowser?: boolean, routeManifest?: RouteManifest) => RuntimeContext;
 export {};

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

@@ -1,5 +1,4 @@
-export { runtime } from './plugin';
-export type { Plugin } from './plugin';
+export type { Plugin, RuntimePluginFuture } from './plugin';
 export { defineConfig, getConfig, defineRuntimeConfig } from './config';
 export * from './compatible';
 export type { RuntimeContext } from './context/runtime';

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

@@ -1,40 +1,16 @@
 /// <reference types="react" />
-import { type PluginOptions, type Setup } from '@modern-js/plugin';
+import type { AsyncInterruptWorkflow, PluginOptions, Setup, SyncParallelWorkflow, Waterfall } from '@modern-js/plugin';
 import type { 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: {
-    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>>;
+import type { RuntimeConfig } from './types';
+/** All hooks of runtime plugin. */
+export type RuntimeHooks = {
+    beforeRender: AsyncInterruptWorkflow<RuntimeContext, void>;
+    wrapRoot: Waterfall<React.ComponentType<any>>;
+    pickContext: Waterfall<TRuntimeContext>;
+    modifyRuntimeConfig: SyncParallelWorkflow<void, Record<string, any>>;
 };
-declare const runtimePluginAPI: {
+export type 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, RuntimePluginAPI>>;
-export declare const createRuntime: () => import("@modern-js/plugin").Manager<{
-    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<{
-    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 {};

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

@@ -1,13 +1,20 @@
-/// <reference types="react" />
-import { type Plugin, runtime } from './base';
-export * from './base';
-export interface RuntimeConfig {
-    plugins?: Plugin[];
-}
-export declare function registerPlugin(internalPlugins: Plugin[], runtimeConfig?: RuntimeConfig, customRuntime?: typeof runtime): import("@modern-js/plugin").ToRunners<{
-    beforeRender: import("@modern-js/plugin").AsyncInterruptWorkflow<import("..").RuntimeContext, void>;
-    wrapRoot: import("@modern-js/plugin").Waterfall<import("react").ComponentType<any>>;
-    pickContext: import("@modern-js/plugin").Waterfall<import("../context/runtime").TRuntimeContext>;
-    modifyRuntimeConfig: import("@modern-js/plugin").SyncParallelWorkflow<void, Record<string, any>>;
-}>;
+import type { Plugin as RuntimePlugin } from './base';
+import type { RuntimeConfig, RuntimePluginFuture } from './types';
+export type { Plugin } from './base';
+export type { RuntimePluginFuture };
+export declare function registerPlugin(internalPlugins: (RuntimePlugin | RuntimePluginFuture)[], runtimeConfig?: RuntimeConfig): {
+    hooks: import("@modern-js/plugin-v2/runtime").Hooks<{} | undefined, import("@modern-js/plugin-v2/runtime").RuntimeContext>;
+    extendsHooks: {} | undefined;
+    config: {} | undefined;
+    pluginAPI?: Readonly<{
+        updateRuntimeContext: (updateContext: import("@modern-js/plugin-v2/dist/types/types/utils").DeepPartial<import("@modern-js/plugin-v2/runtime").RuntimeContext>) => void;
+        getHooks: () => Readonly<import("@modern-js/plugin-v2/runtime").Hooks<{} | undefined, import("@modern-js/plugin-v2/runtime").RuntimeContext>>;
+        getRuntimeConfig: () => Readonly<{} | undefined>;
+        onBeforeRender: import("@modern-js/plugin-v2/dist/types").PluginHookTap<import("@modern-js/plugin-v2/dist/types/types/runtime/hooks").OnBeforeRenderFn<{} | undefined>>;
+        wrapRoot: import("@modern-js/plugin-v2/dist/types").PluginHookTap<import("@modern-js/plugin-v2/dist/types/types/runtime/hooks").WrapRootFn>;
+        pickContext: import("@modern-js/plugin-v2/dist/types").PluginHookTap<import("@modern-js/plugin-v2/dist/types/types/runtime/hooks").PickContextFn<import("@modern-js/plugin-v2/runtime").RuntimeContext>>;
+        modifyRuntimeConfig: import("@modern-js/plugin-v2/dist/types").PluginHookTap<import("@modern-js/plugin-v2/dist/types/types/runtime/hooks").ModifyRuntimeConfigFn<{} | undefined>>;
+    } & {}> | undefined;
+    _internalContext?: any | undefined;
+};
 export declare function mergeConfig(config: Record<string, any>, ...otherConfig: Record<string, any>[]): Record<string, any>;