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

package/dist/esm-node/base/utils/request.js

@@ -0,0 +1,38 @@
+function parseQuery(request) {
+  const { url } = request;
+  const q = url.split("?")[1];
+  const query = {};
+  if (q) {
+    q.split("&").forEach((item) => {
+      const [key, value] = item.split("=");
+      query[key] = value;
+    });
+  }
+  return query;
+}
+function parseHeaders(request) {
+  const headersData = {};
+  request.headers.forEach((value, key) => {
+    headersData[key] = value;
+  });
+  return headersData;
+}
+function getPathname(request) {
+  const match = request.url.match(/^https?:\/\/[^/]+(\/[^?]*)/);
+  return match ? match[1] : "/";
+}
+function getHost(request) {
+  const { headers } = request;
+  let host = headers.get("X-Forwarded-Host");
+  if (!host) {
+    host = headers.get("Host");
+  }
+  host = (host === null || host === void 0 ? void 0 : host.split(/\s*,\s*/, 1)[0]) || "undefined";
+  return host;
+}
+export {
+  getHost,
+  getPathname,
+  parseHeaders,
+  parseQuery
+};

package/dist/esm-node/base/utils/serverConfig.js

@@ -0,0 +1,34 @@
+import { compatRequire, fs, DEFAULT_SERVER_CONFIG } from "@modern-js/utils";
+import mergeDeep from "merge-deep";
+const getServerConfigPath = async (distDirectory, serverConfigFile = DEFAULT_SERVER_CONFIG) => {
+  const path = await import("path");
+  const serverConfigPath = path.join(distDirectory, serverConfigFile);
+  return `${serverConfigPath}.js`;
+};
+const requireConfig = (serverConfigPath) => {
+  if (fs.pathExistsSync(serverConfigPath)) {
+    return compatRequire(serverConfigPath);
+  }
+  return {};
+};
+const loadConfig = ({ cliConfig, serverConfig, resolvedConfigPath }) => {
+  let config = null;
+  if (process.env.NODE_ENV === "production") {
+    const resolvedConfig = requireConfig(resolvedConfigPath);
+    config = mergeDeep({
+      ...resolvedConfig,
+      plugins: []
+    }, serverConfig, cliConfig);
+  } else {
+    config = mergeDeep({
+      ...cliConfig,
+      plugins: []
+    }, serverConfig);
+  }
+  return config;
+};
+export {
+  getServerConfigPath,
+  loadConfig,
+  requireConfig
+};

package/dist/esm-node/base/utils/transformStream.js

@@ -0,0 +1,36 @@
+function createTransformStream(fn) {
+  const decoder = new TextDecoder();
+  const encoder = new TextEncoder();
+  return new TransformStream({
+    async transform(chunk, controller) {
+      const content = decoder.decode(chunk);
+      const newContent = await fn(content);
+      controller.enqueue(encoder.encode(newContent));
+    }
+  });
+}
+function transformResponse(response, transformCb) {
+  let readable = null;
+  if (response.body) {
+    const stream = createTransformStream(async (before) => {
+      if (Array.isArray(transformCb)) {
+        return transformCb.reduce(async (before2, cb) => {
+          return cb(await before2);
+        }, Promise.resolve(before));
+      } else {
+        return transformCb(before);
+      }
+    });
+    response.body.pipeThrough(stream);
+    readable = stream.readable;
+  }
+  return new Response(readable, {
+    status: response.status,
+    headers: response.headers,
+    statusText: response.statusText
+  });
+}
+export {
+  createTransformStream,
+  transformResponse
+};

package/dist/esm-node/base/utils/warmup.js

@@ -0,0 +1,9 @@
+function warmup(bundles) {
+  bundles.forEach((bundle) => {
+    bundle && import(bundle).catch((_) => {
+    });
+  });
+}
+export {
+  warmup
+};

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

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

package/dist/{esm → esm-node/core}/loadPlugins.js

@@ -1,5 +1,5 @@
 import { compatRequire, getInternalPlugins, tryResolve } from "@modern-js/utils";
-import { createPlugin } from "./plugin";
+import { createPlugin } from "../core/plugin";
 const resolvePlugin = (p, appDirectory) => {
   const isPluginInstance = typeof p !== "string";
   if (isPluginInstance) {
@@ -14,12 +14,9 @@ const resolvePlugin = (p, appDirectory) => {
     module: createPlugin(pluginInstance.setup, pluginInstance)
   };
 };
-const loadPlugins = (appDirectory, configPlugins, options) => {
-  const loadedPlugins = getInternalPlugins(appDirectory, options.internalPlugins);
-  return [
-    ...loadedPlugins,
-    ...configPlugins
-  ].map((plugin) => {
+const loadPlugins = (appDirectory, internalPlugins) => {
+  const loadedPlugins = getInternalPlugins(appDirectory, internalPlugins);
+  return loadedPlugins.map((plugin) => {
     const { module } = resolvePlugin(plugin, appDirectory);
     return module;
   });

package/dist/{esm → esm-node/core}/plugin.js

@@ -5,10 +5,9 @@ const prepare = createWaterfall();
 const prepareLoaderHandler = createAsyncPipeline();
 const prepareWebServer = createAsyncPipeline();
 const prepareApiServer = createAsyncPipeline();
-const onApiChange = createWaterfall();
+const onApiChange = createAsyncWaterfall();
 const repack = createWaterfall();
 const beforeServerInit = createAsyncWaterfall();
-const afterServerInit = createAsyncWaterfall();
 const setupCompiler = createParallelWorkflow();
 const beforeRouteSet = createAsyncPipeline();
 const afterRouteSet = createAsyncPipeline();
@@ -52,7 +51,6 @@ const serverHooks = {
   repack,
   onApiChange,
   beforeServerInit,
-  afterServerInit,
   setupCompiler,
   beforeRouteSet,
   afterRouteSet,

package/dist/esm-node/index.js

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

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

@@ -0,0 +1,6 @@
+export * from "./bff";
+export * from "./html";
+export * from "./output";
+export * from "./server";
+export * from "./source";
+export * from "./tools";

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

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

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

@@ -0,0 +1,22 @@
+import { NodeRequest, NodeResponse } from '../../../core/plugin';
+import { HonoContext, HonoRequest, ServerEnv, Middleware, Next, ServerManifest } from '../../../core/server';
+type NodeBindings = {
+    node: {
+        req: NodeRequest & {
+            __honoRequest: HonoRequest;
+            __templates: Record<string, string>;
+            __serverManifest: ServerManifest;
+        };
+        res: NodeResponse;
+    };
+};
+export type ServerNodeEnv = {
+    Bindings: NodeBindings;
+};
+export type ServerNodeMiddleware = Middleware<ServerNodeEnv>;
+export type ServerNodeContext = HonoContext<ServerNodeEnv>;
+type Handler = (req: NodeRequest, res: NodeResponse) => void | Promise<void>;
+export declare const httpCallBack2HonoMid: (handler: Handler) => (context: HonoContext<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/index.d.ts

@@ -0,0 +1,6 @@
+export { loadServerEnv } from './loadServer';
+export { httpCallBack2HonoMid, connectMid2HonoMid } from './hono';
+export type { ServerNodeContext, ServerNodeMiddleware } from './hono';
+export { createNodeServer, sendResponse, createWebRequest } from './node';
+export { bindBFFHandler } from './bff';
+export { createStaticMiddleware, registerMockHandlers, injectServerManifest, injectTemplates, getHtmlTemplates, } from './middlewares';

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

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

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

@@ -0,0 +1,4 @@
+export * from './mock';
+export * from './serverStatic';
+export * from './templates';
+export * from './serverManifest';

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

@@ -0,0 +1,5 @@
+import type { ServerBase } from '../../../serverBase';
+export declare const registerMockHandlers: ({ pwd, server, }: {
+    pwd: string;
+    server: ServerBase;
+}) => Promise<null | undefined>;

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

@@ -0,0 +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>;

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

@@ -0,0 +1,7 @@
+import { ServerRoute } from '@modern-js/types';
+import { Middleware } from '../../../../core/server';
+export type PublicMiddlwareOptions = {
+    pwd: string;
+    routes: ServerRoute[];
+};
+export declare function createPublicMiddleware({ pwd, routes, }: PublicMiddlwareOptions): Middleware;

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

@@ -0,0 +1,11 @@
+import { ServerRoute } from '@modern-js/types';
+import type { OutputNormalizedConfig, HtmlNormalizedConfig } from '../../../../types/config';
+import { Middleware } from '../../../../core/server';
+interface ServerStaticOptions {
+    pwd: string;
+    output: OutputNormalizedConfig;
+    html: HtmlNormalizedConfig;
+    routes?: ServerRoute[];
+}
+export declare function createStaticMiddleware(options: ServerStaticOptions): Middleware;
+export {};

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

@@ -0,0 +1,4 @@
+import { ServerRoute } from '@modern-js/types';
+import { HonoMiddleware, 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>;

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

@@ -0,0 +1,12 @@
+/// <reference types="node" />
+import { Server as NodeServer } from 'node:http';
+import { NodeRequest, NodeResponse } from '../../../core/plugin';
+import { RequestHandler } from '../../../core/server';
+export declare const createWebRequest: (req: NodeRequest, res: NodeResponse) => Request;
+export declare const sendResponse: (response: Response, res: NodeResponse) => Promise<void>;
+declare const getRequestListener: (handler: RequestHandler) => (req: NodeRequest, res: NodeResponse) => Promise<void>;
+type NodeServerWrapper = NodeServer & {
+    getRequestHandler: () => ReturnType<typeof getRequestListener>;
+};
+export declare const createNodeServer: (handleRequest: RequestHandler) => NodeServerWrapper;
+export {};

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

@@ -0,0 +1,2 @@
+export * from './install';
+export * from './stream';

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

@@ -0,0 +1 @@
+export declare const installGlobals: () => void;

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

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

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

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

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

@@ -0,0 +1,7 @@
+export { createErrorHtml } from './utils';
+export { AGGRED_DIR } from './constants';
+export { favionFallbackMiddleware, injectReporter, injectLogger, getRenderHandler, bindRenderHandler, } 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, Metrics } from '@modern-js/types';
+import { HonoContext, Logger } from '../../../core/server';
+export declare function createBaseHookContext(c: HonoContext, logger: Logger, metrics?: Metrics): HookContext;

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

@@ -0,0 +1,7 @@
+import { AfterMatchContext, AfterRenderContext, Metrics, MiddlewareContext, Logger, AfterStreamingRenderContext, ServerRoute } from '@modern-js/types';
+import { HonoContext, ServerEnv } from '../../../core/server';
+import type { ServerNodeEnv } from '../../adapters/node/hono';
+export declare function createAfterMatchCtx(c: HonoContext, entryName: string, logger: Logger, metrics?: Metrics): AfterMatchContext;
+export declare function createAfterRenderCtx(c: HonoContext, logger: Logger, metrics?: Metrics): Promise<AfterRenderContext>;
+export declare function createCustomMiddlewaresCtx(c: HonoContext<ServerNodeEnv & ServerEnv>, logger: Logger, metrics?: Metrics): MiddlewareContext;
+export declare function createAfterStreamingRenderContext(c: HonoContext, logger: Logger, route: Partial<ServerRoute>, metrics?: Metrics): (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,3 @@
+export * from './faviconFallback';
+export * from './monitor';
+export * from './renderHandler';

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,9 @@
+import { Render } from '../../../core/render';
+import { ServerBaseOptions } from '../../../core/server';
+import { ServerBase } from '../../serverBase';
+export type BindRenderHandleOptions = {
+    metaName?: string;
+    staticGenerate?: 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,18 @@
+/// <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;
+    reporter?: Reporter;
+    nodeReq?: IncomingMessage;
+    nonce?: string;
+}
+export declare function ssrRender(request: Request, { routeInfo, html, staticGenerate, nonce, metaName, reporter, logger, nodeReq, serverManifest, }: SSRRenderOptions): Promise<Response>;

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;
+};