@modern-js/server 0.0.0-plugins-202111301002 → 0.0.0-runtime-2021112193858

package/dist/js/node/server/modern-server.js

@@ -5,6 +5,8 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.ModernServer = void 0;
 
+var _http = require("http");
+
 var _util = _interopRequireDefault(require("util"));
 
 var _path = _interopRequireDefault(require("path"));
@@ -33,7 +35,9 @@ var _context = require("../libs/context");
 
 var _constants = require("../constants");
 
-var _hookApi = require("../libs/hook-api");
+var _template = require("../libs/hook-api/template");
+
+var _route2 = require("../libs/hook-api/route");
 
 const _excluded = ["getMiddlewares"];
 
@@ -43,9 +47,9 @@ function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj &&
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
 
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
 
 function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
 
@@ -67,8 +71,9 @@ class ModernServer {
     routes,
     staticGenerate,
     logger,
-    measure
-  }, runner) {
+    metrics,
+    proxyTarget
+  }) {
     this.pwd = void 0;
     this.distDir = void 0;
     this.workDir = void 0;
@@ -76,9 +81,10 @@ class ModernServer {
     this.conf = void 0;
     this.handlers = [];
     this.presetRoutes = void 0;
-    this.logger = void 0;
-    this.measure = void 0;
     this.runner = void 0;
+    this.logger = void 0;
+    this.metrics = void 0;
+    this.proxyTarget = void 0;
     this.isDev = false;
     this.staticFileHandler = void 0;
     this.routeRenderHandler = void 0;
@@ -92,14 +98,14 @@ class ModernServer {
 
     this.isDev = Boolean(dev);
     this.pwd = pwd;
-    this.distDir = _path.default.join(pwd, config.output.path || '');
+    this.distDir = _path.default.join(pwd, config.output.path || 'dist');
     this.workDir = this.isDev ? pwd : this.distDir;
     this.conf = config;
-    this.runner = runner;
     this.logger = logger;
-    this.measure = measure;
+    this.metrics = metrics;
     this.router = new _route.RouteMatchManager();
     this.presetRoutes = routes;
+    this.proxyTarget = proxyTarget;
 
     if (staticGenerate) {
       this.staticGenerate = staticGenerate;
@@ -114,9 +120,10 @@ class ModernServer {
   } // server prepare
 
 
-  async init() {
+  async init(runner) {
     var _conf$bff;
 
+    this.runner = runner;
     const {
       distDir,
       isDev,
@@ -181,20 +188,10 @@ class ModernServer {
 
   close() {
     reader.close();
-  } // warmup ssr function
-
-
-  warmupSSRBundle() {
-    const {
-      distDir
-    } = this;
-    const bundles = this.router.getBundles();
-    bundles.forEach(bundle => {
-      const filepath = _path.default.join(distDir, bundle); // if error, just throw and let process die
-
+  }
 
-      require(filepath);
-    });
+  async createHTTPServer(handler) {
+    return (0, _http.createServer)(handler);
   } // read route spec from route.json
 
 
@@ -229,20 +226,8 @@ class ModernServer {
   async prepareFrameHandler() {
     const {
       workDir,
-      runner,
-      conf
-    } = this; // inner tool, gather user inject
-
-    let userAPIExt = [];
-    let userWebExt = [];
-
-    if (!conf.server.disableUserExtension) {
-      ({
-        api: userAPIExt,
-        web: userWebExt
-      } = (0, _serverUtils.gather)(workDir));
-    } // server hook, gather plugin inject
-
+      runner
+    } = this; // server hook, gather plugin inject
 
     const _createMiddlewareColl = (0, _serverUtils.createMiddlewareCollecter)(),
           {
@@ -262,16 +247,21 @@ class ModernServer {
 
 
     if (await _utils.fs.pathExists(_path.default.join(serverDir))) {
-      const webExtension = (0, _utils2.mergeExtension)(pluginWebExt, userWebExt);
+      const webExtension = (0, _utils2.mergeExtension)(pluginWebExt);
       this.frameWebHandler = await this.prepareWebHandler(webExtension);
     }
 
     if (_utils.fs.existsSync(apiDir)) {
       const mode = _utils.fs.existsSync(_path.default.join(apiDir, _constants.AGGRED_DIR.lambda)) ? _constants.ApiServerMode.frame : _constants.ApiServerMode.func; // if use lambda/, mean framework style of writing, then discard user extension
 
-      const apiExtension = (0, _utils2.mergeExtension)(pluginAPIExt, mode === _constants.ApiServerMode.frame ? [] : userAPIExt);
+      const apiExtension = (0, _utils2.mergeExtension)(pluginAPIExt);
       this.frameAPIHandler = await this.prepareAPIHandler(mode, apiExtension);
     }
+  } // Todo
+
+
+  async proxy() {
+    return null;
   }
   /* —————————————————————— function will be overwrite —————————————————————— */
 
@@ -303,7 +293,7 @@ class ModernServer {
       pwd: workDir,
       mode,
       config: extension,
-      prefix
+      prefix: Array.isArray(prefix) ? prefix[0] : prefix
     }, {
       onLast: () => null
     });
@@ -313,34 +303,55 @@ class ModernServer {
     return routes;
   }
 
+  async emitRouteHook(eventName, input) {
+    return this.runner[eventName](input, {
+      onLast: _utils2.noop
+    });
+  } // warmup ssr function
+
+
+  warmupSSRBundle() {
+    const {
+      distDir
+    } = this;
+    const bundles = this.router.getBundles();
+    bundles.forEach(bundle => {
+      const filepath = _path.default.join(distDir, bundle); // if error, just throw and let process die
+
+
+      require(filepath);
+    });
+  }
+
   async preServerInit() {
     const {
-      conf
+      conf,
+      runner
     } = this;
-    const preMiddleware = await this.runner.preServerInit(conf);
-    preMiddleware.forEach(mid => {
+    const preMiddleware = await runner.preServerInit(conf);
+    preMiddleware.flat().forEach(mid => {
       this.addHandler(mid);
     });
   }
 
-  prepareFavicons(favicon, faviconByEntries) {
-    const faviconNames = [];
+  async handleAPI(context) {
+    const {
+      req,
+      res
+    } = context;
 
-    if (favicon) {
-      faviconNames.push(favicon.substring(favicon.lastIndexOf('/') + 1));
+    if (!this.frameAPIHandler) {
+      throw new Error('can not found api hanlder');
     }
 
-    if (faviconByEntries) {
-      Object.keys(faviconByEntries).forEach(f => {
-        const curFavicon = faviconByEntries[f];
+    await this.frameAPIHandler(req, res);
+  }
 
-        if (curFavicon) {
-          faviconNames.push(curFavicon.substring(curFavicon.lastIndexOf('/') + 1));
-        }
-      });
-    }
+  async handleWeb(context, route) {
+    return this.routeRenderHandler(context, route);
+  }
 
-    return faviconNames;
+  verifyMatch(_c, _m) {// empty
   }
   /* —————————————————————— private function —————————————————————— */
   // handler route.json, include api / csr / ssr
@@ -351,25 +362,43 @@ class ModernServer {
     const {
       req,
       res
-    } = context; // match routes in the route spec
+    } = context;
+    await this.emitRouteHook('beforeMatch', {
+      context
+    }); // match routes in the route spec
 
     const matched = this.router.match(context.url);
 
     if (!matched) {
       this.render404(context);
       return;
+    } else {
+      this.verifyMatch(context, matched);
     }
 
-    const route = matched.generate();
-    const params = matched.parseURLParams(context.url);
+    if (res.headersSent) {
+      return;
+    }
+
+    const routeAPI = (0, _route2.createRouteAPI)(matched, this.router);
+    await this.emitRouteHook('afterMatch', {
+      context,
+      routeAPI
+    });
+
+    if (res.headersSent) {
+      return;
+    }
+
+    const {
+      current
+    } = routeAPI;
+    const route = current.generate();
+    const params = current.parseURLParams(context.url);
     context.setParams(params); // route is api service
 
     if (route.isApi) {
-      if (!this.frameAPIHandler) {
-        throw new Error('can not found api hanlder');
-      }
-
-      await this.frameAPIHandler(req, res);
+      this.handleAPI(context);
       return;
     }
 
@@ -382,7 +411,13 @@ class ModernServer {
       return;
     }
 
-    const file = await this.routeRenderHandler(context, route);
+    if (route.entryName) {
+      await this.emitRouteHook('beforeRender', {
+        context
+      });
+    }
+
+    const file = await this.handleWeb(context, route);
 
     if (!file) {
       this.render404(context);
@@ -399,12 +434,10 @@ class ModernServer {
     let response = file.content;
 
     if (route.entryName) {
-      const templateAPI = (0, _hookApi.createTemplateAPI)(file.content.toString());
-      await this.runner.afterRender({
+      const templateAPI = (0, _template.createTemplateAPI)(file.content.toString());
+      await this.emitRouteHook('afterRender', {
         context,
         templateAPI
-      }, {
-        onLast: _utils2.noop
       });
       await this.injectMicroFE(context, templateAPI);
       response = templateAPI.get();
@@ -524,7 +557,7 @@ class ModernServer {
     res.statusCode = 200;
     const context = (0, _context.createContext)(req, res, {
       logger: this.logger,
-      measure: this.measure
+      metrics: this.metrics
     });
 
     try {
@@ -572,6 +605,26 @@ class ModernServer {
     res.end((0, _utils2.createErrorDocument)(status, text));
   }
 
+  prepareFavicons(favicon, faviconByEntries) {
+    const faviconNames = [];
+
+    if (favicon) {
+      faviconNames.push(favicon.substring(favicon.lastIndexOf('/') + 1));
+    }
+
+    if (faviconByEntries) {
+      Object.keys(faviconByEntries).forEach(f => {
+        const curFavicon = faviconByEntries[f];
+
+        if (curFavicon) {
+          faviconNames.push(curFavicon.substring(curFavicon.lastIndexOf('/') + 1));
+        }
+      });
+    }
+
+    return faviconNames;
+  }
+
 }
 /* eslint-enable max-lines */
 

package/dist/js/node/utils.js

@@ -3,12 +3,13 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+exports.applyMixins = applyMixins;
 exports.toMessage = exports.noop = exports.mergeExtension = exports.createErrorDocument = void 0;
 
-const mergeExtension = (users, plugins) => {
+const mergeExtension = users => {
   const output = [];
   return {
-    middleware: output.concat(users).concat(plugins)
+    middleware: output.concat(users)
   };
 };
 
@@ -63,6 +64,15 @@ const createErrorDocument = (status, text) => {
   </body>
   </html>
   `;
-};
+}; // This can live anywhere in your codebase:
+
+
+exports.createErrorDocument = createErrorDocument;
 
-exports.createErrorDocument = createErrorDocument;
+function applyMixins(derivedCtor, constructors) {
+  constructors.forEach(baseCtor => {
+    Object.getOwnPropertyNames(baseCtor.prototype).forEach(name => {
+      Object.defineProperty(derivedCtor.prototype, name, Object.getOwnPropertyDescriptor(baseCtor.prototype, name) || Object.create(null));
+    });
+  });
+}

package/dist/types/libs/context/context.d.ts

@@ -2,7 +2,7 @@
 import { IncomingMessage, ServerResponse } from 'http';
 import { URL } from 'url';
 import qs from 'querystring';
-import type { ModernServerContext as ModernServerContextInterface, Measure, Logger } from '@modern-js/types/server';
+import type { ModernServerContext as ModernServerContextInterface, Metrics, Logger } from '@modern-js/types/server';
 export declare class ModernServerContext implements ModernServerContextInterface {
   /**
    * http request
@@ -19,18 +19,18 @@ export declare class ModernServerContext implements ModernServerContextInterface
 
   params: Record<string, string>;
   logger: Logger;
-  measure?: Measure;
+  metrics?: Metrics;
   constructor(req: IncomingMessage, res: ServerResponse, {
     logger,
-    measure
+    metrics
   }: {
     logger: Logger;
-    measure: Measure;
+    metrics: Metrics;
   });
+  private bind;
   setParams(params: Record<string, string>): void;
   getReqHeader(key: string): string | string[];
   get headers(): import("http").IncomingHttpHeaders;
-  set headers(val: import("http").IncomingHttpHeaders);
   get method(): string;
   get url(): string;
   set url(val: string);

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

@@ -1,11 +1,11 @@
 import { IncomingMessage, ServerResponse } from 'http';
-import { Measure, Logger } from '../../type';
+import { Metrics, Logger } from '../../type';
 import { ModernServerContext } from './context';
 export declare const createContext: (req: IncomingMessage, res: ServerResponse, {
   logger,
-  measure
+  metrics
 }: {
   logger: Logger;
-  measure: Measure;
+  metrics: Metrics;
 }) => ModernServerContext;
 export { ModernServerContext };

package/dist/types/libs/hook-api/route.d.ts

@@ -0,0 +1,13 @@
+import { RouteMatchManager, RouteMatcher } from '../route';
+
+declare class RouteAPI {
+  private readonly router;
+  private current;
+  constructor(matched: RouteMatcher, router: RouteMatchManager);
+  cur(): import("../route").ModernRoute;
+  get(entryName: string): import("../route").ModernRoute | null;
+  use(entryName: string): boolean;
+}
+
+export declare const createRouteAPI: (matched: RouteMatcher, router: RouteMatchManager) => RouteAPI;
+export {};

package/dist/types/libs/metrics.d.ts

@@ -0,0 +1,3 @@
+import { Metrics } from "../type.d";
+declare const metrics: Metrics;
+export { metrics };

package/dist/types/libs/render/type.d.ts

@@ -1,7 +1,7 @@
 /// <reference types="node" />
 /// <reference types="react" />
 import { IncomingHttpHeaders } from 'http';
-import { Measure, Logger } from '../../type';
+import { Metrics, Logger } from '../../type';
 declare type MetaKeyMap = {
   header?: string[];
   query?: string[];
@@ -40,7 +40,7 @@ export declare type SSRServerContext = {
   template: string;
   entryName: string;
   logger: Logger;
-  measure?: Measure;
+  metrics?: Metrics;
   loadableManifest?: string;
   cacheConfig?: CacheConfig;
   staticGenerate?: boolean;

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

@@ -8,6 +8,7 @@ export declare class RouteMatchManager {
   private best;
   reset(specs: ModernRouteInterface[]): void;
   match(pathname: string): RouteMatcher | undefined;
+  matchEntry(entryname: string): RouteMatcher | undefined;
   getBundles(): (string | undefined)[];
 }
 export type { ModernRouteInterface, RouteMatcher, ModernRoute };

package/dist/types/libs/route/matcher.d.ts

@@ -10,5 +10,6 @@ export declare class RouteMatcher {
   parseURLParams(pathname: string): Record<string, string>;
   matchLength(pathname: string): number | null;
   matchUrlPath(requestUrl: string): boolean;
+  matchEntry(entryName: string): boolean;
   private setupUrlPath;
 }

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

@@ -1,13 +1,5 @@
-export interface ModernRouteInterface {
-  entryName: string;
-  urlPath: string;
-  entryPath?: string;
-  isSPA?: boolean;
-  isSSR?: boolean;
-  isApi?: boolean;
-  bundle?: string;
-  enableModernMode?: boolean;
-}
+import { ServerRoute as ModernRouteInterface } from '@modern-js/types';
+export type { ModernRouteInterface };
 export declare class ModernRoute implements ModernRouteInterface {
   entryName: string;
   urlPath: string;

package/dist/types/server/dev-server/dev-server-split.d.ts

@@ -0,0 +1,15 @@
+import type { APIServerStartInput } from '@modern-js/server-plugin';
+import { ModernDevServer } from './dev-server';
+import { mergeExtension } from "../../utils.d";
+import { ModernRouteInterface } from "../../libs/route";
+import { ApiServerMode } from "../../constants.d";
+export declare class ModernSSRDevServer extends ModernDevServer {
+  protected prepareAPIHandler(_m: ApiServerMode, _: APIServerStartInput['config']): any;
+  protected prepareWebHandler(extension: ReturnType<typeof mergeExtension>): Promise<import("@modern-js/server-plugin").Adapter>;
+  protected filterRoutes(routes: ModernRouteInterface[]): ModernRouteInterface[];
+}
+export declare class ModernAPIDevServer extends ModernDevServer {
+  protected prepareAPIHandler(mode: ApiServerMode, extension: APIServerStartInput['config']): Promise<import("@modern-js/server-plugin").Adapter>;
+  protected filterRoutes(routes: ModernRouteInterface[]): ModernRouteInterface[];
+  protected preServerInit(): Promise<void>;
+}

package/dist/types/server/{dev-server.d.ts → dev-server/dev-server.d.ts}

@@ -1,7 +1,7 @@
 /// <reference types="node" />
-import { Server } from 'http';
-import { ModernServerOptions, ServerHookRunner, ReadyOptions } from '../type';
-import { ModernServer } from './modern-server';
+import http, { Server, IncomingMessage, ServerResponse } from 'http';
+import { ModernServer } from '../modern-server';
+import { ModernServerOptions, ServerHookRunner, ReadyOptions } from "../../type.d";
 export declare class ModernDevServer extends ModernServer {
   private devProxyHandler;
   private mockHandler;
@@ -10,11 +10,12 @@ export declare class ModernDevServer extends ModernServer {
   private socketServer;
   private watcher;
   private devMiddleware;
-  constructor(options: ModernServerOptions, runner: ServerHookRunner);
-  init(): Promise<void>;
+  constructor(options: ModernServerOptions);
+  init(runner: ServerHookRunner): Promise<void>;
   ready(options?: ReadyOptions): void;
   onListening(app: Server): void;
   close(): Promise<void>;
+  createHTTPServer(handler: (req: IncomingMessage, res: ServerResponse, next?: () => void) => void): Promise<http.Server | import("https").Server>;
   private setupCompiler;
   private setupDevServerPlugin;
   private setupHooks;

package/dist/types/server/dev-server/index.d.ts

@@ -0,0 +1,2 @@
+export { ModernAPIDevServer, ModernSSRDevServer } from './dev-server-split';
+export { ModernDevServer } from './dev-server';

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

@@ -1,6 +1,6 @@
 /// <reference types="node" />
 import { IncomingMessage, ServerResponse, Server as httpServer } from 'http';
-import { ModernServerOptions, ReadyOptions } from '../type';
+import { ModernServerOptions, ReadyOptions } from "../type.d";
 export declare class Server {
   options: ModernServerOptions;
   private server;
@@ -15,4 +15,6 @@ export declare class Server {
   close(): Promise<void>;
   private createProdServer;
   private createDevServer;
+  private createHookRunner;
+  private initAppContext;
 }

package/dist/types/server/modern-server-split.d.ts

@@ -0,0 +1,26 @@
+import { APIServerStartInput } from '@modern-js/server-plugin';
+import { ModernServer } from './modern-server';
+import { mergeExtension } from "../utils.d";
+import { ModernRoute, ModernRouteInterface, RouteMatcher } from "../libs/route";
+import { ApiServerMode } from "../constants.d";
+import { ModernServerContext } from "../libs/context";
+export declare class ModernSSRServer extends ModernServer {
+  protected warmupSSRBundle(): Promise<void>;
+  protected verifyMatch(context: ModernServerContext, matched: RouteMatcher): void;
+  protected prepareAPIHandler(_m: ApiServerMode, _: APIServerStartInput['config']): any;
+  protected prepareWebHandler(extension: ReturnType<typeof mergeExtension>): Promise<import("@modern-js/server-plugin").Adapter>;
+  protected preServerInit(): Promise<void>;
+}
+export declare class ModernAPIServer extends ModernServer {
+  protected emitRouteHook(_: string, _input: any): Promise<void>;
+  protected warmupSSRBundle(): Promise<void>;
+  protected prepareWebHandler(_: ReturnType<typeof mergeExtension>): any;
+  protected prepareAPIHandler(mode: ApiServerMode, extension: APIServerStartInput['config']): Promise<import("@modern-js/server-plugin").Adapter>;
+  protected filterRoutes(routes: ModernRouteInterface[]): ModernRouteInterface[];
+  protected preServerInit(): Promise<void>;
+}
+export declare class ModernWebServer extends ModernServer {
+  protected warmupSSRBundle(): Promise<void>;
+  protected handleAPI(context: ModernServerContext): Promise<void>;
+  protected handleWeb(context: ModernServerContext, route: ModernRoute): Promise<any>;
+}

package/dist/types/server/modern-server.d.ts

@@ -1,10 +1,10 @@
 /// <reference types="node" />
 import { IncomingMessage, ServerResponse, Server } from 'http';
-import { Adapter } from '@modern-js/server-plugin';
+import { Adapter, APIServerStartInput } from '@modern-js/server-plugin';
 import type { NormalizedConfig } from '@modern-js/core';
-import { ModernServerOptions, NextFunction, ServerHookRunner, Measure, Logger, ReadyOptions } from '../type';
-import { RouteMatchManager, ModernRouteInterface } from '../libs/route';
-import { mergeExtension } from '../utils';
+import { ModernServerOptions, NextFunction, ServerHookRunner, Metrics, Logger, ReadyOptions } from "../type.d";
+import { RouteMatchManager, ModernRouteInterface, ModernRoute, RouteMatcher } from "../libs/route";
+import { mergeExtension } from "../utils.d";
 import { ModernServerContext } from "../libs/context";
 import { ApiServerMode } from "../constants.d";
 declare type ModernServerHandler = (context: ModernServerContext, next: NextFunction) => Promise<void> | void;
@@ -17,9 +17,10 @@ export declare class ModernServer {
   protected conf: NormalizedConfig;
   protected handlers: ModernServerAsyncHandler[];
   protected presetRoutes?: ModernRouteInterface[];
+  protected runner: ServerHookRunner;
   protected readonly logger: Logger;
-  protected readonly measure: Measure;
-  private readonly runner;
+  protected readonly metrics: Metrics;
+  protected readonly proxyTarget: ModernServerOptions['proxyTarget'];
   private readonly isDev;
   private staticFileHandler;
   private routeRenderHandler;
@@ -35,28 +36,35 @@ export declare class ModernServer {
     routes,
     staticGenerate,
     logger,
-    measure
-  }: ModernServerOptions, runner: ServerHookRunner);
+    metrics,
+    proxyTarget
+  }: ModernServerOptions);
   getRequestHandler(): (req: IncomingMessage, res: ServerResponse, next?: () => void) => void;
-  init(): Promise<void>;
+  init(runner: ServerHookRunner): Promise<void>;
   ready(_: ReadyOptions): void;
   onListening(_: Server): void;
   close(): void;
-  protected warmupSSRBundle(): void;
+  createHTTPServer(handler: (req: IncomingMessage, res: ServerResponse, next?: () => void) => void): Promise<Server>;
   protected readRouteSpec(): ModernRouteInterface[];
   protected addHandler(handler: ModernServerHandler): void;
   protected render404(context: ModernServerContext): void;
   protected prepareFrameHandler(): Promise<void>;
+  protected proxy(): Promise<any>;
   protected prepareWebHandler(extension: ReturnType<typeof mergeExtension>): Promise<Adapter>;
-  protected prepareAPIHandler(mode: ApiServerMode, extension: ReturnType<typeof mergeExtension>): Promise<Adapter>;
+  protected prepareAPIHandler(mode: ApiServerMode, extension: APIServerStartInput['config']): Promise<Adapter>;
   protected filterRoutes(routes: ModernRouteInterface[]): ModernRouteInterface[];
+  protected emitRouteHook(eventName: 'beforeMatch' | 'afterMatch' | 'beforeRender' | 'afterRender', input: any): Promise<any>;
+  protected warmupSSRBundle(): void;
   protected preServerInit(): Promise<void>;
-  private prepareFavicons;
+  protected handleAPI(context: ModernServerContext): Promise<void>;
+  protected handleWeb(context: ModernServerContext, route: ModernRoute): Promise<import("@/type").RenderResult | null>;
+  protected verifyMatch(_c: ModernServerContext, _m: RouteMatcher): void;
   private routeHandler;
   private injectMicroFE;
   private compose;
   private requestHandler;
   private onError;
   private renderErrorPage;
+  private prepareFavicons;
 }
 export {};