hono 2.1.1 → 2.1.4

package/README.md

@@ -47,13 +47,13 @@ export default app
 **Hono is fastest**, compared to other routers for Cloudflare Workers.
 
 ```plain
-hono - trie-router(default) x 437,354 ops/sec ±4.58% (83 runs sampled)
-hono - regexp-router x 535,157 ops/sec ±3.46% (83 runs sampled)
-itty-router x 203,092 ops/sec ±3.64% (89 runs sampled)
-sunder x 308,252 ops/sec ±2.17% (91 runs sampled)
-worktop x 190,764 ops/sec ±3.11% (86 runs sampled)
+hono - trie-router(default) x 482,004 ops/sec ±5.00% (79 runs sampled)
+hono - regexp-router x 604,006 ops/sec ±4.80% (81 runs sampled)
+itty-router x 203,623 ops/sec ±2.10% (94 runs sampled)
+sunder x 306,457 ops/sec ±2.49% (89 runs sampled)
+worktop x 189,450 ops/sec ±3.14% (88 runs sampled)
 Fastest is hono - regexp-router
-✨  Done in 38.26s.
+✨  Done in 36.79s.
 ```
 
 ## Documentation

package/dist/compose.d.ts

@@ -1,2 +1,7 @@
-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';
+interface ComposeContext {
+    finalized: boolean;
+    res: any;
+}
+export declare const compose: <C extends ComposeContext>(middleware: Function[], onNotFound?: NotFoundHandler<import("./hono").Environment> | undefined) => (context: C, next?: Function | undefined) => C | Promise<C>;
+export {};

package/dist/compose.js

@@ -3,12 +3,12 @@ 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;
         return dispatch(0);
-        async function dispatch(i) {
+        function dispatch(i) {
             if (i <= index) {
                 throw new Error('next() called multiple times');
             }
@@ -16,33 +16,32 @@ const compose = (middleware, onError, onNotFound) => {
             index = i;
             if (i === middlewareLength && next)
                 handler = next;
+            let res;
             if (!handler) {
                 if (context instanceof context_1.HonoContext && context.finalized === false && onNotFound) {
-                    context.res = await onNotFound(context);
+                    res = onNotFound(context);
                 }
-                return context;
             }
-            let res;
-            let isError = false;
-            try {
-                const tmp = handler(context, () => dispatch(i + 1));
-                res = tmp instanceof Promise ? await tmp : tmp;
+            else {
+                res = handler(context, () => {
+                    const dispatchRes = dispatch(i + 1);
+                    return dispatchRes instanceof Promise ? dispatchRes : Promise.resolve(dispatchRes);
+                });
             }
-            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 instanceof Promise)) {
+                if (res && context.finalized === false) {
+                    context.res = res;
                 }
+                return context;
             }
-            if (res && context instanceof context_1.HonoContext && (!context.finalized || isError)) {
-                context.res = res;
+            else {
+                return res.then((res) => {
+                    if (res && context.finalized === false) {
+                        context.res = res;
+                    }
+                    return context;
+                });
             }
-            return context;
         }
     };
 };

package/dist/context.d.ts

@@ -4,7 +4,7 @@ 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'];
     event: FetchEvent;

package/dist/context.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HonoContext = void 0;
+const hono_1 = require("./hono");
 const cookie_1 = require("./utils/cookie");
 const url_1 = require("./utils/url");
 class HonoContext {
@@ -10,7 +11,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;
     }
@@ -31,7 +32,7 @@ class HonoContext {
         }
     }
     get res() {
-        return (this._res || (this._res = new Response()));
+        return (this._res || (this._res = new Response(hono_1.defaultNotFoundMessage, { status: 404 })));
     }
     set res(_res) {
         this._res = _res;

package/dist/hono.d.ts

@@ -13,14 +13,15 @@ export declare type Handler<RequestParamKeyType extends string = string, E exten
 export declare type NotFoundHandler<E extends Partial<Environment> = Environment> = (c: Context<string, E>) => Response | Promise<Response>;
 export declare type ErrorHandler<E extends Partial<Environment> = Environment> = (err: Error, c: Context<string, E>) => Response;
 export declare type Next = () => Promise<void>;
+export declare const defaultNotFoundMessage = "404 Not Found";
 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 = string, E extends Partial<Environment> = Environment, U = Hono<E, T>> {
-    <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;
     <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 +38,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;

package/dist/hono.js

@@ -1,12 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Hono = void 0;
+exports.Hono = exports.defaultNotFoundMessage = void 0;
 const compose_1 = require("./compose");
 const context_1 = require("./context");
 const request_1 = require("./request");
 const router_1 = require("./router");
 const trie_router_1 = require("./router/trie-router"); // Default Router
 const url_1 = require("./utils/url");
+exports.defaultNotFoundMessage = '404 Not Found';
 const methods = ['get', 'post', 'put', 'delete', 'head', 'options', 'patch'];
 function defineDynamicClass() {
     return class {
@@ -21,7 +22,7 @@ class Hono extends defineDynamicClass() {
         this.path = '/';
         this.routes = [];
         this.notFoundHandler = (c) => {
-            const message = '404 Not Found';
+            const message = exports.defaultNotFoundMessage;
             return c.text(message, 404);
         };
         this.errorHandler = (err, c) => {
@@ -99,12 +100,32 @@ class Hono extends defineDynamicClass() {
         const method = request.method;
         const result = this.matchRoute(method, path);
         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);
+        // Do not `compose` if it has only one handler
+        if (result && result.handlers.length === 1) {
+            const handler = result.handlers[0];
+            try {
+                const res = handler(c, async () => { });
+                if (res) {
+                    const awaited = res instanceof Promise ? await res : res;
+                    if (awaited)
+                        return awaited;
+                }
+                return this.notFoundHandler(c);
+            }
+            catch (err) {
+                if (err instanceof Error) {
+                    return this.errorHandler(err, c);
+                }
+                throw err;
+            }
+        }
+        const handlers = result ? result.handlers : [this.notFoundHandler];
+        const composed = (0, compose_1.compose)(handlers, this.notFoundHandler);
         let context;
         try {
-            context = await composed(c);
+            const tmp = composed(c);
+            context = tmp instanceof Promise ? await tmp : tmp;
             if (!context.finalized) {
                 throw new Error('Context is not finalized. You may forget returning Response object or `await next()`');
             }

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

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

@@ -9,7 +9,7 @@ const DEFAULT_DOCUMENT = 'index.html';
 const serveStatic = (options = { root: '' }) => {
     return async (c, next) => {
         // Do nothing if Response is already set
-        if (c.res && c.finalized) {
+        if (c.finalized) {
             await next();
         }
         const url = new URL(c.req.url);

package/dist/request.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.extendRequestPrototype = void 0;
 const body_1 = require("./utils/body");
 const cookie_1 = require("./utils/cookie");
+const url_1 = require("./utils/url");
 function extendRequestPrototype() {
     if (!!Request.prototype.param) {
         // already extended
@@ -32,27 +33,29 @@ function extendRequestPrototype() {
         }
     };
     Request.prototype.query = function (key) {
-        const url = new URL(this.url);
+        const queryString = (0, url_1.getQueryStringFromURL)(this.url);
+        const searchParams = new URLSearchParams(queryString);
         if (key) {
-            return url.searchParams.get(key);
+            return searchParams.get(key);
         }
         else {
             const result = {};
-            for (const key of url.searchParams.keys()) {
-                result[key] = url.searchParams.get(key) || '';
+            for (const key of searchParams.keys()) {
+                result[key] = searchParams.get(key) || '';
             }
             return result;
         }
     };
     Request.prototype.queries = function (key) {
-        const url = new URL(this.url);
+        const queryString = (0, url_1.getQueryStringFromURL)(this.url);
+        const searchParams = new URLSearchParams(queryString);
         if (key) {
-            return url.searchParams.getAll(key);
+            return searchParams.getAll(key);
         }
         else {
             const result = {};
-            for (const key of url.searchParams.keys()) {
-                result[key] = url.searchParams.getAll(key);
+            for (const key of searchParams.keys()) {
+                result[key] = searchParams.getAll(key);
             }
             return result;
         }

package/dist/router/reg-exp-router/router.js

@@ -237,7 +237,9 @@ class RegExpRouter {
         return this.match(method, path);
     }
     buildAllMatchers() {
-        // @ts-ignore
+        if (!this.routeData) {
+            throw new Error('Can not call the buildAllMatchers since the matcher is already built.');
+        }
         this.routeData.routes.sort(({ hint: a }, { hint: b }) => {
             if (a.componentsLength !== b.componentsLength) {
                 return a.componentsLength - b.componentsLength;
@@ -263,21 +265,26 @@ class RegExpRouter {
         const primaryMatchers = {};
         const secondaryMatchers = {};
         let hasAmbiguous = false;
-        // @ts-ignore
         this.routeData.methods.forEach((method) => {
             let _hasAmbiguous;
             [primaryMatchers[method], secondaryMatchers[method], _hasAmbiguous] =
                 this.buildMatcher(method);
             hasAmbiguous = hasAmbiguous || _hasAmbiguous;
         });
+        if (hasAmbiguous) {
+            // rebuild all matchers with ambiguous flag
+            this.routeData.methods.forEach((method) => {
+                ;
+                [primaryMatchers[method], secondaryMatchers[method]] = this.buildMatcher(method, hasAmbiguous);
+            });
+        }
         primaryMatchers[router_1.METHOD_NAME_ALL] || (primaryMatchers[router_1.METHOD_NAME_ALL] = nullMatcher);
         secondaryMatchers[router_1.METHOD_NAME_ALL] || (secondaryMatchers[router_1.METHOD_NAME_ALL] = []);
         delete this.routeData; // to reduce memory usage
         return [primaryMatchers, secondaryMatchers, hasAmbiguous];
     }
-    buildMatcher(method) {
+    buildMatcher(method, hasAmbiguous = false) {
         var _a, _b;
-        let hasAmbiguous = false;
         const targetMethods = new Set([method, router_1.METHOD_NAME_ALL]);
         // @ts-ignore
         const routes = this.routeData.routes.filter(({ method }) => targetMethods.has(method));

package/dist/utils/url.d.ts

@@ -2,5 +2,6 @@ export declare type Pattern = readonly [string, string, RegExp | true] | '*';
 export declare const splitPath: (path: string) => string[];
 export declare const getPattern: (label: string) => Pattern | null;
 export declare const getPathFromURL: (url: string, strict?: boolean) => string;
+export declare const getQueryStringFromURL: (url: string) => string;
 export declare const isAbsoluteURL: (url: string) => boolean;
 export declare const mergePath: (...paths: string[]) => string;

package/dist/utils/url.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.mergePath = exports.isAbsoluteURL = exports.getPathFromURL = exports.getPattern = exports.splitPath = void 0;
+exports.mergePath = exports.isAbsoluteURL = exports.getQueryStringFromURL = exports.getPathFromURL = exports.getPattern = exports.splitPath = void 0;
 const URL_REGEXP = /^https?:\/\/[a-zA-Z0-9\-\.:]+(\/?[^?#]*)/;
 const splitPath = (path) => {
     const paths = path.split(/\//); // faster than path.split('/')
@@ -45,6 +45,12 @@ const getPathFromURL = (url, strict = true) => {
     return result;
 };
 exports.getPathFromURL = getPathFromURL;
+const getQueryStringFromURL = (url) => {
+    const queryIndex = url.indexOf('?');
+    const result = queryIndex !== -1 ? url.substring(queryIndex) : '';
+    return result;
+};
+exports.getQueryStringFromURL = getQueryStringFromURL;
 const isAbsoluteURL = (url) => {
     const match = url.match(URL_REGEXP);
     if (match) {

package/package.json

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