@modern-js/server-core 2.48.6 → 2.49.1-alpha.0

package/dist/types/base/adapters/node/polyfills/stream.d.ts

@@ -0,0 +1,18 @@
+/// <reference types="node" />
+/// <reference types="node" />
+/**
+ * The following code is modified based on
+ * https://github.com/remix-run/remix/blob/f7defe0b46c50947f6269d5ab5b6e3fe59339054/packages/remix-node/stream.ts#L3
+ *
+ * MIT Licensed
+ * Author Michael Jackson
+ * Copyright 2021 Remix Software Inc.
+ * https://github.com/remix-run/remix/blob/f7defe0b46c50947f6269d5ab5b6e3fe59339054/LICENSE.md
+ */
+import type { Readable, Writable } from 'node:stream';
+export declare function writeReadableStreamToWritable(stream: ReadableStream, writable: Writable): Promise<void>;
+export declare function writeAsyncIterableToWritable(iterable: AsyncIterable<Uint8Array>, writable: Writable): Promise<void>;
+export declare function readableStreamToString(stream: ReadableStream<Uint8Array>, encoding?: BufferEncoding): Promise<string>;
+export declare const createReadableStreamFromReadable: (source: Readable & {
+    readableHighWaterMark?: number;
+}) => ReadableStream<Uint8Array>;

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

@@ -0,0 +1,24 @@
+export declare const AGGRED_DIR: {
+    mock: string;
+    server: string;
+    api: string;
+    shared: string;
+    lambda: string;
+};
+export declare const REPLACE_REG: {
+    before: {
+        head: string;
+        body: string;
+    };
+    after: {
+        head: string;
+        body: string;
+    };
+};
+export declare enum ServerReportTimings {
+    SERVER_HANDLE_REQUEST = "server-handle-request",
+    SERVER_MIDDLEWARE = "server-middleware",
+    SERVER_HOOK_AFTER_RENDER = "server-hook-after-render",
+    SERVER_HOOK_AFTER_MATCH = "server-hook-after-match"
+}
+export declare const X_RENDER_CACHE = "x-render-cache";

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

@@ -0,0 +1,7 @@
+export { createErrorHtml } from './utils';
+export { AGGRED_DIR } from './constants';
+export { favionFallbackMiddleware, injectReporter, injectLogger, getRenderHandler, bindRenderHandler, logHandler, processedBy, } from './middlewares';
+export type { BindRenderHandleOptions } from './middlewares';
+export type { ServerBase, ServerBaseOptions } from './serverBase';
+export { createServerBase } from './serverBase';
+export type { Middleware, Context, Next, HonoRequest, ServerEnv, ServerManifest, } from '../core/server';

package/dist/types/base/middlewares/customServer/base.d.ts

@@ -0,0 +1,3 @@
+import { HookContext } from '@modern-js/types';
+import type { Context, ServerEnv } from '../../../core/server';
+export declare function createBaseHookContext(c: Context<ServerEnv>): HookContext;

package/dist/types/base/middlewares/customServer/context.d.ts

@@ -0,0 +1,7 @@
+import { AfterMatchContext, AfterRenderContext, MiddlewareContext, AfterStreamingRenderContext, ServerRoute, HookContext } from '@modern-js/types';
+import { Context, ServerEnv } from '../../../core/server';
+import type { ServerNodeEnv } from '../../adapters/node/hono';
+export declare function getAfterMatchCtx(entryName: string, baseHookCtx: HookContext): AfterMatchContext;
+export declare function getAfterRenderCtx(c: Context, baseHookCtx: HookContext, route: Partial<ServerRoute>): Promise<AfterRenderContext>;
+export declare function createCustomMiddlewaresCtx(c: Context<ServerNodeEnv & ServerEnv>, locals: Record<string, any>): MiddlewareContext;
+export declare function createAfterStreamingRenderContext(baseHookCtx: HookContext, route: Partial<ServerRoute>): (chunk: string) => AfterStreamingRenderContext;

package/dist/types/base/middlewares/customServer/index.d.ts

@@ -0,0 +1,13 @@
+import { ServerRoute } from '@modern-js/types';
+import { ServerBase } from '../../serverBase';
+import { ServerHookRunner } from '../../../core/plugin';
+import { Middleware, ServerEnv } from '../../../core/server';
+import type { ServerNodeEnv } from '../../adapters/node/hono';
+export declare class CustomServer {
+    private runner;
+    private serverMiddlewarePromise;
+    private serverBase;
+    constructor(runner: ServerHookRunner, serverBase: ServerBase, pwd: string);
+    getHookMiddleware(entryName: string, routes: ServerRoute[]): Middleware<ServerEnv>;
+    getServerMiddleware(): Middleware<ServerNodeEnv & ServerEnv>;
+}

package/dist/types/base/middlewares/customServer/routerApi.d.ts

@@ -0,0 +1,9 @@
+export declare class RouterAPI {
+    current: string;
+    status: number;
+    url: string;
+    constructor(entryName: string);
+    redirect(url: string, status?: number): void;
+    rewrite(entryName: string): void;
+    use(entryName: string): void;
+}

package/dist/types/base/middlewares/customServer/template.d.ts

@@ -0,0 +1,11 @@
+export declare class TemplateApi {
+    private body;
+    constructor(body: string);
+    set(content: string): void;
+    get(): string;
+    prependHead(fragment: string): void;
+    appendHead(fragment: string): void;
+    prependBody(fragment: string): void;
+    appendBody(fragment: string): void;
+    private replaceBody;
+}

package/dist/types/base/middlewares/faviconFallback.d.ts

@@ -0,0 +1,2 @@
+import { Middleware } from '../../core/server';
+export declare const favionFallbackMiddleware: Middleware;

package/dist/types/base/middlewares/frameworkHeader.d.ts

@@ -0,0 +1,2 @@
+import { Middleware } from '../../core/server';
+export declare const processedBy: Middleware;

package/dist/types/base/middlewares/index.d.ts

@@ -0,0 +1,5 @@
+export * from './faviconFallback';
+export * from './monitor';
+export * from './renderHandler';
+export * from './logger';
+export * from './frameworkHeader';

package/dist/types/base/middlewares/logger.d.ts

@@ -0,0 +1,2 @@
+import type { Middleware, ServerEnv } from '../../core/server';
+export declare function logHandler(): Middleware<ServerEnv>;

package/dist/types/base/middlewares/monitor.d.ts

@@ -0,0 +1,6 @@
+import type { Logger, Metrics } from '@modern-js/types';
+import type { Context, Next, ServerEnv } from '../../core/server';
+export declare function injectReporter(): (c: Context<ServerEnv>, next: Next) => Promise<void>;
+export declare function initReporter(entryName: string): (c: Context<ServerEnv>, next: Next) => Promise<void>;
+export declare function injectLogger(inputLogger: Logger): (c: Context<ServerEnv>, next: Next) => Promise<void>;
+export declare function injectMetrics(inputMetrics: Metrics): (c: Context<ServerEnv>, next: Next) => Promise<void>;

package/dist/types/base/middlewares/renderHandler/dataHandler.d.ts

@@ -0,0 +1,5 @@
+import type { ServerRoute } from '@modern-js/types';
+import { SSRRenderOptions } from './ssrRender';
+export declare const dataHandler: (request: Request, { routeInfo, serverRoutes, reporter, logger, serverManifest, }: SSRRenderOptions & {
+    serverRoutes: ServerRoute[];
+}) => Promise<Response | void>;

package/dist/types/base/middlewares/renderHandler/index.d.ts

@@ -0,0 +1,9 @@
+import { Render } from '../../../core/render';
+import { ServerBase, type ServerBaseOptions } from '../../serverBase';
+export type BindRenderHandleOptions = {
+    metaName?: string;
+    staticGenerate?: boolean;
+    disableCustomHook?: boolean;
+};
+export declare function getRenderHandler(options: ServerBaseOptions & BindRenderHandleOptions): Promise<Render | null>;
+export declare function bindRenderHandler(server: ServerBase, options: ServerBaseOptions & BindRenderHandleOptions): Promise<void>;

package/dist/types/base/middlewares/renderHandler/render.d.ts

@@ -0,0 +1,12 @@
+import { ServerRoute } from '@modern-js/types';
+import { Render } from '../../../core/render';
+interface CreateRenderOptions {
+    routes: ServerRoute[];
+    pwd: string;
+    staticGenerate?: boolean;
+    metaName?: string;
+    forceCSR?: boolean;
+    nonce?: string;
+}
+export declare function createRender({ routes, pwd, metaName, staticGenerate, forceCSR, nonce, }: CreateRenderOptions): Promise<Render>;
+export {};

package/dist/types/base/middlewares/renderHandler/serverTiming.d.ts

@@ -0,0 +1,7 @@
+import { ServerTiming as ServerTimingInterafce } from '@modern-js/types';
+export declare class ServerTiming implements ServerTimingInterafce {
+    private headers;
+    private meta;
+    constructor(headers: Headers, meta: string);
+    addServeTiming(name: string, dur: number, desc?: string): this;
+}

package/dist/types/base/middlewares/renderHandler/ssrCache.d.ts

@@ -0,0 +1,28 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import type { IncomingMessage } from 'http';
+import { Readable } from 'stream';
+import type { CacheControl, CacheOption, Container } from '@modern-js/types';
+import type { SSRServerContext, ServerRender } from '../../../core/server';
+export type CacheStatus = 'hit' | 'stale' | 'expired' | 'miss';
+export type CacheResult = {
+    data: string | Readable | ReadableStream;
+    status?: CacheStatus;
+};
+export declare class CacheManager {
+    private container;
+    constructor(container: Container<string, string>);
+    getCacheResult(req: Request, cacheControl: CacheControl, render: ServerRender, ssrContext: SSRServerContext): Promise<CacheResult>;
+    private processCache;
+    private computedKey;
+}
+declare class ServerCache {
+    customContainer?: Container;
+    cacheOption?: CacheOption;
+    private cacheManger?;
+    loadCacheMod(pwd?: string): Promise<void>;
+    matchCacheControl(req?: IncomingMessage): CacheControl | Promise<CacheControl> | undefined;
+    getCache(req: Request, cacheControl: CacheControl, render: ServerRender, ssrContext: SSRServerContext): Promise<CacheResult>;
+}
+export declare const ssrCache: ServerCache;
+export {};

package/dist/types/base/middlewares/renderHandler/ssrRender.d.ts

@@ -0,0 +1,21 @@
+/// <reference types="node" />
+import type { IncomingMessage } from 'http';
+import type { Logger, Metrics, Reporter, ServerRoute } from '@modern-js/types';
+import { ServerManifest } from '../../../core/server';
+export interface SSRRenderOptions {
+    pwd: string;
+    html: string;
+    routeInfo: ServerRoute;
+    staticGenerate: boolean;
+    metaName: string;
+    logger: Logger;
+    serverManifest: ServerManifest;
+    /** Produce by custom server hook */
+    locals?: Record<string, any>;
+    reporter?: Reporter;
+    metrics?: Metrics;
+    nodeReq?: IncomingMessage;
+    nonce?: string;
+}
+export declare function ssrRender(request: Request, { routeInfo, html, staticGenerate, nonce, metaName, reporter, logger, nodeReq, serverManifest, locals, metrics, }: SSRRenderOptions): Promise<Response>;
+export declare function getPathnameFromNodeReq(nodeReq: IncomingMessage): string;

package/dist/types/base/serverBase.d.ts

@@ -0,0 +1,70 @@
+import { InternalPlugins, ServerRoute } from '@modern-js/types';
+import { Hono } from 'hono';
+import { ServerHookRunner, ServerPlugin } from '../core';
+import type { Env } from '../core/server';
+import type { ServerOptions } from '../types/config';
+declare module '@modern-js/types' {
+    interface ISAppContext {
+        serverBase?: ServerBase;
+    }
+}
+export type ServerBaseOptions = {
+    /** server working directory, and then also dist directory */
+    pwd: string;
+    config: ServerOptions;
+    serverConfigFile?: string;
+    routes?: ServerRoute[];
+    plugins?: ServerPlugin[];
+    internalPlugins?: InternalPlugins;
+    appContext: {
+        appDirectory?: string;
+        sharedDirectory?: string;
+        apiDirectory?: string;
+        lambdaDirectory?: string;
+    };
+    runMode?: 'apiOnly' | 'ssrOnly' | 'webOnly';
+};
+export declare class ServerBase<E extends Env = any> {
+    options: ServerBaseOptions;
+    runner: ServerHookRunner;
+    private app;
+    private serverConfig;
+    constructor(options: ServerBaseOptions);
+    /**
+     * 初始化顺序
+     * - 获取 server runtime config
+     * - 设置 context
+     * - 创建 hooksRunner
+     * - 合并插件，内置插件和 serverConfig 中配置的插件
+     * - 执行 config hook
+     * - 获取最终的配置
+     * - 设置配置到 context
+     * - 执行 prepare hook
+     */
+    init(): Promise<this>;
+    private createHookRunner;
+    private loadInternalPlugins;
+    private loadExternalPlugins;
+    private initServerConfig;
+    private injectContext;
+    private initAppContext;
+    /**
+     * Execute config hooks
+     * @param runner
+     * @param options
+     */
+    private runConfigHook;
+    private initConfig;
+    get all(): import("hono/types").HandlerInterface<E, "all", {}, "/">;
+    get use(): import("hono/types").MiddlewareHandlerInterface<E, {}, "/">;
+    get get(): import("hono/types").HandlerInterface<E, "get", {}, "/">;
+    get post(): import("hono/types").HandlerInterface<E, "post", {}, "/">;
+    get put(): import("hono/types").HandlerInterface<E, "put", {}, "/">;
+    get delete(): import("hono/types").HandlerInterface<E, "delete", {}, "/">;
+    get patch(): import("hono/types").HandlerInterface<E, "patch", {}, "/">;
+    get handle(): (request: Request, Env?: {} | E["Bindings"] | undefined, executionCtx?: import("hono/dist/types/context").ExecutionContext | undefined) => Response | Promise<Response>;
+    get request(): (input: RequestInfo | URL, requestInit?: RequestInit | undefined, Env?: {} | E["Bindings"] | undefined, executionCtx?: import("hono/dist/types/context").ExecutionContext | undefined) => Response | Promise<Response>;
+    get notFound(): (handler: import("hono").NotFoundHandler<E>) => Hono<E, {}, "/">;
+    get onError(): (handler: import("hono").ErrorHandler<E>) => Hono<E, {}, "/">;
+}
+export declare function createServerBase<E extends Env>(options: ServerBaseOptions): ServerBase<E>;

package/dist/types/base/utils/debug.d.ts

@@ -0,0 +1 @@
+export declare const debug: import("@modern-js/utils/compiled/debug").Debugger;

package/dist/types/base/utils/entry.d.ts

@@ -0,0 +1,2 @@
+import { ServerRoute } from '@modern-js/types';
+export declare const sortRoutes: (route1: ServerRoute, route2: ServerRoute) => number;

package/dist/types/base/utils/env.d.ts

@@ -0,0 +1,2 @@
+export declare const getRuntimeEnv: () => "node" | "other";
+export declare const checkIsProd: () => boolean;

package/dist/types/base/utils/error.d.ts

@@ -0,0 +1 @@
+export declare const createErrorHtml: (status: number) => string;

package/dist/types/base/utils/index.d.ts

@@ -0,0 +1,7 @@
+export * from './env';
+export * from './request';
+export * from './transformStream';
+export * from './middlewareCollector';
+export * from './error';
+export * from './warmup';
+export * from './entry';

package/dist/types/base/utils/middlewareCollector.d.ts

@@ -0,0 +1,12 @@
+export type CollectMiddlewaresResult = {
+    web: any[];
+    api: any[];
+};
+export declare const mergeExtension: (users: any[]) => {
+    middleware: any[];
+};
+export declare const createMiddlewareCollecter: () => {
+    getMiddlewares: () => CollectMiddlewaresResult;
+    addWebMiddleware: (input: any) => void;
+    addAPIMiddleware: (input: any) => void;
+};

package/dist/types/base/utils/request.d.ts

@@ -0,0 +1,12 @@
+export declare function parseQuery(request: Request): Record<string, string>;
+export declare function parseHeaders(request: Request): Record<string, string | undefined>;
+/**
+ * The function is modified based on
+ * https://github.com/honojs/hono/blob/main/src/utils/url.ts
+ *
+ * MIT Licensed
+ * https://github.com/honojs/hono/blob/main/LICENSE
+ *
+ */
+export declare function getPathname(request: Request): string;
+export declare function getHost(request: Request): string;

package/dist/types/base/utils/serverConfig.d.ts

@@ -0,0 +1,14 @@
+import { ServerConfig } from '../../core/plugin';
+import { ServerOptions } from '../../types/config';
+export declare const getServerConfigPath: (distDirectory: string, serverConfigFile?: string) => Promise<string>;
+export declare const requireConfig: (serverConfigPath: string) => any;
+/**
+ * 对配置进行合并，开发环境下，cliConfig 与 serverConfig 进行深合并
+ * 生产环境下，resolvedConfig 与 serverConfig 进行深合并
+ * resolvedConfigPath: 构建序列化后的 modern.config.js 文件路径
+ */
+export declare const loadConfig: ({ cliConfig, serverConfig, resolvedConfigPath, }: {
+    cliConfig: ServerOptions;
+    serverConfig: ServerConfig;
+    resolvedConfigPath: string;
+}) => any;

package/dist/types/base/utils/transformStream.d.ts

@@ -0,0 +1,5 @@
+import { MaybeAsync } from '@modern-js/plugin';
+type TransformCb = (tempalte: string) => MaybeAsync<string>;
+export declare function createTransformStream(fn: TransformCb): TransformStream<any, any>;
+export declare function transformResponse(response: Response, transformCb: Array<TransformCb> | TransformCb): Response;
+export {};

package/dist/types/base/utils/warmup.d.ts

@@ -0,0 +1 @@
+export declare function warmup(bundles: Array<string | undefined>): void;

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

@@ -0,0 +1 @@
+export * from './plugin';

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

@@ -0,0 +1,3 @@
+import { InternalPlugins } from '@modern-js/types';
+import { createPlugin } from '../core/plugin';
+export declare const loadPlugins: (appDirectory: string, internalPlugins: InternalPlugins) => ReturnType<typeof createPlugin>[];

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

@@ -0,0 +1,202 @@
+/// <reference types="node" />
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import { CommonAPI, ToThreads, AsyncSetup, PluginOptions, ToRunners } from '@modern-js/plugin';
+import type { ModernServerContext, AfterMatchContext, AfterRenderContext, MiddlewareContext, ISAppContext, HttpMethodDecider, ServerInitHookContext, AfterStreamingRenderContext } from '@modern-js/types';
+import { MiddlewareHandler as Middleware } from 'hono';
+import type { BffUserConfig, UserConfig } from '../types/config';
+import { Render } from './render';
+export type WebAdapter = (ctx: MiddlewareContext) => void | Promise<void>;
+export type NodeRequest = IncomingMessage;
+export type NodeResponse = ServerResponse;
+export type Adapter = (req: NodeRequest, res: NodeResponse) => void | Promise<void>;
+export type WebServerStartInput = {
+    pwd: string;
+    config: Record<string, any>;
+};
+export type LoaderHandler = (context: ModernServerContext) => Promise<void>;
+export type APIServerStartInput = {
+    pwd: string;
+    prefix?: string;
+    httpMethodDecider?: HttpMethodDecider;
+    config?: {
+        middleware?: Array<any>;
+    };
+    render?: Render | null;
+};
+type Change = {
+    filename: string;
+    event: 'add' | 'change' | 'unlink';
+};
+export type Route = Record<string, unknown>;
+export type RequestResult = {
+    isfinish: boolean;
+};
+export type SSRServerContext = Record<string, unknown>;
+export type RenderContext = Record<string, unknown>;
+export declare const AppContext: import("@modern-js/plugin").Context<ISAppContext>;
+export declare const setAppContext: (value: ISAppContext) => void;
+export declare const ConfigContext: import("@modern-js/plugin").Context<UserConfig>;
+/**
+ * Get original content of user config.
+ */
+export declare const useConfigContext: () => UserConfig;
+/**
+ * Get app context, including directories, plugins and some static infos.
+ */
+export declare const useAppContext: () => ISAppContext;
+declare const pluginAPI: {
+    useAppContext: () => ISAppContext;
+    useConfigContext: () => UserConfig;
+    setAppContext: (value: ISAppContext) => void;
+};
+declare const serverHooks: {
+    gather: import("@modern-js/plugin").ParallelWorkflow<{
+        addWebMiddleware: (_input: any) => void;
+        addAPIMiddleware: (_input: any) => void;
+    }, unknown>;
+    config: import("@modern-js/plugin").Waterfall<ServerConfig>;
+    prepare: import("@modern-js/plugin").Waterfall<void>;
+    prepareWebServer: import("@modern-js/plugin").AsyncPipeline<WebServerStartInput, WebAdapter | null>;
+    prepareApiServer: import("@modern-js/plugin").AsyncPipeline<APIServerStartInput, Middleware>;
+    repack: import("@modern-js/plugin").Waterfall<void>;
+    onApiChange: import("@modern-js/plugin").AsyncWaterfall<Change[]>;
+    beforeServerInit: import("@modern-js/plugin").AsyncWaterfall<ServerInitHookContext>;
+    afterMatch: import("@modern-js/plugin").AsyncPipeline<AfterMatchContext, any>;
+    afterRender: import("@modern-js/plugin").AsyncPipeline<AfterRenderContext, any>;
+    afterStreamingRender: import("@modern-js/plugin").AsyncPipeline<AfterStreamingRenderContext, string>;
+    reset: import("@modern-js/plugin").ParallelWorkflow<void, unknown>;
+};
+/** All hooks of server plugin. */
+export type ServerHooks = typeof serverHooks;
+/** All hook callbacks of server plugin. */
+export type ServerHookCallbacks = ToThreads<ServerHooks>;
+/** The ServerHook Runner type */
+export type ServerHookRunner = ToRunners<ServerHooks>;
+/** All apis for server plugin. */
+export type PluginAPI = typeof pluginAPI & CommonAPI<ServerHooks>;
+export declare const createServerManager: () => import("@modern-js/plugin").AsyncManager<{
+    gather: import("@modern-js/plugin").ParallelWorkflow<{
+        addWebMiddleware: (_input: any) => void;
+        addAPIMiddleware: (_input: any) => void;
+    }, unknown>;
+    config: import("@modern-js/plugin").Waterfall<ServerConfig>;
+    prepare: import("@modern-js/plugin").Waterfall<void>;
+    prepareWebServer: import("@modern-js/plugin").AsyncPipeline<WebServerStartInput, WebAdapter | null>;
+    prepareApiServer: import("@modern-js/plugin").AsyncPipeline<APIServerStartInput, Middleware>;
+    repack: import("@modern-js/plugin").Waterfall<void>;
+    onApiChange: import("@modern-js/plugin").AsyncWaterfall<Change[]>;
+    beforeServerInit: import("@modern-js/plugin").AsyncWaterfall<ServerInitHookContext>;
+    afterMatch: import("@modern-js/plugin").AsyncPipeline<AfterMatchContext, any>;
+    afterRender: import("@modern-js/plugin").AsyncPipeline<AfterRenderContext, any>;
+    afterStreamingRender: import("@modern-js/plugin").AsyncPipeline<AfterStreamingRenderContext, string>;
+    reset: import("@modern-js/plugin").ParallelWorkflow<void, unknown>;
+}, {
+    useAppContext: () => ISAppContext;
+    useConfigContext: () => UserConfig;
+    setAppContext: (value: ISAppContext) => void;
+}>;
+export declare const serverManager: import("@modern-js/plugin").AsyncManager<{
+    gather: import("@modern-js/plugin").ParallelWorkflow<{
+        addWebMiddleware: (_input: any) => void;
+        addAPIMiddleware: (_input: any) => void;
+    }, unknown>;
+    config: import("@modern-js/plugin").Waterfall<ServerConfig>;
+    prepare: import("@modern-js/plugin").Waterfall<void>;
+    prepareWebServer: import("@modern-js/plugin").AsyncPipeline<WebServerStartInput, WebAdapter | null>;
+    prepareApiServer: import("@modern-js/plugin").AsyncPipeline<APIServerStartInput, Middleware>;
+    repack: import("@modern-js/plugin").Waterfall<void>;
+    onApiChange: import("@modern-js/plugin").AsyncWaterfall<Change[]>;
+    beforeServerInit: import("@modern-js/plugin").AsyncWaterfall<ServerInitHookContext>;
+    afterMatch: import("@modern-js/plugin").AsyncPipeline<AfterMatchContext, any>;
+    afterRender: import("@modern-js/plugin").AsyncPipeline<AfterRenderContext, any>;
+    afterStreamingRender: import("@modern-js/plugin").AsyncPipeline<AfterStreamingRenderContext, string>;
+    reset: import("@modern-js/plugin").ParallelWorkflow<void, unknown>;
+}, {
+    useAppContext: () => ISAppContext;
+    useConfigContext: () => UserConfig;
+    setAppContext: (value: ISAppContext) => void;
+}>;
+/** Plugin options of a server plugin. */
+export type ServerPlugin = PluginOptions<ServerHooks, AsyncSetup<ServerHooks, PluginAPI>>;
+export type ServerConfig = {
+    bff?: BffUserConfig;
+    plugins?: ServerPlugin[];
+};
+export declare const createPlugin: (setup?: AsyncSetup<{
+    gather: import("@modern-js/plugin").ParallelWorkflow<{
+        addWebMiddleware: (_input: any) => void;
+        addAPIMiddleware: (_input: any) => void;
+    }, unknown>;
+    config: import("@modern-js/plugin").Waterfall<ServerConfig>;
+    prepare: import("@modern-js/plugin").Waterfall<void>;
+    prepareWebServer: import("@modern-js/plugin").AsyncPipeline<WebServerStartInput, WebAdapter | null>;
+    prepareApiServer: import("@modern-js/plugin").AsyncPipeline<APIServerStartInput, Middleware>;
+    repack: import("@modern-js/plugin").Waterfall<void>;
+    onApiChange: import("@modern-js/plugin").AsyncWaterfall<Change[]>;
+    beforeServerInit: import("@modern-js/plugin").AsyncWaterfall<ServerInitHookContext>;
+    afterMatch: import("@modern-js/plugin").AsyncPipeline<AfterMatchContext, any>;
+    afterRender: import("@modern-js/plugin").AsyncPipeline<AfterRenderContext, any>;
+    afterStreamingRender: import("@modern-js/plugin").AsyncPipeline<AfterStreamingRenderContext, string>;
+    reset: import("@modern-js/plugin").ParallelWorkflow<void, unknown>;
+}, {
+    useAppContext: () => ISAppContext;
+    useConfigContext: () => UserConfig;
+    setAppContext: (value: ISAppContext) => void;
+}> | undefined, options?: PluginOptions<{
+    gather: import("@modern-js/plugin").ParallelWorkflow<{
+        addWebMiddleware: (_input: any) => void;
+        addAPIMiddleware: (_input: any) => void;
+    }, unknown>;
+    config: import("@modern-js/plugin").Waterfall<ServerConfig>;
+    prepare: import("@modern-js/plugin").Waterfall<void>;
+    prepareWebServer: import("@modern-js/plugin").AsyncPipeline<WebServerStartInput, WebAdapter | null>;
+    prepareApiServer: import("@modern-js/plugin").AsyncPipeline<APIServerStartInput, Middleware>;
+    repack: import("@modern-js/plugin").Waterfall<void>;
+    onApiChange: import("@modern-js/plugin").AsyncWaterfall<Change[]>;
+    beforeServerInit: import("@modern-js/plugin").AsyncWaterfall<ServerInitHookContext>;
+    afterMatch: import("@modern-js/plugin").AsyncPipeline<AfterMatchContext, any>;
+    afterRender: import("@modern-js/plugin").AsyncPipeline<AfterRenderContext, any>;
+    afterStreamingRender: import("@modern-js/plugin").AsyncPipeline<AfterStreamingRenderContext, string>;
+    reset: import("@modern-js/plugin").ParallelWorkflow<void, unknown>;
+}, AsyncSetup<{
+    gather: import("@modern-js/plugin").ParallelWorkflow<{
+        addWebMiddleware: (_input: any) => void;
+        addAPIMiddleware: (_input: any) => void;
+    }, unknown>;
+    config: import("@modern-js/plugin").Waterfall<ServerConfig>;
+    prepare: import("@modern-js/plugin").Waterfall<void>;
+    prepareWebServer: import("@modern-js/plugin").AsyncPipeline<WebServerStartInput, WebAdapter | null>;
+    prepareApiServer: import("@modern-js/plugin").AsyncPipeline<APIServerStartInput, Middleware>;
+    repack: import("@modern-js/plugin").Waterfall<void>;
+    onApiChange: import("@modern-js/plugin").AsyncWaterfall<Change[]>;
+    beforeServerInit: import("@modern-js/plugin").AsyncWaterfall<ServerInitHookContext>;
+    afterMatch: import("@modern-js/plugin").AsyncPipeline<AfterMatchContext, any>;
+    afterRender: import("@modern-js/plugin").AsyncPipeline<AfterRenderContext, any>;
+    afterStreamingRender: import("@modern-js/plugin").AsyncPipeline<AfterStreamingRenderContext, string>;
+    reset: import("@modern-js/plugin").ParallelWorkflow<void, unknown>;
+}, {
+    useAppContext: () => ISAppContext;
+    useConfigContext: () => UserConfig;
+    setAppContext: (value: ISAppContext) => void;
+}>> | undefined) => import("@modern-js/plugin").AsyncPlugin<{
+    gather: import("@modern-js/plugin").ParallelWorkflow<{
+        addWebMiddleware: (_input: any) => void;
+        addAPIMiddleware: (_input: any) => void;
+    }, unknown>;
+    config: import("@modern-js/plugin").Waterfall<ServerConfig>;
+    prepare: import("@modern-js/plugin").Waterfall<void>;
+    prepareWebServer: import("@modern-js/plugin").AsyncPipeline<WebServerStartInput, WebAdapter | null>;
+    prepareApiServer: import("@modern-js/plugin").AsyncPipeline<APIServerStartInput, Middleware>;
+    repack: import("@modern-js/plugin").Waterfall<void>;
+    onApiChange: import("@modern-js/plugin").AsyncWaterfall<Change[]>;
+    beforeServerInit: import("@modern-js/plugin").AsyncWaterfall<ServerInitHookContext>;
+    afterMatch: import("@modern-js/plugin").AsyncPipeline<AfterMatchContext, any>;
+    afterRender: import("@modern-js/plugin").AsyncPipeline<AfterRenderContext, any>;
+    afterStreamingRender: import("@modern-js/plugin").AsyncPipeline<AfterStreamingRenderContext, string>;
+    reset: import("@modern-js/plugin").ParallelWorkflow<void, unknown>;
+}, {
+    useAppContext: () => ISAppContext;
+    useConfigContext: () => UserConfig;
+    setAppContext: (value: ISAppContext) => void;
+}>;
+export {};

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

@@ -0,0 +1,17 @@
+/// <reference types="node" />
+import type { IncomingMessage } from 'node:http';
+import type { Logger, Metrics, Reporter } from '@modern-js/types';
+import type { ServerManifest } from './server';
+export interface RenderOptions {
+    logger: Logger;
+    /** ssr render html templates */
+    templates: Record<string, string>;
+    /** Communicating with custom server hook & modern ssr runtime. */
+    locals?: Record<string, any>;
+    /** Metrics */
+    metrics?: Metrics;
+    serverManifest: ServerManifest;
+    reporter?: Reporter;
+    nodeReq?: IncomingMessage;
+}
+export type Render = (request: Request, options: RenderOptions) => Promise<Response>;