@depup/hono 4.12.8-depup.0

package/dist/types/adapter/aws-lambda/handler.d.ts

@@ -0,0 +1,184 @@
+import type { Hono } from '../../hono';
+import type { Env, Schema } from '../../types';
+import type { ALBRequestContext, ApiGatewayRequestContext, ApiGatewayRequestContextV2, Handler, LambdaContext, LatticeRequestContextV2 } from './types';
+export type LambdaEvent = APIGatewayProxyEvent | APIGatewayProxyEventV2 | ALBProxyEvent | LatticeProxyEventV2;
+export interface LatticeProxyEventV2 {
+    version: string;
+    path: string;
+    method: string;
+    headers: Record<string, string[] | undefined>;
+    queryStringParameters: Record<string, string[] | undefined>;
+    body: string | null;
+    isBase64Encoded: boolean;
+    requestContext: LatticeRequestContextV2;
+}
+export interface APIGatewayProxyEventV2 {
+    version: string;
+    routeKey: string;
+    headers: Record<string, string | undefined>;
+    multiValueHeaders?: undefined;
+    cookies?: string[];
+    rawPath: string;
+    rawQueryString: string;
+    body: string | null;
+    isBase64Encoded: boolean;
+    requestContext: ApiGatewayRequestContextV2;
+    queryStringParameters?: {
+        [name: string]: string | undefined;
+    };
+    pathParameters?: {
+        [name: string]: string | undefined;
+    };
+    stageVariables?: {
+        [name: string]: string | undefined;
+    };
+}
+export interface APIGatewayProxyEvent {
+    version: string;
+    httpMethod: string;
+    headers: Record<string, string | undefined>;
+    multiValueHeaders?: {
+        [headerKey: string]: string[];
+    };
+    path: string;
+    body: string | null;
+    isBase64Encoded: boolean;
+    queryStringParameters?: Record<string, string | undefined>;
+    requestContext: ApiGatewayRequestContext;
+    resource: string;
+    multiValueQueryStringParameters?: {
+        [parameterKey: string]: string[];
+    };
+    pathParameters?: Record<string, string>;
+    stageVariables?: Record<string, string>;
+}
+export interface ALBProxyEvent {
+    httpMethod: string;
+    headers?: Record<string, string | undefined>;
+    multiValueHeaders?: Record<string, string[] | undefined>;
+    path: string;
+    body: string | null;
+    isBase64Encoded: boolean;
+    queryStringParameters?: Record<string, string | undefined>;
+    multiValueQueryStringParameters?: {
+        [parameterKey: string]: string[];
+    };
+    requestContext: ALBRequestContext;
+}
+type WithHeaders = {
+    headers: Record<string, string>;
+    multiValueHeaders?: undefined;
+};
+type WithMultiValueHeaders = {
+    headers?: undefined;
+    multiValueHeaders: Record<string, string[]>;
+};
+export type APIGatewayProxyResult = {
+    statusCode: number;
+    statusDescription?: string;
+    body: string;
+    cookies?: string[];
+    isBase64Encoded: boolean;
+} & (WithHeaders | WithMultiValueHeaders);
+export declare const streamHandle: <E extends Env = Env, S extends Schema = {}, BasePath extends string = "/">(app: Hono<E, S, BasePath>) => Handler;
+type HandleOptions = {
+    isContentTypeBinary: ((contentType: string) => boolean) | undefined;
+};
+/**
+ * Converts a Hono application to an AWS Lambda handler.
+ *
+ * Accepts events from API Gateway (v1 and v2), Application Load Balancer (ALB),
+ * and Lambda Function URLs.
+ *
+ * @param app - The Hono application instance
+ * @param options - Optional configuration
+ * @param options.isContentTypeBinary - A function to determine if the content type is binary.
+ *                                      If not provided, the default function will be used.
+ * @returns Lambda handler function
+ *
+ * @example
+ * ```js
+ * import { Hono } from 'hono'
+ * import { handle } from 'hono/aws-lambda'
+ *
+ * const app = new Hono()
+ *
+ * app.get('/', (c) => c.text('Hello from Lambda'))
+ * app.get('/json', (c) => c.json({ message: 'Hello JSON' }))
+ *
+ * export const handler = handle(app)
+ * ```
+ *
+ * @example
+ * ```js
+ * // With custom binary content type detection
+ * import { handle, defaultIsContentTypeBinary } from 'hono/aws-lambda'
+ * export const handler = handle(app, {
+ *   isContentTypeBinary: (contentType) => {
+ *     if (defaultIsContentTypeBinary(contentType)) {
+ *       // default logic same as prior to v4.8.4
+ *       return true
+ *     }
+ *     return contentType.startsWith('image/') || contentType === 'application/pdf'
+ *   }
+ * })
+ * ```
+ */
+export declare const handle: <E extends Env = Env, S extends Schema = {}, BasePath extends string = "/">(app: Hono<E, S, BasePath>, { isContentTypeBinary }?: HandleOptions) => (<L extends LambdaEvent>(event: L, lambdaContext?: LambdaContext) => Promise<APIGatewayProxyResult & (L extends {
+    multiValueHeaders: Record<string, string[]>;
+} ? WithMultiValueHeaders : WithHeaders)>);
+export declare abstract class EventProcessor<E extends LambdaEvent> {
+    protected abstract getPath(event: E): string;
+    protected abstract getMethod(event: E): string;
+    protected abstract getQueryString(event: E): string;
+    protected abstract getHeaders(event: E): Headers;
+    protected abstract getCookies(event: E, headers: Headers): void;
+    protected abstract setCookiesToResult(result: APIGatewayProxyResult, cookies: string[]): void;
+    protected getHeaderValue(headers: E['headers'], key: string): string | undefined;
+    protected getDomainName(event: E): string | undefined;
+    createRequest(event: E): Request;
+    createResult(event: E, res: Response, options: Pick<HandleOptions, 'isContentTypeBinary'>): Promise<APIGatewayProxyResult>;
+    setCookies(_event: E, res: Response, result: APIGatewayProxyResult): void;
+}
+export declare class EventV2Processor extends EventProcessor<APIGatewayProxyEventV2> {
+    protected getPath(event: APIGatewayProxyEventV2): string;
+    protected getMethod(event: APIGatewayProxyEventV2): string;
+    protected getQueryString(event: APIGatewayProxyEventV2): string;
+    protected getCookies(event: APIGatewayProxyEventV2, headers: Headers): void;
+    protected setCookiesToResult(result: APIGatewayProxyResult, cookies: string[]): void;
+    protected getHeaders(event: APIGatewayProxyEventV2): Headers;
+}
+export declare class EventV1Processor extends EventProcessor<APIGatewayProxyEvent> {
+    protected getPath(event: APIGatewayProxyEvent): string;
+    protected getMethod(event: APIGatewayProxyEvent): string;
+    protected getQueryString(event: APIGatewayProxyEvent): string;
+    protected getCookies(_event: APIGatewayProxyEvent, _headers: Headers): void;
+    protected getHeaders(event: APIGatewayProxyEvent): Headers;
+    protected setCookiesToResult(result: APIGatewayProxyResult, cookies: string[]): void;
+}
+export declare class ALBProcessor extends EventProcessor<ALBProxyEvent> {
+    protected getHeaders(event: ALBProxyEvent): Headers;
+    protected getPath(event: ALBProxyEvent): string;
+    protected getMethod(event: ALBProxyEvent): string;
+    protected getQueryString(event: ALBProxyEvent): string;
+    protected getCookies(event: ALBProxyEvent, headers: Headers): void;
+    protected setCookiesToResult(result: APIGatewayProxyResult, cookies: string[]): void;
+}
+export declare class LatticeV2Processor extends EventProcessor<LatticeProxyEventV2> {
+    protected getPath(event: LatticeProxyEventV2): string;
+    protected getMethod(event: LatticeProxyEventV2): string;
+    protected getQueryString(): string;
+    protected getHeaders(event: LatticeProxyEventV2): Headers;
+    protected getCookies(): void;
+    protected setCookiesToResult(result: APIGatewayProxyResult, cookies: string[]): void;
+}
+export declare const getProcessor: (event: LambdaEvent) => EventProcessor<LambdaEvent>;
+/**
+ * Check if the given content type is binary.
+ * This is a default function and may be overwritten by the user via `isContentTypeBinary` option in handler().
+ * @param contentType The content type to check.
+ * @returns True if the content type is binary, false otherwise.
+ */
+export declare const defaultIsContentTypeBinary: (contentType: string) => boolean;
+export declare const isContentEncodingBinary: (contentEncoding: string | null) => boolean;
+export {};

package/dist/types/adapter/aws-lambda/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @module
+ * AWS Lambda Adapter for Hono.
+ */
+export { handle, streamHandle, defaultIsContentTypeBinary } from './handler';
+export { getConnInfo } from './conninfo';
+export type { APIGatewayProxyResult, LambdaEvent } from './handler';
+export type { ApiGatewayRequestContext, ApiGatewayRequestContextV2, ALBRequestContext, LambdaContext, } from './types';

package/dist/types/adapter/aws-lambda/types.d.ts

@@ -0,0 +1,144 @@
+export interface CognitoIdentity {
+    cognitoIdentityId: string;
+    cognitoIdentityPoolId: string;
+}
+export interface ClientContext {
+    client: ClientContextClient;
+    Custom?: any;
+    env: ClientContextEnv;
+}
+export interface ClientContextClient {
+    installationId: string;
+    appTitle: string;
+    appVersionName: string;
+    appVersionCode: string;
+    appPackageName: string;
+}
+export interface ClientContextEnv {
+    platformVersion: string;
+    platform: string;
+    make: string;
+    model: string;
+    locale: string;
+}
+/**
+ * {@link Handler} context parameter.
+ * See {@link https://docs.aws.amazon.com/lambda/latest/dg/nodejs-prog-model-context.html AWS documentation}.
+ */
+export interface LambdaContext {
+    callbackWaitsForEmptyEventLoop: boolean;
+    functionName: string;
+    functionVersion: string;
+    invokedFunctionArn: string;
+    memoryLimitInMB: string;
+    awsRequestId: string;
+    logGroupName: string;
+    logStreamName: string;
+    identity?: CognitoIdentity | undefined;
+    clientContext?: ClientContext | undefined;
+    getRemainingTimeInMillis(): number;
+}
+type Callback<TResult = any> = (error?: Error | string | null, result?: TResult) => void;
+export type Handler<TEvent = any, TResult = any> = (event: TEvent, context: LambdaContext, callback: Callback<TResult>) => void | Promise<TResult>;
+interface ClientCert {
+    clientCertPem: string;
+    subjectDN: string;
+    issuerDN: string;
+    serialNumber: string;
+    validity: {
+        notBefore: string;
+        notAfter: string;
+    };
+}
+interface Identity {
+    accessKey?: string;
+    accountId?: string;
+    caller?: string;
+    cognitoAuthenticationProvider?: string;
+    cognitoAuthenticationType?: string;
+    cognitoIdentityId?: string;
+    cognitoIdentityPoolId?: string;
+    principalOrgId?: string;
+    sourceIp: string;
+    user?: string;
+    userAgent: string;
+    userArn?: string;
+    clientCert?: ClientCert;
+}
+export interface ApiGatewayRequestContext {
+    accountId: string;
+    apiId: string;
+    authorizer: {
+        claims?: unknown;
+        scopes?: unknown;
+    };
+    domainName: string;
+    domainPrefix: string;
+    extendedRequestId: string;
+    httpMethod: string;
+    identity: Identity;
+    path: string;
+    protocol: string;
+    requestId: string;
+    requestTime: string;
+    requestTimeEpoch: number;
+    resourceId?: string;
+    resourcePath: string;
+    stage: string;
+}
+interface Authorizer {
+    iam?: {
+        accessKey: string;
+        accountId: string;
+        callerId: string;
+        cognitoIdentity: null;
+        principalOrgId: null;
+        userArn: string;
+        userId: string;
+    };
+}
+export interface ApiGatewayRequestContextV2 {
+    accountId: string;
+    apiId: string;
+    authentication: null;
+    authorizer: Authorizer;
+    domainName: string;
+    domainPrefix: string;
+    http: {
+        method: string;
+        path: string;
+        protocol: string;
+        sourceIp: string;
+        userAgent: string;
+    };
+    requestId: string;
+    routeKey: string;
+    stage: string;
+    time: string;
+    timeEpoch: number;
+}
+export interface ALBRequestContext {
+    elb: {
+        targetGroupArn: string;
+    };
+}
+export interface LatticeRequestContextV2 {
+    serviceNetworkArn: string;
+    serviceArn: string;
+    targetGroupArn: string;
+    region: string;
+    timeEpoch: string;
+    identity: {
+        sourceVpcArn?: string;
+        type?: string;
+        principal?: string;
+        principalOrgID?: string;
+        sessionName?: string;
+        x509IssuerOu?: string;
+        x509SanDns?: string;
+        x509SanNameCn?: string;
+        x509SanUri?: string;
+        x509SubjectCn?: string;
+    };
+}
+export {};

package/dist/types/adapter/bun/conninfo.d.ts

@@ -0,0 +1,7 @@
+import type { GetConnInfo } from '../../helper/conninfo';
+/**
+ * Get ConnInfo with Bun
+ * @param c Context
+ * @returns ConnInfo
+ */
+export declare const getConnInfo: GetConnInfo;

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

@@ -0,0 +1,10 @@
+/**
+ * @module
+ * Bun Adapter for Hono.
+ */
+export { serveStatic } from './serve-static';
+export { bunFileSystemModule, toSSG } from './ssg';
+export { createBunWebSocket, upgradeWebSocket, websocket } from './websocket';
+export type { BunWebSocketData, BunWebSocketHandler } from './websocket';
+export { getConnInfo } from './conninfo';
+export { getBunServer } from './server';

package/dist/types/adapter/bun/serve-static.d.ts

@@ -0,0 +1,3 @@
+import type { ServeStaticOptions } from '../../middleware/serve-static';
+import type { Env, MiddlewareHandler } from '../../types';
+export declare const serveStatic: <E extends Env = Env>(options: ServeStaticOptions<E>) => MiddlewareHandler;

package/dist/types/adapter/bun/server.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Getting Bun Server Object for Bun adapters
+ * @module
+ */
+import type { Context } from '../../context';
+/**
+ * Get Bun Server Object from Context
+ * @template T - The type of Bun Server
+ * @param c Context
+ * @returns Bun Server
+ */
+export declare const getBunServer: <T>(c: Context) => T | undefined;

package/dist/types/adapter/bun/ssg.d.ts

@@ -0,0 +1,13 @@
+import type { FileSystemModule, ToSSGAdaptorInterface } from '../../helper/ssg';
+/**
+ * @experimental
+ * `bunFileSystemModule` is an experimental feature.
+ * The API might be changed.
+ */
+export declare const bunFileSystemModule: FileSystemModule;
+/**
+ * @experimental
+ * `toSSG` is an experimental feature.
+ * The API might be changed.
+ */
+export declare const toSSG: ToSSGAdaptorInterface;

package/dist/types/adapter/bun/websocket.d.ts

@@ -0,0 +1,39 @@
+import type { UpgradeWebSocket, WSEvents } from '../../helper/websocket';
+import { WSContext } from '../../helper/websocket';
+/**
+ * @internal
+ */
+export interface BunServerWebSocket<T> {
+    send(data: string | ArrayBuffer | Uint8Array, compress?: boolean): void;
+    close(code?: number, reason?: string): void;
+    data: T;
+    readyState: 0 | 1 | 2 | 3;
+}
+export interface BunWebSocketHandler<T> {
+    open(ws: BunServerWebSocket<T>): void;
+    close(ws: BunServerWebSocket<T>, code?: number, reason?: string): void;
+    message(ws: BunServerWebSocket<T>, message: string | {
+        buffer: ArrayBufferLike;
+    }): void;
+}
+interface CreateWebSocket<T> {
+    upgradeWebSocket: UpgradeWebSocket<T>;
+    websocket: BunWebSocketHandler<BunWebSocketData>;
+}
+export interface BunWebSocketData {
+    events: WSEvents;
+    url: URL;
+    protocol: string;
+}
+/**
+ * @internal
+ */
+export declare const createWSContext: (ws: BunServerWebSocket<BunWebSocketData>) => WSContext;
+export declare const upgradeWebSocket: UpgradeWebSocket<any>;
+export declare const websocket: BunWebSocketHandler<BunWebSocketData>;
+/**
+ * @deprecated Import `upgradeWebSocket` and `websocket` directly from `hono/bun` instead.
+ * @returns A function to create a Bun WebSocket handler.
+ */
+export declare const createBunWebSocket: <T>() => CreateWebSocket<T>;
+export {};

package/dist/types/adapter/cloudflare-pages/conninfo.d.ts

@@ -0,0 +1,21 @@
+import type { GetConnInfo } from '../../helper/conninfo';
+/**
+ * Get connection information from Cloudflare Pages
+ * @param c - Context
+ * @returns Connection information including remote address
+ * @example
+ * ```ts
+ * import { Hono } from 'hono'
+ * import { handle, getConnInfo } from 'hono/cloudflare-pages'
+ *
+ * const app = new Hono()
+ *
+ * app.get('/', (c) => {
+ *   const info = getConnInfo(c)
+ *   return c.text(`Your IP: ${info.remote.address}`)
+ * })
+ *
+ * export const onRequest = handle(app)
+ * ```
+ */
+export declare const getConnInfo: GetConnInfo;

package/dist/types/adapter/cloudflare-pages/handler.d.ts

@@ -0,0 +1,33 @@
+import type { Hono } from '../../hono';
+import type { BlankSchema, Env, Input, MiddlewareHandler, Schema } from '../../types';
+type Params<P extends string = any> = Record<P, string | string[]>;
+export type EventContext<Env = {}, P extends string = any, Data = Record<string, unknown>> = {
+    request: Request;
+    functionPath: string;
+    waitUntil: (promise: Promise<unknown>) => void;
+    passThroughOnException: () => void;
+    props: any;
+    next: (input?: Request | string, init?: RequestInit) => Promise<Response>;
+    env: Env & {
+        ASSETS: {
+            fetch: typeof fetch;
+        };
+    };
+    params: Params<P>;
+    data: Data;
+};
+declare type PagesFunction<Env = unknown, Params extends string = any, Data extends Record<string, unknown> = Record<string, unknown>> = (context: EventContext<Env, Params, Data>) => Response | Promise<Response>;
+export declare const handle: <E extends Env = Env, S extends Schema = BlankSchema, BasePath extends string = "/">(app: Hono<E, S, BasePath>) => PagesFunction<E["Bindings"]>;
+export declare function handleMiddleware<E extends Env = {}, P extends string = any, I extends Input = {}>(middleware: MiddlewareHandler<E & {
+    Bindings: {
+        eventContext: EventContext;
+    };
+}, P, I>): PagesFunction<E['Bindings']>;
+/**
+ *
+ * @description `serveStatic()` is for advanced mode:
+ * https://developers.cloudflare.com/pages/platform/functions/advanced-mode/#set-up-a-function
+ *
+ */
+export declare const serveStatic: () => MiddlewareHandler;
+export {};

package/dist/types/adapter/cloudflare-pages/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @module
+ * Cloudflare Pages Adapter for Hono.
+ */
+export { handle, handleMiddleware, serveStatic } from './handler';
+export { getConnInfo } from './conninfo';
+export type { EventContext } from './handler';

package/dist/types/adapter/cloudflare-workers/conninfo.d.ts

@@ -0,0 +1,2 @@
+import type { GetConnInfo } from '../../helper/conninfo';
+export declare const getConnInfo: GetConnInfo;

package/dist/types/adapter/cloudflare-workers/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @module
+ * Cloudflare Workers Adapter for Hono.
+ */
+export { serveStatic } from './serve-static-module';
+export { upgradeWebSocket } from './websocket';
+export { getConnInfo } from './conninfo';

package/dist/types/adapter/cloudflare-workers/serve-static-module.d.ts

@@ -0,0 +1,4 @@
+import type { Env, MiddlewareHandler } from '../../types';
+import type { ServeStaticOptions } from './serve-static';
+declare const module: <E extends Env = Env>(options: Omit<ServeStaticOptions<E>, "namespace">) => MiddlewareHandler;
+export { module as serveStatic };

package/dist/types/adapter/cloudflare-workers/serve-static.d.ts

@@ -0,0 +1,16 @@
+import type { ServeStaticOptions as BaseServeStaticOptions } from '../../middleware/serve-static';
+import type { Env, MiddlewareHandler } from '../../types';
+export type ServeStaticOptions<E extends Env = Env> = BaseServeStaticOptions<E> & {
+    namespace?: unknown;
+    manifest: object | string;
+};
+/**
+ * @deprecated
+ * `serveStatic` in the Cloudflare Workers adapter is deprecated.
+ * You can serve static files directly using Cloudflare Static Assets.
+ * @see https://developers.cloudflare.com/workers/static-assets/
+ * Cloudflare Static Assets is currently in open beta. If this doesn't work for you,
+ * please consider using Cloudflare Pages. You can start to create the Cloudflare Pages
+ * application with the `npm create hono@latest` command.
+ */
+export declare const serveStatic: <E extends Env = Env>(options: ServeStaticOptions<E>) => MiddlewareHandler;

package/dist/types/adapter/cloudflare-workers/utils.d.ts

@@ -0,0 +1,5 @@
+export type KVAssetOptions = {
+    manifest?: object | string;
+    namespace?: unknown;
+};
+export declare const getContentFromKVAsset: (path: string, options?: KVAssetOptions) => Promise<ReadableStream | null>;

package/dist/types/adapter/cloudflare-workers/websocket.d.ts

@@ -0,0 +1,2 @@
+import type { UpgradeWebSocket, WSEvents } from '../../helper/websocket';
+export declare const upgradeWebSocket: UpgradeWebSocket<WebSocket, any, Omit<WSEvents<WebSocket>, 'onOpen'>>;

package/dist/types/adapter/deno/conninfo.d.ts

@@ -0,0 +1,7 @@
+import type { GetConnInfo } from '../../helper/conninfo';
+/**
+ * Get conninfo with Deno
+ * @param c Context
+ * @returns ConnInfo
+ */
+export declare const getConnInfo: GetConnInfo;

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

@@ -0,0 +1,8 @@
+/**
+ * @module
+ * Deno Adapter for Hono.
+ */
+export { serveStatic } from './serve-static';
+export { toSSG, denoFileSystemModule } from './ssg';
+export { upgradeWebSocket } from './websocket';
+export { getConnInfo } from './conninfo';

package/dist/types/adapter/deno/serve-static.d.ts

@@ -0,0 +1,3 @@
+import type { ServeStaticOptions } from '../../middleware/serve-static';
+import type { Env, MiddlewareHandler } from '../../types';
+export declare const serveStatic: <E extends Env = Env>(options: ServeStaticOptions<E>) => MiddlewareHandler;

package/dist/types/adapter/deno/ssg.d.ts

@@ -0,0 +1,13 @@
+import type { FileSystemModule, ToSSGAdaptorInterface } from '../../helper/ssg/index';
+/**
+ * @experimental
+ * `denoFileSystemModule` is an experimental feature.
+ * The API might be changed.
+ */
+export declare const denoFileSystemModule: FileSystemModule;
+/**
+ * @experimental
+ * `toSSG` is an experimental feature.
+ * The API might be changed.
+ */
+export declare const toSSG: ToSSGAdaptorInterface;

package/dist/types/adapter/deno/websocket.d.ts

@@ -0,0 +1,2 @@
+import type { UpgradeWebSocket } from '../../helper/websocket';
+export declare const upgradeWebSocket: UpgradeWebSocket<WebSocket, Deno.UpgradeWebSocketOptions>;

package/dist/types/adapter/lambda-edge/conninfo.d.ts

@@ -0,0 +1,2 @@
+import type { GetConnInfo } from '../../helper/conninfo';
+export declare const getConnInfo: GetConnInfo;