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

package/dist/esm-node/core/plugin.js

@@ -2,33 +2,14 @@ import { createContext, createAsyncManager, createAsyncPipeline, createAsyncWate
 const gather = createParallelWorkflow();
 const config = createWaterfall();
 const prepare = createWaterfall();
-const prepareLoaderHandler = createAsyncPipeline();
 const prepareWebServer = createAsyncPipeline();
 const prepareApiServer = createAsyncPipeline();
 const onApiChange = createAsyncWaterfall();
 const repack = createWaterfall();
 const beforeServerInit = createAsyncWaterfall();
-const setupCompiler = createParallelWorkflow();
-const beforeRouteSet = createAsyncPipeline();
-const afterRouteSet = createAsyncPipeline();
-const beforeProdServer = createParallelWorkflow();
-const afterProdServer = createParallelWorkflow();
-const listen = createParallelWorkflow();
-const beforeServerReset = createParallelWorkflow();
-const afterServerReset = createParallelWorkflow();
-const extendSSRContext = createAsyncWaterfall();
-const extendContext = createAsyncPipeline();
-const handleError = createParallelWorkflow();
-const handleSSRFallback = createParallelWorkflow();
-const beforeMatch = createAsyncPipeline();
 const afterMatch = createAsyncPipeline();
-const prefetch = createParallelWorkflow();
-const renderToString = createAsyncPipeline();
-const beforeRender = createAsyncPipeline();
 const afterRender = createAsyncPipeline();
 const afterStreamingRender = createAsyncPipeline();
-const beforeSend = createAsyncPipeline();
-const afterSend = createParallelWorkflow();
 const reset = createParallelWorkflow();
 const AppContext = createContext({});
 const setAppContext = (value) => AppContext.set(value);
@@ -45,34 +26,14 @@ const serverHooks = {
   gather,
   config,
   prepare,
-  prepareLoaderHandler,
   prepareWebServer,
   prepareApiServer,
   repack,
   onApiChange,
   beforeServerInit,
-  setupCompiler,
-  beforeRouteSet,
-  afterRouteSet,
-  beforeProdServer,
-  afterProdServer,
-  listen,
-  beforeServerReset,
-  afterServerReset,
-  // request hook
-  extendSSRContext,
-  extendContext,
-  handleError,
-  handleSSRFallback,
-  beforeMatch,
   afterMatch,
-  prefetch,
-  renderToString,
-  beforeRender,
   afterRender,
   afterStreamingRender,
-  beforeSend,
-  afterSend,
   reset
 };
 const createServerManager = () => createAsyncManager(serverHooks, pluginAPI);

package/dist/types/base/adapters/node/bff.d.ts

@@ -1,4 +1,3 @@
-import type { ServerBaseOptions } from '../../../core/server';
 import { BindRenderHandleOptions } from '../../../base/middlewares';
-import { ServerBase } from '../../serverBase';
+import { ServerBase, type ServerBaseOptions } from '../../serverBase';
 export declare const bindBFFHandler: (server: ServerBase, options: ServerBaseOptions & BindRenderHandleOptions) => Promise<void>;

package/dist/types/base/adapters/node/hono.d.ts

@@ -1,5 +1,5 @@
 import { NodeRequest, NodeResponse } from '../../../core/plugin';
-import { HonoContext, HonoRequest, ServerEnv, Middleware, Next, ServerManifest } from '../../../core/server';
+import { Context, HonoRequest, ServerEnv, Middleware, Next, ServerManifest } from '../../../core/server';
 type NodeBindings = {
     node: {
         req: NodeRequest & {
@@ -14,9 +14,9 @@ export type ServerNodeEnv = {
     Bindings: NodeBindings;
 };
 export type ServerNodeMiddleware = Middleware<ServerNodeEnv>;
-export type ServerNodeContext = HonoContext<ServerNodeEnv>;
+export type ServerNodeContext = Context<ServerNodeEnv>;
 type Handler = (req: NodeRequest, res: NodeResponse) => void | Promise<void>;
-export declare const httpCallBack2HonoMid: (handler: Handler) => (context: HonoContext<ServerNodeEnv & ServerEnv>, next: Next) => Promise<void>;
+export declare const httpCallBack2HonoMid: (handler: Handler) => (context: Context<ServerNodeEnv & ServerEnv>, next: Next) => Promise<void>;
 type ConnectMiddleware = ((req: NodeRequest, res: NodeResponse, callback: (...args: unknown[]) => void) => void) | ((req: NodeRequest, res: NodeResponse) => void);
 export declare const connectMid2HonoMid: (handler: ConnectMiddleware) => Middleware;
 export {};

package/dist/types/base/adapters/node/loadServer.d.ts

@@ -1,3 +1,3 @@
-import { ServerBaseOptions } from '../../../core/server';
+import type { ServerBaseOptions } from '../../serverBase';
 /** 读取 .env.{process.env.MODERN_ENV} 文件，加载环境变量 */
 export declare function loadServerEnv(options: ServerBaseOptions): Promise<void>;

package/dist/types/base/adapters/node/middlewares/serverManifest.d.ts

@@ -1,3 +1,3 @@
 import type { ServerRoute } from '@modern-js/types';
-import { HonoMiddleware, ServerEnv } from '../../../../core/server';
-export declare function injectServerManifest(pwd: string, routes?: ServerRoute[]): HonoMiddleware<ServerEnv>;
+import { Middleware, ServerEnv } from '../../../../core/server';
+export declare function injectServerManifest(pwd: string, routes?: ServerRoute[]): Middleware<ServerEnv>;

package/dist/types/base/adapters/node/middlewares/templates.d.ts

@@ -1,4 +1,4 @@
 import { ServerRoute } from '@modern-js/types';
-import { HonoMiddleware, ServerEnv } from '../../../../core/server';
+import { Middleware, ServerEnv } from '../../../../core/server';
 export declare function getHtmlTemplates(pwd: string, routes: ServerRoute[]): Promise<Record<string, string>>;
-export declare function injectTemplates(pwd: string, routes?: ServerRoute[]): HonoMiddleware<ServerEnv>;
+export declare function injectTemplates(pwd: string, routes?: ServerRoute[]): Middleware<ServerEnv>;

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

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

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

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

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

@@ -1,7 +1,7 @@
 import { AfterMatchContext, AfterRenderContext, MiddlewareContext, AfterStreamingRenderContext, ServerRoute, HookContext } from '@modern-js/types';
-import { HonoContext, ServerEnv } from '../../../core/server';
+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: HonoContext, baseHookCtx: HookContext, route: Partial<ServerRoute>): Promise<AfterRenderContext>;
-export declare function createCustomMiddlewaresCtx(c: HonoContext<ServerNodeEnv & ServerEnv>, locals: Record<string, any>): MiddlewareContext;
+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/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

@@ -2,3 +2,4 @@ export * from './faviconFallback';
 export * from './monitor';
 export * from './renderHandler';
 export * from './logger';
+export * from './frameworkHeader';

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

@@ -1,6 +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>;
+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/index.d.ts

@@ -1,6 +1,5 @@
 import { Render } from '../../../core/render';
-import { ServerBaseOptions } from '../../../core/server';
-import { ServerBase } from '../../serverBase';
+import { ServerBase, type ServerBaseOptions } from '../../serverBase';
 export type BindRenderHandleOptions = {
     metaName?: string;
     staticGenerate?: boolean;

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

@@ -1,6 +1,5 @@
 /// <reference types="node" />
-/// <reference types="node/http" />
-/// <reference types="dist/types/core/server" />
+/// <reference types="node" />
 import type { IncomingMessage } from 'http';
 import { Readable } from 'stream';
 import type { CacheControl, CacheOption, Container } from '@modern-js/types';

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

@@ -1,5 +1,4 @@
-/// <reference types="node/http" />
-/// <reference types="dist/types/core/server" />
+/// <reference types="node" />
 import type { IncomingMessage } from 'http';
 import type { Logger, Reporter, ServerRoute } from '@modern-js/types';
 import { ServerManifest } from '../../../core/server';

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

@@ -1,12 +1,30 @@
+import { InternalPlugins, ServerRoute } from '@modern-js/types';
 import { Hono } from 'hono';
-import { ServerHookRunner } from '../core';
-import type { HonoEnv, ServerBaseOptions } from '../core/server';
+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 declare class ServerBase<E extends HonoEnv = any> {
+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;
@@ -49,4 +67,4 @@ export declare class ServerBase<E extends HonoEnv = any> {
     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>;
+export declare function createServerBase<E extends Env>(options: ServerBaseOptions): ServerBase<E>;

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

@@ -5,4 +5,3 @@ export * from './middlewareCollector';
 export * from './error';
 export * from './warmup';
 export * from './entry';
-export declare const cutNameByHyphen: (s: string) => string;