hono 2.1.0 → 2.1.3

package/dist/compose.d.ts

@@ -1,2 +1,2 @@
-import type { ErrorHandler, NotFoundHandler } from './hono';
-export declare const compose: <C>(middleware: Function[], onError?: ErrorHandler<import("./hono").Environment> | undefined, onNotFound?: NotFoundHandler<import("./hono").Environment> | undefined) => (context: C, next?: Function | undefined) => Promise<C>;
+import type { NotFoundHandler } from './hono';
+export declare const compose: <C>(middleware: Function[], onNotFound?: NotFoundHandler<import("./hono").Environment> | undefined) => (context: C, next?: Function | undefined) => Promise<C>;

package/dist/compose.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.compose = void 0;
 const context_1 = require("./context");
 // Based on the code in the MIT licensed `koa-compose` package.
-const compose = (middleware, onError, onNotFound) => {
+const compose = (middleware, onNotFound) => {
     const middlewareLength = middleware.length;
     return (context, next) => {
         let index = -1;
@@ -22,24 +22,9 @@ const compose = (middleware, onError, onNotFound) => {
                 }
                 return context;
             }
-            let res;
-            let isError = false;
-            try {
-                const tmp = handler(context, () => dispatch(i + 1));
-                res = tmp instanceof Promise ? await tmp : tmp;
-            }
-            catch (err) {
-                if (context instanceof context_1.HonoContext && onError) {
-                    if (err instanceof Error) {
-                        isError = true;
-                        res = onError(err, context);
-                    }
-                }
-                if (!res) {
-                    throw err;
-                }
-            }
-            if (res && context instanceof context_1.HonoContext && (!context.finalized || isError)) {
+            const tmp = handler(context, () => dispatch(i + 1));
+            const res = tmp instanceof Promise ? await tmp : tmp;
+            if (res && context instanceof context_1.HonoContext && context.finalized === false) {
                 context.res = res;
             }
             return context;

package/dist/context.d.ts

@@ -1,12 +1,12 @@
 /// <reference types="@cloudflare/workers-types" />
-import type { Environment, NotFoundHandler, ContextVariableMap, Bindings } from './hono';
+import type { Environment, NotFoundHandler, ContextVariableMap } from './hono';
 import type { CookieOptions } from './utils/cookie';
 import type { StatusCode } from './utils/http-status';
 declare type Headers = Record<string, string>;
 export declare type Data = string | ArrayBuffer | ReadableStream;
-export interface Context<RequestParamKeyType extends string = string, E extends Partial<Environment> = Environment> {
+export interface Context<RequestParamKeyType extends string = string, E extends Partial<Environment> = any> {
     req: Request<RequestParamKeyType>;
-    env: E['Bindings'] | Bindings;
+    env: E['Bindings'];
     event: FetchEvent;
     executionCtx: ExecutionContext;
     finalized: boolean;
@@ -36,7 +36,7 @@ export interface Context<RequestParamKeyType extends string = string, E extends
 }
 export declare class HonoContext<RequestParamKeyType extends string = string, E extends Partial<Environment> = Environment> implements Context<RequestParamKeyType, E> {
     req: Request<RequestParamKeyType>;
-    env: Environment['Bindings'];
+    env: E['Bindings'];
     finalized: boolean;
     _status: StatusCode;
     private _executionCtx;

package/dist/context.js

@@ -10,7 +10,7 @@ class HonoContext {
         this._prettySpace = 2;
         this._executionCtx = executionCtx;
         this.req = req;
-        this.env = env ? env : {};
+        this.env = env || {};
         this.notFoundHandler = notFoundHandler;
         this.finalized = false;
     }

package/dist/hono.d.ts

@@ -16,11 +16,11 @@ export declare type Next = () => Promise<void>;
 declare type ParamKeyName<NameWithPattern> = NameWithPattern extends `${infer Name}{${infer _Pattern}` ? Name : NameWithPattern;
 declare type ParamKey<Component> = Component extends `:${infer NameWithPattern}` ? ParamKeyName<NameWithPattern> : never;
 declare type ParamKeys<Path> = Path extends `${infer Component}/${infer Rest}` ? ParamKey<Component> | ParamKeys<Rest> : ParamKey<Path>;
-interface HandlerInterface<T extends string, E extends Partial<Environment> = Environment, U = Hono<E, T>> {
-    <Path extends string>(path: Path, ...handlers: Handler<ParamKeys<Path> extends never ? string : ParamKeys<Path>, E>[]): U;
-    (path: string, ...handlers: Handler<string, E>[]): U;
-    <Path extends string>(...handlers: Handler<ParamKeys<Path> extends never ? string : ParamKeys<Path>, E>[]): U;
+interface HandlerInterface<T extends string = string, E extends Partial<Environment> = Environment, U = Hono<E, T>> {
+    <Path extends string, Env extends Partial<Environment> = E>(...handlers: Handler<ParamKeys<Path> extends never ? string : ParamKeys<Path>, Env>[]): U;
     (...handlers: Handler<string, E>[]): U;
+    <Path extends string, Env extends Partial<Environment> = E>(path: Path, ...handlers: Handler<ParamKeys<Path> extends never ? string : ParamKeys<Path>, Env>[]): U;
+    (path: string, ...handlers: Handler<string, E>[]): U;
 }
 interface Route<E extends Partial<Environment> = Environment> {
     path: string;
@@ -37,10 +37,7 @@ declare const Hono_base: new <E_1 extends Partial<Environment> = Environment, T
     options: HandlerInterface<T, E_1, U>;
     patch: HandlerInterface<T, E_1, U>;
 };
-export declare class Hono<E extends {
-    Bindings?: Bindings;
-    Variables?: Variables;
-} = Environment, P extends string = '/'> extends Hono_base<E, P, Hono<E, P>> {
+export declare class Hono<E extends Partial<Environment> = Environment, P extends string = '/'> extends Hono_base<E, P, Hono<E, P>> {
     readonly router: Router<Handler<string, E>>;
     readonly strict: boolean;
     private _tempPath;
@@ -50,8 +47,8 @@ export declare class Hono<E extends {
     private notFoundHandler;
     private errorHandler;
     route(path: string, app?: Hono<any>): Hono<E, P>;
-    use(path: string, ...middleware: Handler<string, E>[]): Hono<E, P>;
-    use(...middleware: Handler<string, E>[]): Hono<E, P>;
+    use<Path extends string = string, Env extends Partial<Environment> = E>(...middleware: Handler<Path, Env>[]): Hono<Env, Path>;
+    use<Path extends string = string, Env extends Partial<Environment> = E>(arg1: string, ...middleware: Handler<Path, Env>[]): Hono<Env, Path>;
     onError(handler: ErrorHandler): Hono<E, P>;
     notFound(handler: NotFoundHandler): Hono<E, P>;
     private addRoute;

package/dist/hono.js

@@ -101,7 +101,7 @@ class Hono extends defineDynamicClass() {
         request.paramData = result?.params;
         const handlers = result ? result.handlers : [this.notFoundHandler];
         const c = new context_1.HonoContext(request, env, eventOrExecutionCtx, this.notFoundHandler);
-        const composed = (0, compose_1.compose)(handlers, this.errorHandler, this.notFoundHandler);
+        const composed = (0, compose_1.compose)(handlers, this.notFoundHandler);
         let context;
         try {
             context = await composed(c);

package/dist/middleware/serve-static/module.d.mts

@@ -1,3 +1,3 @@
 import type { ServeStaticOptions } from './serve-static';
-declare const module: (options?: ServeStaticOptions) => import("../../hono").Handler<string, import("../../hono").Environment>;
+declare const module: (options?: ServeStaticOptions) => (c: import("../../context").Context<string, any>, next: import("../../hono").Next) => Promise<Response | undefined>;
 export { module as serveStatic };

package/dist/middleware/serve-static/serve-static.d.ts

@@ -1,9 +1,10 @@
 /// <reference types="@cloudflare/workers-types" />
-import type { Handler } from '../../hono';
+import type { Context } from '../../context';
+import type { Next } from '../../hono';
 export declare type ServeStaticOptions = {
     root?: string;
     path?: string;
     manifest?: object | string;
     namespace?: KVNamespace;
 };
-export declare const serveStatic: (options?: ServeStaticOptions) => Handler;
+export declare const serveStatic: (options?: ServeStaticOptions) => (c: Context, next: Next) => Promise<Response | undefined>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hono",
-  "version": "2.1.0",
+  "version": "2.1.3",
   "description": "Ultrafast web framework for Cloudflare Workers.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",