@modern-js/runtime 2.54.6 → 2.56.0

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

@@ -1,66 +1,55 @@
-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);
+function createRemixReuqest(request) {
+  const method = "GET";
+  const { headers } = request;
   const controller = new AbortController();
-  const init = {
-    method: req.method,
-    headers: createFetchHeaders(req.headers),
+  return new Request(request.url, {
+    method,
+    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 || {})) {
-    if (values) {
-      if (Array.isArray(values)) {
-        for (const value of values) {
-          headers.append(key, value);
-        }
-      } else {
-        headers.set(key, values);
-      }
-    }
-  }
-  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 +61,13 @@ const routerPlugin = ({ basename = "", originalBaseUrl = "", routesConfig, creat
           const { query } = createStaticHandler(routes, {
             basename: _basename
           });
-          const remixRequest = createFetchRequest(request);
+          const remixRequest = createRemixReuqest(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 +79,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 +111,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
@@ -165,7 +145,6 @@ const routerPlugin = ({ basename = "", originalBaseUrl = "", routesConfig, creat
 const modifyRoutes = () => {
 };
 export {
-  createFetchHeaders,
   modifyRoutes,
   routerPlugin
 };

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,3 @@
+import React from 'react';
+export type RenderFunc = typeof render;
+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;

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

@@ -10,17 +10,7 @@ declare const runtimeHooks: {
     }, import("react").ComponentType<any>>;
     init: import("@modern-js/plugin").AsyncPipeline<{
         context: RuntimeContext;
-    }, RuntimeContext>;
-    client: import("@modern-js/plugin").AsyncPipeline<{
-        App: React.ComponentType<any>;
-        readonly context: RuntimeContext;
-        ModernRender: (App: React.ReactElement) => void;
-        ModernHydrate: (App: React.ReactElement, callback?: () => void) => void;
-    }, void>;
-    server: import("@modern-js/plugin").AsyncPipeline<{
-        App: React.ComponentType<any>;
-        readonly context: RuntimeContext;
-    }, string>;
+    }, unknown>;
     pickContext: import("@modern-js/plugin").Pipeline<{
         context: RuntimeContext;
         pickedContext: TRuntimeContext;
@@ -37,17 +27,7 @@ export declare const createRuntime: () => import("@modern-js/plugin").Manager<{
     }, import("react").ComponentType<any>>;
     init: import("@modern-js/plugin").AsyncPipeline<{
         context: RuntimeContext;
-    }, RuntimeContext>;
-    client: import("@modern-js/plugin").AsyncPipeline<{
-        App: React.ComponentType<any>;
-        readonly context: RuntimeContext;
-        ModernRender: (App: React.ReactElement) => void;
-        ModernHydrate: (App: React.ReactElement, callback?: () => void) => void;
-    }, void>;
-    server: import("@modern-js/plugin").AsyncPipeline<{
-        App: React.ComponentType<any>;
-        readonly context: RuntimeContext;
-    }, string>;
+    }, unknown>;
     pickContext: import("@modern-js/plugin").Pipeline<{
         context: RuntimeContext;
         pickedContext: TRuntimeContext;
@@ -60,17 +40,7 @@ export declare const runtime: import("@modern-js/plugin").Manager<{
     }, import("react").ComponentType<any>>;
     init: import("@modern-js/plugin").AsyncPipeline<{
         context: RuntimeContext;
-    }, RuntimeContext>;
-    client: import("@modern-js/plugin").AsyncPipeline<{
-        App: React.ComponentType<any>;
-        readonly context: RuntimeContext;
-        ModernRender: (App: React.ReactElement) => void;
-        ModernHydrate: (App: React.ReactElement, callback?: () => void) => void;
-    }, void>;
-    server: import("@modern-js/plugin").AsyncPipeline<{
-        App: React.ComponentType<any>;
-        readonly context: RuntimeContext;
-    }, string>;
+    }, unknown>;
     pickContext: import("@modern-js/plugin").Pipeline<{
         context: RuntimeContext;
         pickedContext: TRuntimeContext;

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

@@ -11,19 +11,10 @@ export declare function registerPlugin(internalPlugins: Plugin[], runtimeConfig?
     }, import("react").ComponentType<any>>;
     init: import("@modern-js/plugin").AsyncPipeline<{
         context: import("..").RuntimeContext;
-    }, import("..").RuntimeContext>;
-    client: import("@modern-js/plugin").AsyncPipeline<{
-        App: import("react").ComponentType<any>;
-        readonly context: import("..").RuntimeContext;
-        ModernRender: (App: import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>>) => void;
-        ModernHydrate: (App: import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>>, callback?: (() => void) | undefined) => void;
-    }, void>;
-    server: import("@modern-js/plugin").AsyncPipeline<{
-        App: import("react").ComponentType<any>;
-        readonly context: import("..").RuntimeContext;
-    }, string>;
+    }, unknown>;
     pickContext: import("@modern-js/plugin").Pipeline<{
         context: import("..").RuntimeContext;
         pickedContext: import("../context/runtime").TRuntimeContext;
     }, import("../context/runtime").TRuntimeContext>;
 }>;
+export declare function mergeConfig(config: Record<string, any>, ...otherConfig: Record<string, any>[]): Record<string, any>;

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

@@ -8,17 +8,7 @@ export declare function getGlobalRunner(): import("@modern-js/plugin").ToRunners
     }, import("react").ComponentType<any>>;
     init: import("@modern-js/plugin").AsyncPipeline<{
         context: import("..").RuntimeContext;
-    }, import("..").RuntimeContext>;
-    client: import("@modern-js/plugin").AsyncPipeline<{
-        App: import("react").ComponentType<any>;
-        readonly context: import("..").RuntimeContext;
-        ModernRender: (App: import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>>) => void;
-        ModernHydrate: (App: import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>>, callback?: (() => void) | undefined) => void;
-    }, void>;
-    server: import("@modern-js/plugin").AsyncPipeline<{
-        App: import("react").ComponentType<any>;
-        readonly context: import("..").RuntimeContext;
-    }, string>;
+    }, unknown>;
     pickContext: import("@modern-js/plugin").Pipeline<{
         context: import("..").RuntimeContext;
         pickedContext: import("../context/runtime").TRuntimeContext;

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

@@ -0,0 +1,6 @@
+import React from 'react';
+export declare function createRoot(UserApp?: React.ComponentType | null, config?: {
+    router: {
+        basename: string;
+    };
+}): React.ComponentType<any>;

package/dist/types/core/server/helmet.d.ts

@@ -0,0 +1,3 @@
+import { HelmetData } from 'react-helmet';
+export declare function createReplaceHelemt(helmetData?: HelmetData): (template: string) => string;
+export declare function helmetReplace(content: string, helmetData: HelmetData): string;

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

@@ -0,0 +1,4 @@
+import { Plugin } from '../plugin';
+export { PreRender, NoSSR } from './react';
+export declare const ssr: (_config: any) => Plugin;
+export default ssr;

package/dist/types/core/server/requestHandler.d.ts

@@ -0,0 +1,11 @@
+import { RequestHandler, RequestHandlerOptions } from '@modern-js/app-tools';
+import React from 'react';
+import { RuntimeContext } from '../context';
+export type { RequestHandlerConfig as HandleRequestConfig } from '@modern-js/app-tools';
+export type HandleRequestOptions = Exclude<RequestHandlerOptions, 'staticGenerate'> & {
+    runtimeContext: RuntimeContext;
+};
+export type HandleRequest = (request: Request, ServerRoot: React.ComponentType, // App, routes,
+options: HandleRequestOptions) => Promise<Response>;
+export type CreateRequestHandler = (handleRequest: HandleRequest) => Promise<RequestHandler>;
+export declare const createRequestHandler: CreateRequestHandler;

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

@@ -0,0 +1,4 @@
+export { renderString } from './string';
+export { renderStreaming } from './stream';
+export { createRequestHandler, type HandleRequest, type HandleRequestOptions, type HandleRequestConfig, type CreateRequestHandler, } from './requestHandler';
+export type { RenderStreaming, RenderString, RenderOptions } from './shared';

package/dist/types/core/server/shared.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="react" />
+import type { ServerUserConfig } from '@modern-js/app-tools';
+import type { HandleRequestOptions } from './requestHandler';
+export type RenderOptions = HandleRequestOptions;
+export type SSRConfig = NonNullable<ServerUserConfig['ssr']>;
+export type RenderStreaming = (request: Request, serverRoot: React.ReactElement, optinos: RenderOptions) => Promise<ReadableStream>;
+export type RenderString = (request: Request, serverRoot: React.ReactElement, optinos: RenderOptions) => Promise<string>;
+export type BuildHtmlCb = (template: string) => string | Promise<string>;
+export declare function buildHtml(template: string, callbacks: BuildHtmlCb[]): Promise<string>;

package/dist/types/core/server/stream/afterTemplate.d.ts

@@ -0,0 +1,12 @@
+import { SSRConfig } from '../shared';
+import { RenderLevel } from '../../constants';
+import { HandleRequestConfig } from '../requestHandler';
+import { RuntimeContext } from '../../context';
+export type BuildShellAfterTemplateOptions = {
+    runtimeContext: RuntimeContext;
+    renderLevel: RenderLevel;
+    ssrConfig: SSRConfig;
+    request: Request;
+    config: HandleRequestConfig;
+};
+export declare function buildShellAfterTemplate(afterAppTemplate: string, options: BuildShellAfterTemplateOptions): Promise<string>;

package/dist/types/core/server/stream/beforeTemplate.d.ts

@@ -0,0 +1,8 @@
+import { RuntimeContext } from '../../context';
+import { HandleRequestConfig } from '../requestHandler';
+export interface BuildShellBeforeTemplateOptions {
+    runtimeContext: RuntimeContext;
+    config: HandleRequestConfig;
+    styledComponentsStyleTags?: string;
+}
+export declare function buildShellBeforeTemplate(beforeAppTemplate: string, options: BuildShellBeforeTemplateOptions): Promise<string>;

package/dist/types/core/server/stream/createReadableStream.d.ts

@@ -0,0 +1,2 @@
+import { CreateReadableStreamFromElement } from './shared';
+export declare const createReadableStreamFromElement: CreateReadableStreamFromElement;

package/dist/types/core/server/stream/createReadableStream.worker.d.ts

@@ -0,0 +1,2 @@
+import { CreateReadableStreamFromElement } from './shared';
+export declare const createReadableStreamFromElement: CreateReadableStreamFromElement;

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

@@ -0,0 +1 @@
+export declare const renderStreaming: import("../shared").RenderStreaming;