hono 2.0.9 → 2.1.0

package/README.md

@@ -21,6 +21,7 @@
 [![GitHub commit activity](https://img.shields.io/github/commit-activity/m/honojs/hono)](https://github.com/honojs/hono/pulse)
 [![GitHub last commit](https://img.shields.io/github/last-commit/honojs/hono)](https://github.com/honojs/hono/commits/main)
 [![Deno badge](https://img.shields.io/endpoint?url=https%3A%2F%2Fdeno-visualizer.danopia.net%2Fshields%2Flatest-version%2Fx%2Fhono%2Fmod.ts)](https://doc.deno.land/https/deno.land/x/hono/mod.ts)
+[![Discord badge](https://img.shields.io/discord/1011308539819597844?label=Discord&logo=Discord)](https://discord.gg/KVYKWmfD)
 
 Hono - _**[炎] means flame🔥 in Japanese**_ - is a small, simple, and ultrafast web framework for Cloudflare Workers, Deno, Bun, and others.
 
@@ -46,13 +47,13 @@ export default app
 **Hono is fastest**, compared to other routers for Cloudflare Workers.
 
 ```plain
-hono - trie-router(default) x 424,449 ops/sec ±4.98% (77 runs sampled)
-hono - regexp-router x 516,228 ops/sec ±4.79% (81 runs sampled)
-itty-router x 206,641 ops/sec ±3.59% (87 runs sampled)
-sunder x 319,500 ops/sec ±1.33% (93 runs sampled)
-worktop x 187,280 ops/sec ±3.09% (87 runs sampled)
+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)
 Fastest is hono - regexp-router
-✨  Done in 38.32s.
+✨  Done in 38.26s.
 ```
 
 ## Documentation
@@ -63,6 +64,10 @@ The documentation is available on [honojs.dev](https://honojs.dev).
 
 Migration guide is available on [docs/MIGRATION.md](docs/MIGRATION.md).
 
+## Communication
+
+[Twitter](https://twitter.com/honojs) and [Discord channel](https://discord.gg/KVYKWmfD) are available.
+
 ## Contributing
 
 Contributions Welcome! You can contribute in the following ways.

package/dist/compose.d.ts

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

package/dist/context.d.ts

@@ -1,13 +1,12 @@
 /// <reference types="@cloudflare/workers-types" />
-import type { ContextVariableMap, NotFoundHandler } from './hono';
+import type { Environment, NotFoundHandler, ContextVariableMap, Bindings } 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;
-declare type Env = Record<string, any>;
-export interface Context<RequestParamKeyType extends string = string, E = Env> {
+export interface Context<RequestParamKeyType extends string = string, E extends Partial<Environment> = Environment> {
     req: Request<RequestParamKeyType>;
-    env: E;
+    env: E['Bindings'] | Bindings;
     event: FetchEvent;
     executionCtx: ExecutionContext;
     finalized: boolean;
@@ -17,10 +16,12 @@ export interface Context<RequestParamKeyType extends string = string, E = Env> {
     status: (status: StatusCode) => void;
     set: {
         <Key extends keyof ContextVariableMap>(key: Key, value: ContextVariableMap[Key]): void;
+        <Key extends keyof E['Variables']>(key: Key, value: E['Variables'][Key]): void;
         (key: string, value: any): void;
     };
     get: {
         <Key extends keyof ContextVariableMap>(key: Key): ContextVariableMap[Key];
+        <Key extends keyof E['Variables']>(key: Key): E['Variables'][Key];
         <T = any>(key: string): T;
     };
     pretty: (prettyJSON: boolean, space?: number) => void;
@@ -33,9 +34,9 @@ export interface Context<RequestParamKeyType extends string = string, E = Env> {
     cookie: (name: string, value: string, options?: CookieOptions) => void;
     notFound: () => Response | Promise<Response>;
 }
-export declare class HonoContext<RequestParamKeyType extends string = string, E = Env> implements Context<RequestParamKeyType, E> {
+export declare class HonoContext<RequestParamKeyType extends string = string, E extends Partial<Environment> = Environment> implements Context<RequestParamKeyType, E> {
     req: Request<RequestParamKeyType>;
-    env: E;
+    env: Environment['Bindings'];
     finalized: boolean;
     _status: StatusCode;
     private _executionCtx;
@@ -45,7 +46,7 @@ export declare class HonoContext<RequestParamKeyType extends string = string, E
     private _headers;
     private _res;
     private notFoundHandler;
-    constructor(req: Request, env?: E | undefined, executionCtx?: FetchEvent | ExecutionContext | undefined, notFoundHandler?: NotFoundHandler);
+    constructor(req: Request, env?: E['Bindings'] | undefined, executionCtx?: FetchEvent | ExecutionContext | undefined, notFoundHandler?: NotFoundHandler);
     get event(): FetchEvent;
     get executionCtx(): ExecutionContext;
     get res(): Response;
@@ -53,8 +54,10 @@ export declare class HonoContext<RequestParamKeyType extends string = string, E
     header(name: string, value: string): void;
     status(status: StatusCode): void;
     set<Key extends keyof ContextVariableMap>(key: Key, value: ContextVariableMap[Key]): void;
+    set<Key extends keyof E['Variables']>(key: Key, value: E['Variables'][Key]): void;
     set(key: string, value: any): void;
     get<Key extends keyof ContextVariableMap>(key: Key): ContextVariableMap[Key];
+    get<Key extends keyof E['Variables']>(key: Key): E['Variables'][Key];
     get<T = any>(key: string): T;
     pretty(prettyJSON: boolean, space?: number): void;
     newResponse(data: Data | null, status: StatusCode, headers?: Headers): Response;

package/dist/hono.d.ts

@@ -3,26 +3,31 @@ import type { Context } from './context';
 import type { Router } from './router';
 export interface ContextVariableMap {
 }
-declare type Env = Record<string, any>;
-export declare type Handler<RequestParamKeyType extends string = string, E = Env> = (c: Context<RequestParamKeyType, E>, next: Next) => Response | Promise<Response> | Promise<void> | Promise<Response | undefined>;
-export declare type NotFoundHandler<E = Env> = (c: Context<string, E>) => Response | Promise<Response>;
-export declare type ErrorHandler<E = Env> = (err: Error, c: Context<string, E>) => Response;
+export declare type Bindings = Record<string, any>;
+export declare type Variables = Record<string, any>;
+export declare type Environment = {
+    Bindings: Bindings;
+    Variables: Variables;
+};
+export declare type Handler<RequestParamKeyType extends string = string, E extends Partial<Environment> = Environment> = (c: Context<RequestParamKeyType, E>, next: Next) => Response | Promise<Response> | Promise<void> | Promise<Response | undefined>;
+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>;
 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 Env = Env, U = Hono<E, T>> {
+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;
     (...handlers: Handler<string, E>[]): U;
 }
-interface Route<E extends Env> {
+interface Route<E extends Partial<Environment> = Environment> {
     path: string;
     method: string;
     handler: Handler<string, E>;
 }
-declare const Hono_base: new <E_1 extends Env, T extends string, U>() => {
+declare const Hono_base: new <E_1 extends Partial<Environment> = Environment, T extends string = string, U = Hono<Environment, "/">>() => {
     all: HandlerInterface<T, E_1, U>;
     get: HandlerInterface<T, E_1, U>;
     post: HandlerInterface<T, E_1, U>;
@@ -32,7 +37,10 @@ declare const Hono_base: new <E_1 extends Env, T extends string, U>() => {
     options: HandlerInterface<T, E_1, U>;
     patch: HandlerInterface<T, E_1, U>;
 };
-export declare class Hono<E extends Env = Env, P extends string = '/'> extends Hono_base<E, P, Hono<E, P>> {
+export declare class Hono<E extends {
+    Bindings?: Bindings;
+    Variables?: Variables;
+} = Environment, P extends string = '/'> extends Hono_base<E, P, Hono<E, P>> {
     readonly router: Router<Handler<string, E>>;
     readonly strict: boolean;
     private _tempPath;
@@ -44,13 +52,13 @@ export declare class Hono<E extends Env = Env, P extends string = '/'> extends H
     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>;
-    onError(handler: ErrorHandler<E>): Hono<E, P>;
-    notFound(handler: NotFoundHandler<E>): Hono<E, P>;
+    onError(handler: ErrorHandler): Hono<E, P>;
+    notFound(handler: NotFoundHandler): Hono<E, P>;
     private addRoute;
     private matchRoute;
     private dispatch;
     handleEvent(event: FetchEvent): Promise<Response>;
-    fetch: (request: Request, env?: E, executionCtx?: ExecutionContext) => Promise<Response>;
+    fetch: (request: Request, Environment?: E["Bindings"] | undefined, executionCtx?: ExecutionContext | undefined) => Promise<Response>;
     request(input: RequestInfo, requestInit?: RequestInit): Promise<Response>;
 }
 export {};

package/dist/hono.js

@@ -29,8 +29,8 @@ class Hono extends defineDynamicClass() {
             const message = 'Internal Server Error';
             return c.text(message, 500);
         };
-        this.fetch = (request, env, executionCtx) => {
-            return this.dispatch(request, executionCtx, env);
+        this.fetch = (request, Environment, executionCtx) => {
+            return this.dispatch(request, executionCtx, Environment);
         };
         (0, request_1.extendRequestPrototype)();
         const allMethods = [...methods, router_1.METHOD_NAME_ALL_LOWERCASE];

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 /// <reference path="request.d.ts" />
 import { Hono } from './hono';
-export type { Handler, Next } from './hono';
+export type { Handler, Next, ContextVariableMap } from './hono';
 export type { Context } from './context';
 declare module './hono' {
     interface Hono {

package/dist/middleware/compress/index.d.ts

@@ -4,5 +4,5 @@ declare type EncodingType = 'gzip' | 'deflate';
 interface CompressionOptions {
     encoding?: EncodingType;
 }
-export declare const compress: (options?: CompressionOptions) => (ctx: Context, next: Next) => Promise<void>;
+export declare const compress: (options?: CompressionOptions | undefined) => (ctx: Context, next: Next) => Promise<void>;
 export {};

package/dist/middleware/cors/index.d.ts

@@ -8,5 +8,5 @@ declare type CORSOptions = {
     credentials?: boolean;
     exposeHeaders?: string[];
 };
-export declare const cors: (options?: CORSOptions) => (c: Context, next: Next) => Promise<void>;
+export declare const cors: (options?: CORSOptions | undefined) => (c: Context, next: Next) => Promise<void>;
 export {};

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

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

package/dist/request.d.ts

@@ -1,4 +1,3 @@
-import type { Body } from './utils/body';
 import type { Cookie } from './utils/cookie';
 declare global {
     interface Request<ParamKeyType extends string = string> {
@@ -23,9 +22,9 @@ declare global {
             (name: string): string;
             (): Cookie;
         };
-        parsedBody?: Promise<Body>;
+        parsedBody?: Promise<Record<string, string | File>>;
         parseBody: {
-            (): Promise<Body>;
+            (): Promise<Record<string, string | File>>;
         };
     }
 }

package/dist/request.js

@@ -69,10 +69,15 @@ function extendRequestPrototype() {
         }
     };
     Request.prototype.parseBody = function () {
+        let body;
         if (!this.parsedBody) {
-            this.parsedBody = (0, body_1.parseBody)(this);
+            body = (0, body_1.parseBody)(this);
+            this.parsedBody = body;
         }
-        return this.parsedBody;
+        else {
+            body = this.parsedBody;
+        }
+        return body;
     };
 }
 exports.extendRequestPrototype = extendRequestPrototype;

package/dist/router/trie-router/node.js

@@ -80,14 +80,13 @@ class Node {
         var _a, _b;
         return ((_a = node.handlerSetCache)[_b = `${method}:${wildcard ? '1' : '0'}`] || (_a[_b] = (() => {
             const handlerSets = [];
-            node.methods.map((m) => {
+            for (let i = 0, len = node.methods.length; i < len; i++) {
+                const m = node.methods[i];
                 const handlerSet = m[method] || m[router_1.METHOD_NAME_ALL];
                 if (handlerSet !== undefined) {
-                    const hs = { ...handlerSet };
-                    handlerSets.push(hs);
-                    return;
+                    handlerSets.push(handlerSet);
                 }
-            });
+            }
             return handlerSets;
         })()));
     }
@@ -115,7 +114,9 @@ class Node {
                         handlerSets.push(...this.getHandlerSets(nextNode, method));
                         matched = true;
                     }
-                    tempNodes.push(nextNode);
+                    else {
+                        tempNodes.push(nextNode);
+                    }
                 }
                 for (let k = 0, len3 = node.patterns.length; k < len3; k++) {
                     const pattern = node.patterns[k];
@@ -139,7 +140,9 @@ class Node {
                             if (isLast === true) {
                                 handlerSets.push(...this.getHandlerSets(node.children[key], method));
                             }
-                            tempNodes.push(node.children[key]);
+                            else {
+                                tempNodes.push(node.children[key]);
+                            }
                         }
                         // '/book/a'     => not-slug
                         // '/book/:slug' => slug
@@ -148,13 +151,17 @@ class Node {
                         if (typeof name === 'string' && !matched) {
                             params[name] = part;
                         }
+                        break;
                     }
                 }
             }
             curNodes = tempNodes;
         }
-        if (handlerSets.length <= 0)
+        const len = handlerSets.length;
+        if (len === 0)
             return null;
+        if (len === 1)
+            return { handlers: [handlerSets[0].handler], params };
         const handlers = handlerSets
             .sort((a, b) => {
             return a.score - b.score;

package/dist/utils/body.d.ts

@@ -1,2 +1 @@
-export declare type Body = string | object | Record<string, string | File> | ArrayBuffer;
-export declare const parseBody: (r: Request | Response) => Promise<Body>;
+export declare function parseBody(r: Request | Response): Promise<Record<string, string | File>>;

package/dist/utils/body.js

@@ -1,31 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseBody = void 0;
-const parseBody = async (r) => {
-    const contentType = r.headers.get('Content-Type') || '';
-    if (contentType.includes('application/json')) {
-        let body = {};
-        try {
-            body = await r.json();
-        }
-        catch { } // Do nothing
-        return body;
-    }
-    else if (contentType.includes('application/text')) {
-        return await r.text();
-    }
-    else if (contentType.startsWith('text')) {
-        return await r.text();
-    }
-    else if (contentType.includes('form')) {
+async function parseBody(r) {
+    let body = {};
+    const contentType = r.headers.get('Content-Type');
+    if (contentType &&
+        (contentType.startsWith('multipart/form-data') ||
+            contentType === 'application/x-www-form-urlencoded')) {
         const form = {};
-        const data = [...(await r.formData())].reduce((acc, cur) => {
+        body = [...(await r.formData())].reduce((acc, cur) => {
             acc[cur[0]] = cur[1];
             return acc;
         }, form);
-        return data;
     }
-    const arrayBuffer = await r.arrayBuffer();
-    return arrayBuffer;
-};
+    return body;
+}
 exports.parseBody = parseBody;

package/dist/utils/buffer.d.ts

@@ -1,3 +1,3 @@
 export declare const equal: (a: ArrayBuffer, b: ArrayBuffer) => boolean;
-export declare const timingSafeEqual: (a: string | object | boolean, b: string | object | boolean, hashFunction?: Function) => Promise<boolean>;
+export declare const timingSafeEqual: (a: string | object | boolean, b: string | object | boolean, hashFunction?: Function | undefined) => Promise<boolean>;
 export declare const bufferToString: (buffer: ArrayBuffer) => string;

package/dist/utils/cloudflare.d.ts

@@ -3,4 +3,4 @@ export declare type KVAssetOptions = {
     manifest?: object | string;
     namespace?: KVNamespace;
 };
-export declare const getContentFromKVAsset: (path: string, options?: KVAssetOptions) => Promise<ArrayBuffer | null>;
+export declare const getContentFromKVAsset: (path: string, options?: KVAssetOptions | undefined) => Promise<ArrayBuffer | null>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hono",
-  "version": "2.0.9",
+  "version": "2.1.0",
   "description": "Ultrafast web framework for Cloudflare Workers.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -155,7 +155,7 @@
     "eslint-plugin-node": "^11.1.0",
     "form-data": "^4.0.0",
     "jest": "27.5.1",
-    "jest-environment-miniflare": "^2.6.0",
+    "jest-environment-miniflare": "^2.7.0",
     "np": "^7.6.2",
     "prettier": "^2.6.2",
     "rimraf": "^3.0.2",