@modern-js/server-core 2.65.4 → 2.65.6-alpha.0

package/dist/esm-node/plugins/index.js

@@ -4,10 +4,13 @@ import { injectServerTiming, injectloggerPlugin } from "./monitors";
 import { processedByPlugin } from "./processedBy";
 import { logPlugin } from "./log";
 import { createDefaultPlugins } from "./default";
+import { compatPlugin, handleSetupResult } from "./compat";
 export {
+  compatPlugin,
   createDefaultPlugins,
   faviconPlugin,
   getRenderHandler,
+  handleSetupResult,
   injectRenderHandlerPlugin,
   injectServerTiming,
   injectloggerPlugin,

package/dist/esm-node/plugins/render/index.js

@@ -11,12 +11,12 @@ const renderPlugin = () => ({
       async prepare() {
         var _config_render;
         const { middlewares, routes, render, distDirectory: pwd, serverBase } = api.useAppContext();
-        const runner = api.useHookRunners();
+        const hooks = api.getHooks();
         const config = api.useConfigContext();
         if (!routes) {
           return;
         }
-        const customServer = new CustomServer(runner, serverBase, pwd);
+        const customServer = new CustomServer(hooks, serverBase, pwd);
         const serverMiddleware = ((_config_render = config.render) === null || _config_render === void 0 ? void 0 : _config_render.middleware) && getServerMidFromUnstableMid(config.render.middleware);
         const pageRoutes = getPageRoutes(routes);
         middlewares.push({

package/dist/esm-node/serverBase.js

@@ -1,25 +1,40 @@
 import { _ as _class_private_method_get } from "@swc/helpers/_/_class_private_method_get";
 import { _ as _class_private_method_init } from "@swc/helpers/_/_class_private_method_init";
-import { createContext } from "@modern-js/plugin";
+import { server } from "@modern-js/plugin-v2/server";
 import { Hono } from "hono";
-import { PluginManager } from "./pluginManager";
-var _getAppContext = /* @__PURE__ */ new WeakSet(), _applyMiddlewares = /* @__PURE__ */ new WeakSet();
+import { handleSetupResult } from "./plugins/compat/hooks";
+import { loadConfig } from "./utils";
+var _applyMiddlewares = /* @__PURE__ */ new WeakSet();
 class ServerBase {
   /**
-  * 初始化顺序
-  * - 初始化 pluginManager;
-  * - 执行 runner.prepare;
-  * - 应用 middlewares
+  * Order
+  * - server runner
+  * - apply middlewares
   */
   async init() {
-    const runner = await this.pluginManager.init();
-    this.runner = runner;
-    await runner.prepare();
+    const { serverConfig, config: cliConfig } = this.options;
+    const mergedConfig = loadConfig({
+      cliConfig,
+      serverConfig: serverConfig || {}
+    });
+    this.addPlugins(mergedConfig.plugins || []);
+    const { serverContext } = await server.run({
+      plugins: this.plugins,
+      options: this.options,
+      config: mergedConfig,
+      handleSetupResult
+    });
+    serverContext.serverBase = this;
+    await serverContext.hooks.onPrepare.call();
+    this.serverContext = serverContext;
     _class_private_method_get(this, _applyMiddlewares, applyMiddlewares).call(this);
     return this;
   }
   addPlugins(plugins) {
-    this.pluginManager.addPlugins(plugins);
+    this.plugins.push(...plugins);
+  }
+  get hooks() {
+    return this.serverContext.hooks;
   }
   get all() {
     return this.app.all.bind(this.app);
@@ -55,39 +70,15 @@ class ServerBase {
     return this.app.onError.bind(this.app);
   }
   constructor(options) {
-    _class_private_method_init(this, _getAppContext);
     _class_private_method_init(this, _applyMiddlewares);
+    this.plugins = [];
+    this.serverContext = null;
     this.options = options;
-    const { config, serverConfig } = options;
-    const appContext = _class_private_method_get(this, _getAppContext, getAppContext).call(this);
-    this.appContext = appContext;
-    this.pluginManager = new PluginManager({
-      cliConfig: config,
-      appContext,
-      serverConfig
-    });
     this.app = new Hono();
   }
 }
-function getAppContext() {
-  const { appContext: context, pwd, routes, metaName } = this.options;
-  const appContext = {
-    routes,
-    middlewares: [],
-    appDirectory: (context === null || context === void 0 ? void 0 : context.appDirectory) || "",
-    apiDirectory: context === null || context === void 0 ? void 0 : context.apiDirectory,
-    internalDirectory: (context === null || context === void 0 ? void 0 : context.internalDirectory) || "",
-    lambdaDirectory: context === null || context === void 0 ? void 0 : context.lambdaDirectory,
-    sharedDirectory: (context === null || context === void 0 ? void 0 : context.sharedDirectory) || "",
-    distDirectory: pwd,
-    plugins: [],
-    metaName: metaName || "modern-js",
-    serverBase: this
-  };
-  return createContext(appContext);
-}
 function applyMiddlewares() {
-  const { middlewares } = this.appContext.get();
+  const { middlewares } = this.serverContext;
   const preMiddlewares = [];
   const defaultMiddlewares = [];
   const postMiddlewares = [];
@@ -145,8 +136,8 @@ function createServerBase(options) {
   if (options == null) {
     throw new Error("can not start server without options");
   }
-  const server = new ServerBase(options);
-  return server;
+  const server2 = new ServerBase(options);
+  return server2;
 }
 export {
   ServerBase,

package/dist/esm-node/types/index.js

@@ -1,4 +1,4 @@
 export * from "./config";
-export * from "./plugin";
+export * from "./plugins";
 export * from "./render";
 export * from "./server";

package/dist/esm-node/types/plugins/index.js

@@ -0,0 +1,2 @@
+export * from "./new";
+export * from "./old";

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

@@ -9,4 +9,10 @@ type Handler = (req: NodeRequest, res: NodeResponse) => void | 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;
+/**
+ * Because we are not sure how use devServer.before and devServer.after, we add a new function to handle the mock middleware
+ * And we supose mock handler always process the res directly
+ * So we need to set the context.finalized = true and resolve the promise
+ */
+export declare const connectMockMid2HonoMid: (handler: ConnectMiddleware) => Middleware;
 export {};

package/dist/types/adapters/node/index.d.ts

@@ -1,4 +1,4 @@
-export { httpCallBack2HonoMid, connectMid2HonoMid } from './hono';
+export { httpCallBack2HonoMid, connectMid2HonoMid, connectMockMid2HonoMid, } from './hono';
 export type { ServerNodeContext, ServerNodeMiddleware } from './hono';
 export { createNodeServer, sendResponse, createWebRequest, writeReadableStreamToWritable, } from './node';
 export { serverStaticPlugin, injectResourcePlugin, getHtmlTemplates, getServerManifest, injectNodeSeverPlugin, injectRscManifestPlugin, } from './plugins';

package/dist/types/adapters/node/plugins/nodeServer.d.ts

@@ -1,4 +1,6 @@
-import type { NodeServer, ServerPlugin } from '../../../types';
+/// <reference types="node" />
+import type { Server as NodeServer } from 'node:http';
+import type { ServerPluginLegacy } from '../../../types';
 export declare const injectNodeSeverPlugin: ({ nodeServer, }: {
     nodeServer: NodeServer;
-}) => ServerPlugin;
+}) => ServerPluginLegacy;

package/dist/types/adapters/node/plugins/resource.d.ts

@@ -1,5 +1,5 @@
 import type { Logger, ServerRoute } from '@modern-js/types';
-import type { Middleware, ServerEnv, ServerManifest, ServerPlugin } from '../../../types';
+import type { Middleware, ServerEnv, ServerManifest, ServerPluginLegacy } from '../../../types';
 export declare function getHtmlTemplates(pwd: string, routes: ServerRoute[]): Promise<Record<string, string>>;
 export declare function injectTemplates(pwd: string, routes?: ServerRoute[], htmlTemplatePromise?: ReturnType<typeof getHtmlTemplates>): Middleware<ServerEnv>;
 export declare function getServerManifest(pwd: string, routes: ServerRoute[], logger: Logger): Promise<ServerManifest>;
@@ -7,5 +7,5 @@ export declare function injectServerManifest(pwd: string, routes?: ServerRoute[]
 export declare function getRscServerManifest(pwd: string): Promise<any>;
 export declare function getClientManifest(pwd: string): Promise<any>;
 export declare function getRscSSRManifest(pwd: string): Promise<any>;
-export declare const injectRscManifestPlugin: () => ServerPlugin;
-export declare const injectResourcePlugin: () => ServerPlugin;
+export declare const injectRscManifestPlugin: () => ServerPluginLegacy;
+export declare const injectResourcePlugin: () => ServerPluginLegacy;

package/dist/types/adapters/node/plugins/static.d.ts

@@ -1,6 +1,6 @@
 import type { ServerRoute } from '@modern-js/types';
-import type { HtmlNormalizedConfig, Middleware, OutputNormalizedConfig, ServerPlugin } from '../../../types';
-export declare const serverStaticPlugin: () => ServerPlugin;
+import type { HtmlNormalizedConfig, Middleware, OutputNormalizedConfig, ServerPluginLegacy } from '../../../types';
+export declare const serverStaticPlugin: () => ServerPluginLegacy;
 export type PublicMiddlwareOptions = {
     pwd: string;
     routes: ServerRoute[];

package/dist/types/index.d.ts

@@ -2,11 +2,10 @@ export { createErrorHtml, onError, ErrorDigest } from './utils';
 export { AGGRED_DIR } from './constants';
 export type { ServerBase, ServerBaseOptions } from './serverBase';
 export { createServerBase } from './serverBase';
-export { PluginManager, type PluginManagerOptions } from './pluginManager';
 export type { Middleware, Context, Next, HonoRequest as InternalRequest, ServerEnv, ServerManifest, ServerLoaderBundle, } from './types';
 export { getLoaderCtx } from './helper';
 export * from './plugins';
-export * from './types/plugin';
+export * from './types/plugins';
 export * from './types/render';
 export * from '@modern-js/plugin';
 export * from './types/config';

package/dist/types/plugins/compat/hooks.d.ts

@@ -0,0 +1,8 @@
+import type { InternalServerContext } from '@modern-js/plugin-v2';
+import type { ServerPluginExtends } from '../../types';
+/**
+ * old plugin useHookRunners function result
+ */
+export declare function getHookRunners(context: InternalServerContext<ServerPluginExtends>): Record<string, any>;
+export declare function transformHookRunner(hookRunnerName: string): string;
+export declare function handleSetupResult(setupResult: Record<string, (...args: any) => any>, api: Record<string, any>): void;

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

@@ -0,0 +1,3 @@
+import type { ServerPlugin } from '../../types';
+export { handleSetupResult } from './hooks';
+export declare const compatPlugin: () => ServerPlugin;

package/dist/types/plugins/customServer/index.d.ts

@@ -1,12 +1,12 @@
 import type { ServerRoute, UnstableMiddleware } from '@modern-js/types';
 import type { ServerNodeEnv } from '../../adapters/node/hono';
 import type { ServerBase } from '../../serverBase';
-import type { Middleware, ServerEnv, ServerHookRunner } from '../../types';
+import type { Middleware, ServerEnv, ServerPluginHooks } from '../../types';
 export declare class CustomServer {
-    private runner;
+    private hooks;
     private serverMiddlewarePromise;
     private serverBase;
-    constructor(runner: ServerHookRunner, serverBase: ServerBase, pwd: string);
+    constructor(hooks: ServerPluginHooks, serverBase: ServerBase, pwd: string);
     getHookMiddleware(entryName: string, routes: ServerRoute[]): Middleware<ServerEnv>;
     getServerMiddleware(renderMiddlewares?: Middleware<ServerNodeEnv & ServerEnv>[]): Promise<Middleware<ServerNodeEnv & ServerEnv> | Array<Middleware<ServerNodeEnv & ServerEnv>> | undefined>;
 }

package/dist/types/plugins/default.d.ts

@@ -1,7 +1,7 @@
 import type { Logger } from '@modern-js/types';
-import type { ServerPlugin } from '../types';
+import type { ServerPlugin, ServerPluginLegacy } from '../types';
 import { type InjectRenderHandlerOptions } from './render';
 export type CreateDefaultPluginsOptions = InjectRenderHandlerOptions & {
     logger?: Logger | false;
 };
-export declare function createDefaultPlugins(options?: CreateDefaultPluginsOptions): ServerPlugin[];
+export declare function createDefaultPlugins(options?: CreateDefaultPluginsOptions): (ServerPluginLegacy | ServerPlugin)[];

package/dist/types/plugins/favicon.d.ts

@@ -1,2 +1,2 @@
-import type { ServerPlugin } from '../types';
-export declare const faviconPlugin: () => ServerPlugin;
+import type { ServerPluginLegacy } from '../types';
+export declare const faviconPlugin: () => ServerPluginLegacy;

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

@@ -4,3 +4,4 @@ export { injectServerTiming, injectloggerPlugin } from './monitors';
 export { processedByPlugin } from './processedBy';
 export { logPlugin } from './log';
 export { createDefaultPlugins, type CreateDefaultPluginsOptions, } from './default';
+export { compatPlugin, handleSetupResult } from './compat';

package/dist/types/plugins/log.d.ts

@@ -1,2 +1,2 @@
-import type { ServerPlugin } from '../types';
-export declare const logPlugin: () => ServerPlugin;
+import type { ServerPluginLegacy } from '../types';
+export declare const logPlugin: () => ServerPluginLegacy;

package/dist/types/plugins/monitors.d.ts

@@ -1,6 +1,6 @@
 import type { Logger } from '@modern-js/types';
-import type { Context, Next, ServerEnv, ServerPlugin } from '../types';
-export declare const initMonitorsPlugin: () => ServerPlugin;
-export declare const injectloggerPlugin: (inputLogger?: Logger) => ServerPlugin;
-export declare const injectServerTiming: () => ServerPlugin;
+import type { Context, Next, ServerEnv, ServerPluginLegacy } from '../types';
+export declare const initMonitorsPlugin: () => ServerPluginLegacy;
+export declare const injectloggerPlugin: (inputLogger?: Logger) => ServerPluginLegacy;
+export declare const injectServerTiming: () => ServerPluginLegacy;
 export declare function requestLatencyMiddleware(): (c: Context<ServerEnv>, next: Next) => Promise<void>;

package/dist/types/plugins/processedBy.d.ts

@@ -1,2 +1,2 @@
-import type { ServerPlugin } from '../types';
-export declare const processedByPlugin: () => ServerPlugin;
+import type { ServerPluginLegacy } from '../types';
+export declare const processedByPlugin: () => ServerPluginLegacy;

package/dist/types/plugins/render/index.d.ts

@@ -1,3 +1,3 @@
-import type { ServerPlugin } from '../../types';
+import type { ServerPluginLegacy } from '../../types';
 export * from './inject';
-export declare const renderPlugin: () => ServerPlugin;
+export declare const renderPlugin: () => ServerPluginLegacy;

package/dist/types/plugins/render/inject.d.ts

@@ -1,7 +1,7 @@
-import type { CacheConfig, GetRenderHandlerOptions, Render, ServerPlugin } from '../../types';
+import type { CacheConfig, GetRenderHandlerOptions, Render, ServerPluginLegacy } from '../../types';
 export interface InjectRenderHandlerOptions {
     staticGenerate?: boolean;
     cacheConfig?: CacheConfig;
 }
-export declare const injectRenderHandlerPlugin: ({ staticGenerate, cacheConfig, }: InjectRenderHandlerOptions) => ServerPlugin;
+export declare const injectRenderHandlerPlugin: ({ staticGenerate, cacheConfig, }: InjectRenderHandlerOptions) => ServerPluginLegacy;
 export declare function getRenderHandler({ pwd, routes, config, cacheConfig, metaName, staticGenerate, onFallback, }: GetRenderHandlerOptions): Promise<Render>;

package/dist/types/plugins/route.d.ts

@@ -1,2 +1,2 @@
-import type { ServerPlugin } from '../types';
-export declare const injectRoutePlugin: () => ServerPlugin;
+import type { ServerPluginLegacy } from '../types';
+export declare const injectRoutePlugin: () => ServerPluginLegacy;

package/dist/types/serverBase.d.ts

@@ -1,44 +1,33 @@
-import type { ServerRoute } from '@modern-js/types';
+import { type ServerCreateOptions } from '@modern-js/plugin-v2/server';
 import { Hono } from 'hono';
-import type { Env, ServerConfig, ServerHookRunner, ServerPlugin } from './types';
+import type { Env, ServerConfig, ServerPlugin, ServerPluginHooks, ServerPluginLegacy } from './types';
 import type { CliConfig } from './types/config';
 declare module '@modern-js/types' {
     interface ISAppContext {
         serverBase?: ServerBase;
     }
 }
-export type ServerBaseOptions = {
+export interface ServerBaseOptions extends ServerCreateOptions {
     /** server working directory, and then also dist directory */
-    pwd: string;
     config: CliConfig;
     serverConfig?: ServerConfig;
-    metaName?: string;
-    routes?: ServerRoute[];
-    appContext: {
-        internalDirectory?: string;
-        appDirectory?: string;
-        sharedDirectory?: string;
-        apiDirectory?: string;
-        lambdaDirectory?: string;
-    };
     runMode?: 'apiOnly' | 'ssrOnly' | 'webOnly';
-};
+}
 export declare class ServerBase<E extends Env = any> {
     #private;
     options: ServerBaseOptions;
-    runner: ServerHookRunner;
     private app;
-    private appContext;
-    private pluginManager;
+    private plugins;
+    private serverContext;
     constructor(options: ServerBaseOptions);
     /**
-     * 初始化顺序
-     * - 初始化 pluginManager;
-     * - 执行 runner.prepare;
-     * - 应用 middlewares
+     * Order
+     * - server runner
+     * - apply middlewares
      */
     init(): Promise<this>;
-    addPlugins(plugins: ServerPlugin[]): void;
+    addPlugins(plugins: (ServerPlugin | ServerPluginLegacy)[]): void;
+    get hooks(): ServerPluginHooks;
     get all(): import("hono/types").HandlerInterface<E, "all", {}, "/">;
     get use(): import("hono/types").MiddlewareHandlerInterface<E, {}, "/">;
     get get(): import("hono/types").HandlerInterface<E, "get", {}, "/">;

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

@@ -1,4 +1,4 @@
 export * from './config';
-export * from './plugin';
+export * from './plugins';
 export * from './render';
 export * from './server';

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

@@ -0,0 +1,80 @@
+/// <reference types="node" />
+import type { IncomingMessage, Server as NodeServer, ServerResponse } from 'http';
+import type { CacheOption, Container, HttpMethodDecider, Logger, Metrics, MiddlewareContext, Reporter, ServerRoute, UnstableMiddleware } from '@modern-js/types';
+import type { MiddlewareHandler } from 'hono';
+import type { UserConfig } from '../config';
+import type { Render } from '../render';
+import type { ServerPlugin } from './new';
+import type { ServerPluginLegacy } from './old';
+export type { FileChangeEvent, ResetEvent } from '@modern-js/plugin-v2';
+export type FallbackReason = 'error' | 'header' | 'query';
+export type FallbackInput = {
+    reason: FallbackReason;
+    error: unknown;
+    logger: Logger;
+    metrics?: Metrics;
+    reporter?: Reporter;
+};
+export type OnFallback = (reason: FallbackReason, utils: {
+    logger: Logger;
+    metrics?: Metrics;
+    reporter?: Reporter;
+}, error?: unknown) => Promise<void>;
+export type APIServerStartInput = {
+    pwd: string;
+    prefix?: string;
+    httpMethodDecider?: HttpMethodDecider;
+    config?: {
+        middleware?: Array<any>;
+    };
+    render?: Render | null;
+};
+export type WebServerStartInput = {
+    pwd: string;
+    config: Record<string, any>;
+};
+export type WebAdapter = (ctx: MiddlewareContext) => void | Promise<void>;
+/** Plugin Api */
+type MiddlewareOrder = 'pre' | 'post' | 'default';
+export type Middleware = {
+    name: string;
+    path?: string;
+    method?: 'options' | 'get' | 'post' | 'put' | 'delete' | 'patch' | 'all';
+    handler: MiddlewareHandler | MiddlewareHandler[];
+    before?: Array<Middleware['name']>;
+    order?: MiddlewareOrder;
+};
+export interface GetRenderHandlerOptions {
+    pwd: string;
+    routes: ServerRoute[];
+    config: UserConfig;
+    onFallback?: OnFallback;
+    cacheConfig?: CacheConfig;
+    staticGenerate?: boolean;
+    metaName?: string;
+}
+declare module '@modern-js/types' {
+    interface ISAppContext {
+        middlewares: Middleware[];
+        metaName: string;
+        getRenderOptions?: GetRenderHandlerOptions;
+        render?: Render;
+        routes?: ServerRoute[];
+        nodeServer?: NodeServer;
+    }
+}
+export type NodeRequest = IncomingMessage;
+export type NodeResponse = ServerResponse;
+export type CacheConfig = {
+    strategy: CacheOption;
+    container?: Container;
+};
+type RenderMiddleware = UnstableMiddleware;
+export interface RenderConfig {
+    cache?: CacheConfig;
+    middleware?: RenderMiddleware[];
+}
+export type ServerConfig = {
+    render?: RenderConfig;
+    plugins?: (ServerPlugin | ServerPluginLegacy)[];
+} & UserConfig;

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

@@ -0,0 +1,3 @@
+export * from './new';
+export * from './old';
+export type { ServerConfig, CacheConfig, OnFallback, FallbackReason, GetRenderHandlerOptions, NodeRequest, NodeResponse, FileChangeEvent, FallbackInput, WebServerStartInput, APIServerStartInput, } from './base';

package/dist/types/types/plugins/new.d.ts

@@ -0,0 +1,34 @@
+import type { AsyncHook, AsyncPipelineHook, ServerContext as BaseServerContext, ServerPlugin as BaseServerPlugin, ServerPluginExtends as BaseServerPluginExtends } from '@modern-js/plugin-v2';
+import type { Hooks } from '@modern-js/plugin-v2/server';
+import type { AfterMatchContext, AfterRenderContext, AfterStreamingRenderContext, ISAppContext, UnstableMiddleware } from '@modern-js/types';
+import type { MiddlewareHandler } from 'hono';
+import type { Middleware } from './base';
+import type { APIServerStartInput, FallbackInput, ServerConfig, WebAdapter, WebServerStartInput } from './base';
+export type FallbackFn = (input: FallbackInput) => Promise<FallbackInput>;
+export type PrepareWebServerFn = (input: WebServerStartInput) => Promise<WebAdapter | Array<UnstableMiddleware> | null>;
+export type PrepareApiServerFn = (input: APIServerStartInput) => Promise<MiddlewareHandler>;
+export type AfterMatchFn = (ctx: AfterMatchContext) => Promise<any>;
+export type AfterRenderFn = (ctx: AfterRenderContext) => Promise<any>;
+export type AfterStreamingRenderContextFn = (ctx: AfterStreamingRenderContext) => Promise<AfterStreamingRenderContext>;
+export interface ServerPluginExtends extends BaseServerPluginExtends {
+    config: ServerConfig;
+    extendContext: {
+        middlewares: Middleware[];
+    };
+    extendApi: {
+        setAppContext: (c: ISAppContext) => void;
+        useAppContext: () => ISAppContext;
+        useConfigContext: () => ServerConfig;
+    };
+    extendHooks: {
+        prepareWebServer: AsyncPipelineHook<PrepareWebServerFn>;
+        fallback: AsyncHook<FallbackFn>;
+        prepareApiServer: AsyncPipelineHook<PrepareApiServerFn>;
+        afterMatch: AsyncPipelineHook<AfterMatchFn>;
+        afterRender: AsyncPipelineHook<AfterRenderFn>;
+        afterStreamingRender: AsyncPipelineHook<AfterStreamingRenderContextFn>;
+    };
+}
+export type ServerPlugin = BaseServerPlugin<ServerPluginExtends>;
+export type ServerContext = BaseServerContext<ServerPluginExtends> & ServerPluginExtends['extendContext'];
+export type ServerPluginHooks = Hooks<ServerPluginExtends> & ServerPluginExtends['extendHooks'];

package/dist/types/types/plugins/old.d.ts

@@ -0,0 +1,56 @@
+import type { AsyncPipeline, AsyncSetup, AsyncWaterfall, AsyncWorkflow, CommonAPI, ParallelWorkflow, PluginOptions } from '@modern-js/plugin';
+import type { AfterMatchContext, AfterRenderContext, AfterStreamingRenderContext, ISAppContext, UnstableMiddleware } from '@modern-js/types';
+import type { MiddlewareHandler } from 'hono';
+import type { APIServerStartInput, FallbackInput, ResetEvent, ServerConfig, WebAdapter, WebServerStartInput } from './base';
+export interface ServerHooks {
+    /**
+     * @deprecated
+     *
+     * deprecate it next major version
+     */
+    config: AsyncWaterfall<ServerConfig>;
+    prepare: AsyncWaterfall<void>;
+    reset: AsyncWorkflow<{
+        event: ResetEvent;
+    }, void>;
+    /**
+     * @deprecated
+     *
+     * deprecate it next major version
+     * */
+    prepareWebServer: AsyncPipeline<WebServerStartInput, WebAdapter | Array<UnstableMiddleware> | null>;
+    /**
+     * @deprecated
+     *
+     * deprecate it when server runtime entry refactor
+     *
+     */
+    fallback: ParallelWorkflow<FallbackInput>;
+    prepareApiServer: AsyncPipeline<APIServerStartInput, MiddlewareHandler>;
+    /**
+     * @deprecated
+     *
+     * deprecate it next major version
+     */
+    afterMatch: AsyncPipeline<AfterMatchContext, any>;
+    /**
+     * @deprecated
+     *
+     * deprecate it next major version
+     */
+    afterRender: AsyncPipeline<AfterRenderContext, any>;
+    /**
+     * @deprecated
+     *
+     * deprecate it next major version
+     * */
+    afterStreamingRender: AsyncPipeline<AfterStreamingRenderContext, string>;
+}
+export type ServerPluginAPI = {
+    setAppContext: (c: ISAppContext) => void;
+    useAppContext: () => ISAppContext;
+    useConfigContext: () => ServerConfig;
+};
+export type PluginAPI = ServerPluginAPI & CommonAPI<ServerHooks>;
+/**old server plugin. */
+export type ServerPluginLegacy = PluginOptions<ServerHooks, AsyncSetup<ServerHooks, PluginAPI>>;

package/package.json

@@ -15,7 +15,7 @@
     "modern",
     "modern.js"
   ],
-  "version": "2.65.4",
+  "version": "2.65.6-alpha.0",
   "jsnext:source": "./src/index.ts",
   "types": "./dist/types/index.d.ts",
   "main": "./dist/cjs/index.js",
@@ -53,9 +53,10 @@
     "flatted": "^3.2.9",
     "hono": "^3.12.2",
     "ts-deepmerge": "7.0.2",
-    "@modern-js/plugin": "2.65.4",
-    "@modern-js/runtime-utils": "2.65.4",
-    "@modern-js/utils": "2.65.4"
+    "@modern-js/plugin": "2.65.5",
+    "@modern-js/runtime-utils": "2.65.5",
+    "@modern-js/plugin-v2": "2.65.6-alpha.0",
+    "@modern-js/utils": "2.65.5"
   },
   "devDependencies": {
     "@types/jest": "^29",
@@ -65,15 +66,14 @@
     "jest": "^29",
     "ts-jest": "^29.1.0",
     "typescript": "^5",
-    "@modern-js/types": "2.65.4",
-    "@scripts/build": "2.65.4",
-    "@scripts/jest-config": "2.65.4"
+    "@modern-js/types": "2.65.5",
+    "@scripts/build": "2.65.5",
+    "@scripts/jest-config": "2.65.5"
   },
   "sideEffects": false,
   "publishConfig": {
     "registry": "https://registry.npmjs.org/",
-    "access": "public",
-    "provenance": true
+    "access": "public"
   },
   "scripts": {
     "new": "modern-lib new",