@modern-js/server-core 2.48.3 → 2.48.5-alpha.0

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, } from './middlewares';
+export type { BindRenderHandleOptions } from './middlewares';
+export type { ServerBase } from './serverBase';
+export { createServerBase } from './serverBase';
+export type { ServerBaseOptions, Next, Middleware, ServerEnv, ServerManifest, HonoContext, HonoEnv, HonoMiddleware, HonoRequest, } from '../core/server';

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

@@ -0,0 +1,3 @@
+import { HookContext } from '@modern-js/types';
+import type { HonoContext, ServerEnv } from '../../../core/server';
+export declare function createBaseHookContext(c: HonoContext<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 { HonoContext, 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: HonoContext, baseHookCtx: HookContext, route: Partial<ServerRoute>): Promise<AfterRenderContext>;
+export declare function createCustomMiddlewaresCtx(c: HonoContext<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/index.d.ts

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

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

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

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

@@ -0,0 +1,6 @@
+import type { Logger, Metrics } from '@modern-js/types';
+import type { HonoContext, Next, ServerEnv } from '../../core/server';
+export declare function injectReporter(): (c: HonoContext<ServerEnv>, next: Next) => Promise<void>;
+export declare function initReporter(entryName: string): (c: HonoContext<ServerEnv>, next: Next) => Promise<void>;
+export declare function injectLogger(inputLogger: Logger): (c: HonoContext<ServerEnv>, next: Next) => Promise<void>;
+export declare function injectMetrics(inputMetrics: Metrics): (c: HonoContext<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,10 @@
+import { Render } from '../../../core/render';
+import { ServerBaseOptions } from '../../../core/server';
+import { ServerBase } 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,29 @@
+/// <reference types="node" />
+/// <reference types="node/http" />
+/// <reference types="dist/types/core/server" />
+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/http" />
+/// <reference types="dist/types/core/server" />
+import type { IncomingMessage } from 'http';
+import type { Logger, 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;
+    nodeReq?: IncomingMessage;
+    nonce?: string;
+}
+export declare function ssrRender(request: Request, { routeInfo, html, staticGenerate, nonce, metaName, reporter, logger, nodeReq, serverManifest, locals, }: SSRRenderOptions): Promise<Response>;
+export declare function getPathnameFromNodeReq(nodeReq: IncomingMessage): string;

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

@@ -0,0 +1,52 @@
+import { Hono } from 'hono';
+import { ServerHookRunner } from '../core';
+import type { HonoEnv, ServerBaseOptions } from '../core/server';
+declare module '@modern-js/types' {
+    interface ISAppContext {
+        serverBase?: ServerBase;
+    }
+}
+export declare class ServerBase<E extends HonoEnv = 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 HonoEnv>(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,8 @@
+export * from './env';
+export * from './request';
+export * from './transformStream';
+export * from './middlewareCollector';
+export * from './error';
+export * from './warmup';
+export * from './entry';
+export declare const cutNameByHyphen: (s: string) => string;

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/hono.d.ts

@@ -0,0 +1 @@
+export type { Context as HonoContext, Env as HonoEnv, HonoRequest, Next, MiddlewareHandler as HonoMiddleware, } from 'hono';

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/{plugin.d.ts → core/plugin.d.ts}

@@ -1,13 +1,15 @@
 /// <reference types="node" />
-/// <reference types="node" />
-import { IncomingMessage, ServerResponse } from 'http';
-import { Readable } from 'stream';
+import type { IncomingMessage, ServerResponse } from 'node:http';
 import type { Component } from 'react';
-import { CommonAPI, ToThreads, AsyncSetup, PluginOptions } from '@modern-js/plugin';
+import { CommonAPI, ToThreads, AsyncSetup, PluginOptions, ToRunners } from '@modern-js/plugin';
 import type { ModernServerContext, BaseSSRServerContext, AfterMatchContext, AfterRenderContext, MiddlewareContext, ISAppContext, ServerRoute, HttpMethodDecider, ServerInitHookContext, AfterStreamingRenderContext } from '@modern-js/types';
-import type { BffUserConfig, ServerOptions, UserConfig } from './types/config';
+import type { BffUserConfig, ServerOptions, UserConfig } from '../types/config';
+import { HonoMiddleware } from './hono';
+import { Render } from './render';
 export type WebAdapter = (ctx: MiddlewareContext) => void | Promise<void>;
-export type Adapter = (req: IncomingMessage, res: ServerResponse) => 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>;
@@ -20,7 +22,7 @@ export type APIServerStartInput = {
     config?: {
         middleware?: Array<any>;
     };
-    render?: (req: IncomingMessage, res: ServerResponse, url?: string) => Promise<string | Readable | null>;
+    render?: Render | null;
 };
 type Change = {
     filename: string;
@@ -59,12 +61,11 @@ declare const serverHooks: {
         serverRoutes: ServerRoute[];
         distDir: string;
     }, LoaderHandler>;
-    prepareWebServer: import("@modern-js/plugin").AsyncPipeline<WebServerStartInput, WebAdapter>;
-    prepareApiServer: import("@modern-js/plugin").AsyncPipeline<APIServerStartInput, Adapter>;
+    prepareWebServer: import("@modern-js/plugin").AsyncPipeline<WebServerStartInput, WebAdapter | null>;
+    prepareApiServer: import("@modern-js/plugin").AsyncPipeline<APIServerStartInput, HonoMiddleware>;
     repack: import("@modern-js/plugin").Waterfall<void>;
-    onApiChange: import("@modern-js/plugin").Waterfall<Change[]>;
+    onApiChange: import("@modern-js/plugin").AsyncWaterfall<Change[]>;
     beforeServerInit: import("@modern-js/plugin").AsyncWaterfall<ServerInitHookContext>;
-    afterServerInit: import("@modern-js/plugin").AsyncWaterfall<ServerInitHookContext>;
     setupCompiler: import("@modern-js/plugin").ParallelWorkflow<Record<string, unknown>, any[]>;
     beforeRouteSet: import("@modern-js/plugin").AsyncPipeline<Route[], Route[]>;
     afterRouteSet: import("@modern-js/plugin").AsyncPipeline<unknown, unknown>;
@@ -111,6 +112,8 @@ declare const serverHooks: {
 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<{
@@ -124,12 +127,11 @@ export declare const createServerManager: () => import("@modern-js/plugin").Asyn
         serverRoutes: ServerRoute[];
         distDir: string;
     }, LoaderHandler>;
-    prepareWebServer: import("@modern-js/plugin").AsyncPipeline<WebServerStartInput, WebAdapter>;
-    prepareApiServer: import("@modern-js/plugin").AsyncPipeline<APIServerStartInput, Adapter>;
+    prepareWebServer: import("@modern-js/plugin").AsyncPipeline<WebServerStartInput, WebAdapter | null>;
+    prepareApiServer: import("@modern-js/plugin").AsyncPipeline<APIServerStartInput, HonoMiddleware>;
     repack: import("@modern-js/plugin").Waterfall<void>;
-    onApiChange: import("@modern-js/plugin").Waterfall<Change[]>;
+    onApiChange: import("@modern-js/plugin").AsyncWaterfall<Change[]>;
     beforeServerInit: import("@modern-js/plugin").AsyncWaterfall<ServerInitHookContext>;
-    afterServerInit: import("@modern-js/plugin").AsyncWaterfall<ServerInitHookContext>;
     setupCompiler: import("@modern-js/plugin").ParallelWorkflow<Record<string, unknown>, any[]>;
     beforeRouteSet: import("@modern-js/plugin").AsyncPipeline<Route[], Route[]>;
     afterRouteSet: import("@modern-js/plugin").AsyncPipeline<unknown, unknown>;
@@ -187,12 +189,11 @@ export declare const serverManager: import("@modern-js/plugin").AsyncManager<{
         serverRoutes: ServerRoute[];
         distDir: string;
     }, LoaderHandler>;
-    prepareWebServer: import("@modern-js/plugin").AsyncPipeline<WebServerStartInput, WebAdapter>;
-    prepareApiServer: import("@modern-js/plugin").AsyncPipeline<APIServerStartInput, Adapter>;
+    prepareWebServer: import("@modern-js/plugin").AsyncPipeline<WebServerStartInput, WebAdapter | null>;
+    prepareApiServer: import("@modern-js/plugin").AsyncPipeline<APIServerStartInput, HonoMiddleware>;
     repack: import("@modern-js/plugin").Waterfall<void>;
-    onApiChange: import("@modern-js/plugin").Waterfall<Change[]>;
+    onApiChange: import("@modern-js/plugin").AsyncWaterfall<Change[]>;
     beforeServerInit: import("@modern-js/plugin").AsyncWaterfall<ServerInitHookContext>;
-    afterServerInit: import("@modern-js/plugin").AsyncWaterfall<ServerInitHookContext>;
     setupCompiler: import("@modern-js/plugin").ParallelWorkflow<Record<string, unknown>, any[]>;
     beforeRouteSet: import("@modern-js/plugin").AsyncPipeline<Route[], Route[]>;
     afterRouteSet: import("@modern-js/plugin").AsyncPipeline<unknown, unknown>;
@@ -256,12 +257,11 @@ export declare const createPlugin: (setup?: AsyncSetup<{
         serverRoutes: ServerRoute[];
         distDir: string;
     }, LoaderHandler>;
-    prepareWebServer: import("@modern-js/plugin").AsyncPipeline<WebServerStartInput, WebAdapter>;
-    prepareApiServer: import("@modern-js/plugin").AsyncPipeline<APIServerStartInput, Adapter>;
+    prepareWebServer: import("@modern-js/plugin").AsyncPipeline<WebServerStartInput, WebAdapter | null>;
+    prepareApiServer: import("@modern-js/plugin").AsyncPipeline<APIServerStartInput, HonoMiddleware>;
     repack: import("@modern-js/plugin").Waterfall<void>;
-    onApiChange: import("@modern-js/plugin").Waterfall<Change[]>;
+    onApiChange: import("@modern-js/plugin").AsyncWaterfall<Change[]>;
     beforeServerInit: import("@modern-js/plugin").AsyncWaterfall<ServerInitHookContext>;
-    afterServerInit: import("@modern-js/plugin").AsyncWaterfall<ServerInitHookContext>;
     setupCompiler: import("@modern-js/plugin").ParallelWorkflow<Record<string, unknown>, any[]>;
     beforeRouteSet: import("@modern-js/plugin").AsyncPipeline<Route[], Route[]>;
     afterRouteSet: import("@modern-js/plugin").AsyncPipeline<unknown, unknown>;
@@ -318,12 +318,11 @@ export declare const createPlugin: (setup?: AsyncSetup<{
         serverRoutes: ServerRoute[];
         distDir: string;
     }, LoaderHandler>;
-    prepareWebServer: import("@modern-js/plugin").AsyncPipeline<WebServerStartInput, WebAdapter>;
-    prepareApiServer: import("@modern-js/plugin").AsyncPipeline<APIServerStartInput, Adapter>;
+    prepareWebServer: import("@modern-js/plugin").AsyncPipeline<WebServerStartInput, WebAdapter | null>;
+    prepareApiServer: import("@modern-js/plugin").AsyncPipeline<APIServerStartInput, HonoMiddleware>;
     repack: import("@modern-js/plugin").Waterfall<void>;
-    onApiChange: import("@modern-js/plugin").Waterfall<Change[]>;
+    onApiChange: import("@modern-js/plugin").AsyncWaterfall<Change[]>;
     beforeServerInit: import("@modern-js/plugin").AsyncWaterfall<ServerInitHookContext>;
-    afterServerInit: import("@modern-js/plugin").AsyncWaterfall<ServerInitHookContext>;
     setupCompiler: import("@modern-js/plugin").ParallelWorkflow<Record<string, unknown>, any[]>;
     beforeRouteSet: import("@modern-js/plugin").AsyncPipeline<Route[], Route[]>;
     afterRouteSet: import("@modern-js/plugin").AsyncPipeline<unknown, unknown>;
@@ -376,12 +375,11 @@ export declare const createPlugin: (setup?: AsyncSetup<{
         serverRoutes: ServerRoute[];
         distDir: string;
     }, LoaderHandler>;
-    prepareWebServer: import("@modern-js/plugin").AsyncPipeline<WebServerStartInput, WebAdapter>;
-    prepareApiServer: import("@modern-js/plugin").AsyncPipeline<APIServerStartInput, Adapter>;
+    prepareWebServer: import("@modern-js/plugin").AsyncPipeline<WebServerStartInput, WebAdapter | null>;
+    prepareApiServer: import("@modern-js/plugin").AsyncPipeline<APIServerStartInput, HonoMiddleware>;
     repack: import("@modern-js/plugin").Waterfall<void>;
-    onApiChange: import("@modern-js/plugin").Waterfall<Change[]>;
+    onApiChange: import("@modern-js/plugin").AsyncWaterfall<Change[]>;
     beforeServerInit: import("@modern-js/plugin").AsyncWaterfall<ServerInitHookContext>;
-    afterServerInit: import("@modern-js/plugin").AsyncWaterfall<ServerInitHookContext>;
     setupCompiler: import("@modern-js/plugin").ParallelWorkflow<Record<string, unknown>, any[]>;
     beforeRouteSet: import("@modern-js/plugin").AsyncPipeline<Route[], Route[]>;
     afterRouteSet: import("@modern-js/plugin").AsyncPipeline<unknown, unknown>;
@@ -438,12 +436,11 @@ export declare const createPlugin: (setup?: AsyncSetup<{
         serverRoutes: ServerRoute[];
         distDir: string;
     }, LoaderHandler>;
-    prepareWebServer: import("@modern-js/plugin").AsyncPipeline<WebServerStartInput, WebAdapter>;
-    prepareApiServer: import("@modern-js/plugin").AsyncPipeline<APIServerStartInput, Adapter>;
+    prepareWebServer: import("@modern-js/plugin").AsyncPipeline<WebServerStartInput, WebAdapter | null>;
+    prepareApiServer: import("@modern-js/plugin").AsyncPipeline<APIServerStartInput, HonoMiddleware>;
     repack: import("@modern-js/plugin").Waterfall<void>;
-    onApiChange: import("@modern-js/plugin").Waterfall<Change[]>;
+    onApiChange: import("@modern-js/plugin").AsyncWaterfall<Change[]>;
     beforeServerInit: import("@modern-js/plugin").AsyncWaterfall<ServerInitHookContext>;
-    afterServerInit: import("@modern-js/plugin").AsyncWaterfall<ServerInitHookContext>;
     setupCompiler: import("@modern-js/plugin").ParallelWorkflow<Record<string, unknown>, any[]>;
     beforeRouteSet: import("@modern-js/plugin").AsyncPipeline<Route[], Route[]>;
     afterRouteSet: import("@modern-js/plugin").AsyncPipeline<unknown, unknown>;

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

@@ -0,0 +1,15 @@
+/// <reference types="node" />
+import type { IncomingMessage } from 'node:http';
+import type { Logger, 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>;
+    serverManifest: ServerManifest;
+    reporter?: Reporter;
+    nodeReq?: IncomingMessage;
+}
+export type Render = (request: Request, options: RenderOptions) => Promise<Response>;

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

@@ -0,0 +1,106 @@
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+import type { IncomingMessage, Server, ServerResponse } from 'node:http';
+import type { Readable } from 'node:stream';
+import type { Metrics, Logger, NextFunction, ModernServerContext, InternalPlugins, Reporter, BaseSSRServerContext, ServerRoute, NestedRoute } from '@modern-js/types';
+import { MiddlewareHandler } from 'hono';
+import { ServerOptions } from '../types/config/index';
+import { ServerHookRunner, ServerPlugin } from './plugin';
+import { HonoEnv } from './hono';
+declare module 'http' {
+    interface IncomingMessage {
+        logger: Logger;
+        metrics: Metrics;
+        reporter?: Reporter;
+        body?: any;
+    }
+    interface OutgoingMessage {
+        set: (key: string, value: any) => this;
+        modernFlushedHeaders?: boolean;
+    }
+}
+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 type SSRServerContext = BaseSSRServerContext & {
+    staticGenerate?: boolean;
+};
+export type ServerRender = (ssrContext: SSRServerContext) => Promise<string | Readable | ReadableStream>;
+export type RenderResult = {
+    content: string | Buffer;
+    contentType: string;
+    contentStream?: Readable;
+    statusCode?: number;
+    redirect?: boolean;
+};
+export type ConfWithBFF = {
+    bff?: {
+        prefix: string;
+    } & ServerOptions['bff'];
+};
+export type Then<T> = T extends PromiseLike<infer U> ? U : T;
+export type { Metrics, Logger, NextFunction };
+export type HookNames = 'afterMatch' | 'afterRender';
+export interface ModernServerInterface {
+    pwd: string;
+    distDir: string;
+    onInit: (runner: ServerHookRunner, app: Server) => Promise<void>;
+    getRequestHandler: () => (req: IncomingMessage, res: ServerResponse, next?: () => void) => void;
+    createHTTPServer: (handler: (req: IncomingMessage, res: ServerResponse, next?: () => void) => void) => Promise<Server>;
+    render: (req: IncomingMessage, res: ServerResponse, url?: string) => Promise<string | Readable | null>;
+    close?: () => Promise<void>;
+}
+export type ServerConstructor = (options: ServerBaseOptions) => ModernServerInterface;
+export type ModernServerHandler = (context: ModernServerContext, next: NextFunction) => Promise<void> | void;
+export type Middleware<Env extends HonoEnv = any> = MiddlewareHandler<Env>;
+export type RequestHandler = (request: Request, ...args: any[]) => Response | Promise<Response>;
+type ServerLoaderBundle = {
+    routes: NestedRoute[];
+    handleRequest: (options: {
+        request: Request;
+        serverRoutes: ServerRoute[];
+        context: any;
+        routes: NestedRoute[];
+    }) => Promise<any>;
+};
+type ServerRenderBundle = {
+    serverRender: () => any;
+};
+export type ServerManifest = {
+    loaderBundles?: Record<string, ServerLoaderBundle>;
+    renderBundles?: Record<string, ServerRenderBundle>;
+    loadableStats?: Record<string, any>;
+    routeManifest?: Record<string, any>;
+};
+type ServerVariables = {
+    logger: Logger;
+    reporter?: Reporter;
+    serverManifest?: ServerManifest;
+    /**
+     * Communicating with custom server hook & modern ssrContext.
+     *
+     * Produce by custom server.
+     * Custom by ssrRuntime.
+     */
+    locals?: Record<string, any>;
+    metrics?: Metrics;
+    templates?: Record<string, string>;
+};
+export type ServerEnv = {
+    Variables: ServerVariables;
+};
+export type { HonoContext, HonoEnv, HonoRequest, Next, HonoMiddleware, } from './hono';

package/dist/types/index.d.ts

@@ -1,4 +1,5 @@
-export * from './plugin';
+export * from './core/plugin';
+export * from './core/render';
 export * from '@modern-js/plugin';
-export * from './loadPlugins';
+export * from './core/loadPlugins';
 export * from './types/config';