hono 3.6.1 → 3.6.2

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

@@ -1,3 +1,3 @@
 import type { ServeStaticOptions } from './serve-static';
-declare const module: (options?: ServeStaticOptions) => import("../..").MiddlewareHandler<{}, any, {}>;
+declare const module: (options?: ServeStaticOptions) => import("../..").MiddlewareHandler<any, string, {}>;
 export { module as serveStatic };

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

@@ -4,4 +4,4 @@ import type { Env, Input, MiddlewareHandler } from '../../types';
  * `middleware()` is an experimental feature.
  * The API might be changed.
  */
-export declare const middleware: <E extends Env = Env, P extends string = string, I extends Input = {}>(middleware: MiddlewareHandler<E, P, I>) => MiddlewareHandler<E, P, I>;
+export declare const middleware: <E extends Env = any, P extends string = any, I extends Input = {}>(middleware: MiddlewareHandler<E, P, I>) => MiddlewareHandler<E, P, I>;

package/dist/types/types.d.ts

@@ -1,7 +1,7 @@
 import type { Context } from './context';
 import type { Hono } from './hono';
 import type { StatusCode } from './utils/http-status';
-import type { UnionToIntersection } from './utils/types';
+import type { IntersectNonAnyTypes, UnionToIntersection } from './utils/types';
 export declare type Bindings = Record<string, unknown>;
 export declare type Variables = Record<string, unknown>;
 export declare type Env = {
@@ -17,83 +17,72 @@ export declare type Input = {
 };
 declare type HandlerResponse<O> = Response | TypedResponse<O> | Promise<Response | TypedResponse<O>>;
 export declare type Handler<E extends Env = any, P extends string = any, I extends Input = Input, R extends HandlerResponse<any> = any> = (c: Context<E, P, I>, next: Next) => R;
-export declare type MiddlewareHandler<E extends Env = {}, P extends string = any, I extends Input = {}> = (c: Context<E, P, I>, next: Next) => Promise<Response | void>;
-export declare type H<E extends Env = any, P extends string = any, I extends Input = {}, E2 extends Env = E, R extends HandlerResponse<any> = any> = Handler<E2, P, I, R> | MiddlewareHandler<E2, P, I>;
+export declare type MiddlewareHandler<E extends Env = any, P extends string = string, I extends Input = {}> = (c: Context<E, P, I>, next: Next) => Promise<Response | void>;
+export declare type H<E extends Env = any, P extends string = any, I extends Input = {}, R extends HandlerResponse<any> = any> = Handler<E, P, I, R> | MiddlewareHandler<E, P, I>;
 export declare type NotFoundHandler<E extends Env = any> = (c: Context<E>) => Response | Promise<Response>;
 export declare type ErrorHandler<E extends Env = any> = (err: Error, c: Context<E>) => Response | Promise<Response>;
-export interface HandlerInterface<E extends Env = Env, M extends string = any, S extends Schema = {}, BasePath extends string = '/'> {
-    <P extends string = ExtractKey<S> extends never ? BasePath : ExtractKey<S>, I extends Input = {}, R extends HandlerResponse<any> = any, Temp extends Env = E>(handler: H<E, P, I, Temp, R>): Hono<E, S & ToSchema<M, P, I['in'], MergeTypedResponseData<R>>, BasePath>;
-    <P extends string = ExtractKey<S> extends never ? BasePath : ExtractKey<S>, I extends Input = {}, R extends HandlerResponse<any> = any, E2 extends Env = E, E3 extends Env = E, Temp extends Env = E & E2>(...handlers: [H<E2, P, I, E2, R>, H<E3, P, I, Temp, R>]): Hono<E, S & ToSchema<M, P, I['in'], MergeTypedResponseData<R>>, BasePath>;
-    <P extends string = ExtractKey<S> extends never ? BasePath : ExtractKey<S>, R extends HandlerResponse<any> = any, I extends Input = {}, I2 extends Input = I, I3 extends Input = I & I2, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, Temp extends Env = E & E2 & E3>(...handlers: [H<E2, P, I, E2, R>, H<E3, P, I2, E3, R>, H<E4, P, I3, Temp, R>]): Hono<E, S & ToSchema<M, P, I3['in'], MergeTypedResponseData<R>>, BasePath>;
-    <P extends string = ExtractKey<S> extends never ? BasePath : ExtractKey<S>, R extends HandlerResponse<any> = any, I extends Input = {}, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, Temp extends Env = E & E2 & E3 & E4>(...handlers: [
-        H<E2, P, I, E2, R>,
-        H<E3, P, I2, E3, R>,
-        H<E4, P, I3, E4, R>,
-        H<E5, P, I3, Temp, R>
-    ]): Hono<E, S & ToSchema<M, P, I4['in'], MergeTypedResponseData<R>>, BasePath>;
-    <P extends string = ExtractKey<S> extends never ? BasePath : ExtractKey<S>, R extends HandlerResponse<any> = any, I extends Input = {}, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I2 & I3, I5 extends Input = I & I2 & I3 & I4, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E, Temp extends Env = E & E2 & E3 & E4 & E5>(...handlers: [
-        H<E2, P, I, E2, R>,
-        H<E3, P, I2, E3, R>,
-        H<E4, P, I3, E4, R>,
-        H<E5, P, I3, E5, R>,
-        H<E6, P, I3, Temp, R>
+export interface HandlerInterface<E extends Env = Env, M extends string = string, S extends Schema = {}, BasePath extends string = '/'> {
+    <P extends string = ExtractKey<S> extends never ? BasePath : ExtractKey<S>, I extends Input = {}, R extends HandlerResponse<any> = any, E2 extends Env = E>(handler: H<E2, P, I, R>): Hono<E, S & ToSchema<M, P, I['in'], MergeTypedResponseData<R>>, BasePath>;
+    <P extends string = ExtractKey<S> extends never ? BasePath : ExtractKey<S>, I extends Input = {}, R extends HandlerResponse<any> = any, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>>(...handlers: [H<E2, P, I, R>, H<E3, P, I, R>]): Hono<E, S & ToSchema<M, P, I['in'], MergeTypedResponseData<R>>, BasePath>;
+    <P extends string = ExtractKey<S> extends never ? BasePath : ExtractKey<S>, R extends HandlerResponse<any> = any, I extends Input = {}, I2 extends Input = I, I3 extends Input = I & I2, E2 extends Env = E, E3 extends Env = E, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>>(...handlers: [H<E2, P, I, R>, H<E3, P, I2, R>, H<E4, P, I3, R>]): Hono<E, S & ToSchema<M, P, I3['in'], MergeTypedResponseData<R>>, BasePath>;
+    <P extends string = ExtractKey<S> extends never ? BasePath : ExtractKey<S>, R extends HandlerResponse<any> = any, I extends Input = {}, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4]>>(...handlers: [H<E2, P, I, R>, H<E3, P, I2, R>, H<E4, P, I3, R>, H<E5, P, I3, R>]): Hono<E, S & ToSchema<M, P, I4['in'], MergeTypedResponseData<R>>, BasePath>;
+    <P extends string = ExtractKey<S> extends never ? BasePath : ExtractKey<S>, R extends HandlerResponse<any> = any, I extends Input = {}, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I2 & I3, I5 extends Input = I & I2 & I3 & I4, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5]>>(...handlers: [
+        H<E2, P, I, R>,
+        H<E3, P, I2, R>,
+        H<E4, P, I3, R>,
+        H<E5, P, I3, R>,
+        H<E6, P, I3, R>
     ]): Hono<E, S & ToSchema<M, P, I5['in'], MergeTypedResponseData<R>>, BasePath>;
-    <P extends string = ExtractKey<S> extends never ? BasePath : ExtractKey<S>, I extends Input = {}, R extends HandlerResponse<any> = any>(...handlers: H<E, P, I, E, R>[]): Hono<E, S & ToSchema<M, P, I['in'], MergeTypedResponseData<R>>, BasePath>;
+    <P extends string = ExtractKey<S> extends never ? BasePath : ExtractKey<S>, I extends Input = {}, R extends HandlerResponse<any> = any>(...handlers: H<E, P, I, R>[]): Hono<E, S & ToSchema<M, P, I['in'], MergeTypedResponseData<R>>, BasePath>;
     <P extends string, R extends HandlerResponse<any> = any, I extends Input = {}>(path: P): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I['in'], MergeTypedResponseData<R>>, BasePath>;
-    <P extends string, R extends HandlerResponse<any> = any, I extends Input = {}, Temp extends Env = E>(path: P, handler: H<E, MergePath<BasePath, P>, I, Temp, R>): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I['in'], MergeTypedResponseData<R>>, BasePath>;
-    <P extends string, R extends HandlerResponse<any> = any, I extends Input = {}, E2 extends Env = E, E3 extends Env = E, Temp extends Env = E & E2>(path: P, ...handlers: [
-        H<E2, MergePath<BasePath, P>, I, E2, R>,
-        H<E3, MergePath<BasePath, P>, I, Temp, R>
-    ]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I['in'], MergeTypedResponseData<R>>, BasePath>;
-    <P extends string, R extends HandlerResponse<any> = any, I extends Input = {}, I2 extends Input = I, I3 extends Input = I & I2, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, Temp extends Env = E & E2 & E3>(path: P, ...handlers: [
-        H<E2, MergePath<BasePath, P>, I, E2, R>,
-        H<E3, MergePath<BasePath, P>, I2, E3, R>,
-        H<E4, MergePath<BasePath, P>, I3, Temp, R>
+    <P extends string, R extends HandlerResponse<any> = any, I extends Input = {}, E2 extends Env = E>(path: P, handler: H<E2, MergePath<BasePath, P>, I, R>): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I['in'], MergeTypedResponseData<R>>, BasePath>;
+    <P extends string, R extends HandlerResponse<any> = any, I extends Input = {}, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>>(path: P, ...handlers: [H<E2, MergePath<BasePath, P>, I, R>, H<E3, MergePath<BasePath, P>, I, R>]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I['in'], MergeTypedResponseData<R>>, BasePath>;
+    <P extends string, R extends HandlerResponse<any> = any, I extends Input = {}, I2 extends Input = I, I3 extends Input = I & I2, E2 extends Env = E, E3 extends Env = E, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>>(path: P, ...handlers: [
+        H<E2, MergePath<BasePath, P>, I, R>,
+        H<E3, MergePath<BasePath, P>, I2, R>,
+        H<E4, MergePath<BasePath, P>, I3, R>
     ]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I3['in'], MergeTypedResponseData<R>>, BasePath>;
-    <P extends string, R extends HandlerResponse<any> = any, I extends Input = {}, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, Temp extends Env = E & E2 & E3 & E4>(path: P, ...handlers: [
-        H<E2, MergePath<BasePath, P>, I, E2, R>,
-        H<E3, MergePath<BasePath, P>, I2, E3, R>,
-        H<E4, MergePath<BasePath, P>, I3, E4, R>,
-        H<E5, MergePath<BasePath, P>, I4, Temp, R>
+    <P extends string, R extends HandlerResponse<any> = any, I extends Input = {}, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4]>>(path: P, ...handlers: [
+        H<E2, MergePath<BasePath, P>, I, R>,
+        H<E3, MergePath<BasePath, P>, I2, R>,
+        H<E4, MergePath<BasePath, P>, I3, R>,
+        H<E5, MergePath<BasePath, P>, I4, R>
     ]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I4['in'], MergeTypedResponseData<R>>, BasePath>;
-    <P extends string, R extends HandlerResponse<any> = any, I extends Input = {}, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I2 & I3, I5 extends Input = I & I2 & I3 & I4, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E, Temp extends Env = E & E2 & E3 & E4 & E5>(path: P, ...handlers: [
-        H<E2, MergePath<BasePath, P>, I, E2, R>,
-        H<E3, MergePath<BasePath, P>, I2, E3, R>,
-        H<E4, MergePath<BasePath, P>, I3, E4, R>,
-        H<E5, MergePath<BasePath, P>, I4, E5, R>,
-        H<E6, MergePath<BasePath, P>, I5, Temp, R>
+    <P extends string, R extends HandlerResponse<any> = any, I extends Input = {}, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I2 & I3, I5 extends Input = I & I2 & I3 & I4, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5]>>(path: P, ...handlers: [
+        H<E2, MergePath<BasePath, P>, I, R>,
+        H<E3, MergePath<BasePath, P>, I2, R>,
+        H<E4, MergePath<BasePath, P>, I3, R>,
+        H<E5, MergePath<BasePath, P>, I4, R>,
+        H<E6, MergePath<BasePath, P>, I5, R>
     ]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I5['in'], MergeTypedResponseData<R>>, BasePath>;
-    <P extends string, I extends Input = {}, R extends HandlerResponse<any> = any>(path: P, ...handlers: H<E, MergePath<BasePath, P>, I, E, R>[]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I['in'], MergeTypedResponseData<R>>, BasePath>;
+    <P extends string, I extends Input = {}, R extends HandlerResponse<any> = any>(path: P, ...handlers: H<E, MergePath<BasePath, P>, I, R>[]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I['in'], MergeTypedResponseData<R>>, BasePath>;
 }
 export interface MiddlewareHandlerInterface<E extends Env = Env, S extends Schema = {}, BasePath extends string = '/'> {
-    (...handlers: MiddlewareHandler<E, MergePath<BasePath, ExtractKey<S>>>[]): Hono<E, S, BasePath>;
+    <E2 extends Env = E>(...handlers: MiddlewareHandler<E2, MergePath<BasePath, ExtractKey<S>>>[]): Hono<E, S, BasePath>;
     <P extends string, E2 extends Env = E>(path: P, ...handlers: MiddlewareHandler<E2, MergePath<BasePath, P>>[]): Hono<E, S, BasePath>;
 }
 export interface OnHandlerInterface<E extends Env = Env, S extends Schema = {}, BasePath extends string = '/'> {
-    <M extends string, P extends string, R extends HandlerResponse<any> = any, I extends Input = {}, E2 extends Env = E, E3 extends Env = E>(method: M, path: P, ...handlers: [
-        H<E2, MergePath<BasePath, P>, I, E2, R>,
-        H<E3, MergePath<BasePath, P>, I, E & E2, R>
-    ]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I['in'], MergeTypedResponseData<R>>, BasePath>;
-    <M extends string, P extends string, R extends HandlerResponse<any> = any, I extends Input = {}, I2 extends Input = I, I3 extends Input = I & I2, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E>(method: M, path: P, ...handlers: [
-        H<E2, MergePath<BasePath, P>, I, E2, R>,
-        H<E3, MergePath<BasePath, P>, I2, E3, R>,
-        H<E4, MergePath<BasePath, P>, I3, E & E2 & E3, R>
+    <M extends string, P extends string, R extends HandlerResponse<any> = any, I extends Input = {}, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>>(method: M, path: P, ...handlers: [H<E2, MergePath<BasePath, P>, I, R>, H<E3, MergePath<BasePath, P>, I, R>]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I['in'], MergeTypedResponseData<R>>, BasePath>;
+    <M extends string, P extends string, R extends HandlerResponse<any> = any, I extends Input = {}, I2 extends Input = I, I3 extends Input = I & I2, E2 extends Env = E, E3 extends Env = E, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>>(method: M, path: P, ...handlers: [
+        H<E2, MergePath<BasePath, P>, I, R>,
+        H<E3, MergePath<BasePath, P>, I2, R>,
+        H<E4, MergePath<BasePath, P>, I3, R>
     ]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I3['in'], MergeTypedResponseData<R>>, BasePath>;
-    <M extends string, P extends string, R extends HandlerResponse<any> = any, I extends Input = {}, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E>(method: M, path: P, ...handlers: [
-        H<E2, MergePath<BasePath, P>, I, E2, R>,
-        H<E3, MergePath<BasePath, P>, I2, E3, R>,
-        H<E4, MergePath<BasePath, P>, I3, E4, R>,
-        H<E5, MergePath<BasePath, P>, I4, E & E2 & E3 & E4, R>
+    <M extends string, P extends string, R extends HandlerResponse<any> = any, I extends Input = {}, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4]>>(method: M, path: P, ...handlers: [
+        H<E2, MergePath<BasePath, P>, I, R>,
+        H<E3, MergePath<BasePath, P>, I2, R>,
+        H<E4, MergePath<BasePath, P>, I3, R>,
+        H<E5, MergePath<BasePath, P>, I4, R>
     ]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I4['in'], MergeTypedResponseData<R>>, BasePath>;
-    <M extends string, P extends string, R extends HandlerResponse<any> = any, I extends Input = {}, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E>(method: M, path: P, ...handlers: [
-        H<E2, MergePath<BasePath, P>, I, E2, R>,
-        H<E3, MergePath<BasePath, P>, I2, E3, R>,
-        H<E4, MergePath<BasePath, P>, I3, E4, R>,
-        H<E5, MergePath<BasePath, P>, I4, E5, R>,
-        H<E6, MergePath<BasePath, P>, I5, E & E2 & E3 & E4 & E5, R>
+    <M extends string, P extends string, R extends HandlerResponse<any> = any, I extends Input = {}, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5]>>(method: M, path: P, ...handlers: [
+        H<E2, MergePath<BasePath, P>, I, R>,
+        H<E3, MergePath<BasePath, P>, I2, R>,
+        H<E4, MergePath<BasePath, P>, I3, R>,
+        H<E5, MergePath<BasePath, P>, I4, R>,
+        H<E6, MergePath<BasePath, P>, I5, R>
     ]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I5['in'], MergeTypedResponseData<R>>, BasePath>;
-    <M extends string, P extends string, R extends HandlerResponse<any> = any, I extends Input = {}>(method: M, path: P, ...handlers: H<E, MergePath<BasePath, P>, I, E, R>[]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I['in'], MergeTypedResponseData<R>>, BasePath>;
-    <P extends string, R extends HandlerResponse<any> = any, I extends Input = {}>(methods: string[], path: P, ...handlers: H<E, MergePath<BasePath, P>, I, E, R>[]): Hono<E, S & ToSchema<string, MergePath<BasePath, P>, I['in'], MergeTypedResponseData<R>>, BasePath>;
+    <M extends string, P extends string, R extends HandlerResponse<any> = any, I extends Input = {}>(method: M, path: P, ...handlers: H<E, MergePath<BasePath, P>, I, R>[]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I['in'], MergeTypedResponseData<R>>, BasePath>;
+    <P extends string, R extends HandlerResponse<any> = any, I extends Input = {}>(methods: string[], path: P, ...handlers: H<E, MergePath<BasePath, P>, I, R>[]): Hono<E, S & ToSchema<string, MergePath<BasePath, P>, I['in'], MergeTypedResponseData<R>>, BasePath>;
 }
 declare type ExtractKey<S> = S extends Record<infer Key, unknown> ? Key extends string ? Key : never : string;
 export declare type ToSchema<M extends string, P extends string, I extends Input['in'], O> = {

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

@@ -3,6 +3,8 @@ export declare type Equal<X, Y> = (<T>() => T extends X ? 1 : 2) extends <T>() =
 export declare type NotEqual<X, Y> = true extends Equal<X, Y> ? false : true;
 export declare type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
 export declare type RemoveBlankRecord<T> = T extends Record<infer K, unknown> ? K extends string ? T : never : never;
+export declare type IfAnyThenEmptyObject<T> = 0 extends 1 & T ? {} : T;
+export declare type IntersectNonAnyTypes<T extends any[]> = T extends [infer Head, ...infer Rest] ? IfAnyThenEmptyObject<Head> & IntersectNonAnyTypes<Rest> : {};
 export declare type JSONPrimitive = string | boolean | number | null | undefined;
 export declare type JSONArray = (JSONPrimitive | JSONObject | JSONArray)[];
 export declare type JSONObject = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hono",
-  "version": "3.6.1",
+  "version": "3.6.2",
   "description": "Ultrafast web framework for the Edges",
   "main": "dist/cjs/index.js",
   "type": "module",