hono 0.3.5 → 0.4.0

package/README.md

@@ -1,6 +1,6 @@
 # Hono
 
-Hono[炎] - _**means flame🔥 in Japanese**_ - is small, simple, and ultrafast web flamework for a Service Workers API based serverless such as Cloudflare Workers and Fastly Compute@Edge.
+Hono[炎] - _**means flame🔥 in Japanese**_ - is small, simple, and ultrafast web framework for a Service Workers API based serverless such as Cloudflare Workers and Fastly Compute@Edge.
 
 ```js
 import { Hono } from 'hono'
@@ -13,7 +13,7 @@ app.fire()
 
 ## Features
 
-- **Ultra fast** - the router is implemented with Trie-Tree structure.
+- **Ultra fast** - the router is implemented with Trie-Tree structure. Not use loops.
 - **Zero dependencies** - using only Web standard API.
 - **Middleware** - builtin middleware, and you can make your own middleware.
 - **Optimized** - for Cloudflare Workers.
@@ -37,9 +37,13 @@ Below is a demonstration to create an application of Cloudflare Workers with Hon
 
 ![Demo](https://user-images.githubusercontent.com/10682/151973526-342644f9-71c5-4fee-81f4-64a7558bb192.gif)
 
+Now, the named path parameter has types.
+
+![Demo](https://user-images.githubusercontent.com/10682/154179671-9e491597-6778-44ac-a8e6-4483d7ad5393.png)
+
 ## Install
 
-You can install from npm registry:
+You can install Hono from npm registry:
 
 ```sh
 yarn add hono
@@ -53,7 +57,7 @@ npm install hono
 
 ## Methods
 
-Instance of `Hono` has these methods:
+An instance of `Hono` has these methods:
 
 - app.**HTTP_METHOD**(path, handler)
 - app.**all**(path, handler)
@@ -104,14 +108,17 @@ app.get('/post/:date{[0-9]+}/:title{[a-z]+}', (c) => {
   ...
 ```
 
-### Chained Route
+### Nested route
 
 ```js
-app
-  .route('/api/book')
-    .get(() => {...})
-    .post(() => {...})
-    .put(() => {...})
+const book = app.route('/book')
+book.get('/', (c) => c.text('List Books')) // => GET /book
+book.get('/:id', (c) => {
+  // => GET /book/:id
+  const id = c.req.param('id')
+  return c.text('Get Book: ' + id)
+})
+book.post('/', (c) => c.text('Create Book')) // => POST /book
 ```
 
 ### Custom 404 Response
@@ -124,6 +131,18 @@ app.get('*', (c) => {
 })
 ```
 
+### no strict
+
+If `strict` is set `false`, `/hello`and`/hello/` are treated the same:
+
+```js
+const app = new Hono({ strict: false })
+
+app.get('/hello', (c) => c.text('/hello or /hello/'))
+```
+
+Default is `true`.
+
 ## async/await
 
 ```js
@@ -147,15 +166,7 @@ const app = new Hono()
 
 app.use('*', poweredBy())
 app.use('*', logger())
-app.use(
-  '/auth/*',
-  basicAuth({
-    username: 'hono',
-    password: 'acoolproject',
-  })
-)
-
-...
+app.use('/auth/*', basicAuth({ username: 'hono', password: 'acoolproject' }))
 ```
 
 Available builtin middleware are listed on [src/middleware](https://github.com/yusukebe/hono/tree/master/src/middleware).
@@ -174,7 +185,7 @@ app.use('*', async (c, next) => {
 // Add a custom header
 app.use('/message/*', async (c, next) => {
   await next()
-  await c.res.headers.add('x-message', 'This is middleware!')
+  await c.header('x-message', 'This is middleware!')
 })
 
 app.get('/message/hello', (c) => c.text('Hello Middleware!'))
@@ -193,30 +204,9 @@ app.use('*', async (c, next) => {
 })
 ```
 
-### Complex Pattern
-
-You can also do this:
-
-```js
-// Output response time
-app.use('*', async (c, next) => {
-  await next()
-  const responseTime = await c.res.headers.get('X-Response-Time')
-  console.log(`X-Response-Time: ${responseTime}`)
-})
-
-// Add X-Response-Time header
-app.use('*', async (c, next) => {
-  const start = Date.now()
-  await next()
-  const ms = Date.now() - start
-  await c.res.headers.append('X-Response-Time', `${ms}ms`)
-})
-```
-
 ## Context
 
-To handle Request and Reponse easily, you can use Context object:
+To handle Request and Reponse, you can use Context object:
 
 ### c.req
 
@@ -253,7 +243,6 @@ app.get('/welcome', (c) => {
   c.header('X-Message', 'Hello!')
   c.header('Content-Type', 'text/plain')
   c.status(201)
-  c.statusText('201 Content Created')
 
   return c.body('Thank you for comming')
 
@@ -261,7 +250,7 @@ app.get('/welcome', (c) => {
   Same as:
   return new Response('Thank you for comming', {
     status: 201,
-    statusText: '201 Content Created',
+    statusText: 'Created',
     headers: {
       'X-Message': 'Hello',
       'Content-Type': 'text/plain',
@@ -431,7 +420,7 @@ Run the development server locally. Then, access like `http://127.0.0.1:8787/` i
 wrangler dev
 ```
 
-### Publish
+### 7. Publish
 
 Deploy to Cloudflare. That's all!
 
@@ -462,6 +451,10 @@ Contributions Welcome! You can contribute by the following way:
 
 If you can, let's make Hono together!
 
+## Contributors
+
+Thanks to [all contributors](https://github.com/yusukebe/hono/graphs/contributors)!
+
 ## Author
 
 Yusuke Wada <https://github.com/yusukebe>

package/dist/compose.d.ts

@@ -1 +1 @@
-export declare const compose: (middleware: any) => (context: any, next?: Function) => any;
+export declare const compose: <T>(middleware: Function[]) => (context: T, next?: Function) => Promise<void | object>;

package/dist/compose.js

@@ -7,7 +7,7 @@ const compose = (middleware) => {
     return function (context, next) {
         let index = -1;
         return dispatch(0);
-        function dispatch(i) {
+        async function dispatch(i) {
             if (i <= index)
                 return Promise.reject(new Error('next() called multiple times'));
             index = i;

package/dist/context.d.ts

@@ -1,11 +1,10 @@
 /// <reference types="@cloudflare/workers-types" />
-declare type Headers = {
-    [key: string]: string;
-};
+declare type Headers = Record<string, string>;
+declare type Data = string | ArrayBuffer | ReadableStream;
 export interface Env {
 }
-export declare class Context {
-    req: Request;
+export declare class Context<RequestParamKeyType = string> {
+    req: Request<RequestParamKeyType>;
     res: Response;
     env: Env;
     event: FetchEvent;
@@ -13,16 +12,15 @@ export declare class Context {
     private _status;
     private _statusText;
     render: (template: string, params?: object, options?: object) => Promise<Response>;
-    constructor(req: Request, opts?: {
+    constructor(req: Request<RequestParamKeyType>, opts?: {
         res: Response;
         env: Env;
         event: FetchEvent;
     });
     header(name: string, value: string): void;
     status(number: number): void;
-    statusText(text: string): void;
-    newResponse(data: any, init?: ResponseInit): Response;
-    body(data: any, status?: number, headers?: Headers): Response;
+    newResponse(data: Data, init?: ResponseInit): Response;
+    body(data: Data, status?: number, headers?: Headers): Response;
     text(text: string, status?: number, headers?: Headers): Response;
     json(object: object, status?: number, headers?: Headers): Response;
     html(html: string, status?: number, headers?: Headers): Response;

package/dist/context.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Context = void 0;
 const url_1 = require("./utils/url");
+const http_status_1 = require("./utils/http-status");
 class Context {
     constructor(req, opts) {
         this.req = req;
@@ -13,13 +14,25 @@ class Context {
         this._headers = {};
     }
     header(name, value) {
+        /*
+        XXX:
+        app.use('*', (c, next) => {
+          next()
+          c.header('foo', 'bar') // => c.res.headers.set(...)
+        })
+        */
+        if (this.res) {
+            this.res.headers.set(name, value);
+        }
         this._headers[name] = value;
     }
     status(number) {
+        if (this.res) {
+            console.warn('c.res.status is already set.');
+            return;
+        }
         this._status = number;
-    }
-    statusText(text) {
-        this._statusText = text;
+        this._statusText = (0, http_status_1.getStatusText)(number);
     }
     newResponse(data, init = {}) {
         init.status = init.status || this._status;
@@ -35,9 +48,6 @@ class Context {
                 const Encoder = new TextEncoder();
                 length = Encoder.encode(data).byteLength || 0;
             }
-            else {
-                length = data.bytelength;
-            }
         }
         init.headers = Object.assign(Object.assign({}, init.headers), { 'Content-Length': length.toString() });
         return new Response(data, init);

package/dist/hono.d.ts

@@ -4,42 +4,50 @@ import { Node } from './node';
 import { Context } from './context';
 import type { Env } from './context';
 declare global {
-    interface Request {
-        param: (key: string) => string;
-        query: (key: string) => string | null;
+    interface Request<ParamKeyType = string> {
+        param: (key: ParamKeyType) => string;
+        query: (key: string) => string;
         header: (name: string) => string;
         parsedBody: any;
     }
 }
-export declare type Handler = (c: Context, next?: Function) => Response | Promise<Response>;
+export declare type Handler<RequestParamKeyType = string> = (c: Context<RequestParamKeyType>, next?: Function) => Response | Promise<Response>;
 export declare type MiddlewareHandler = (c: Context, next: Function) => 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>;
 export declare class Router<T> {
     node: Node<T>;
     constructor();
     add(method: string, path: string, handler: T): void;
     match(method: string, path: string): Result<T> | null;
 }
+declare type Init = {
+    strict?: boolean;
+};
 export declare class Hono {
     router: Router<Handler[]>;
     middlewareRouters: Router<MiddlewareHandler>[];
     tempPath: string;
-    constructor();
-    get(arg: string | Handler, ...args: Handler[]): Hono;
-    post(arg: string | Handler, ...args: Handler[]): Hono;
-    put(arg: string | Handler, ...args: Handler[]): Hono;
-    head(arg: string | Handler, ...args: Handler[]): Hono;
-    delete(arg: string | Handler, ...args: Handler[]): Hono;
-    options(arg: string | Handler, ...args: Handler[]): Hono;
-    patch(arg: string | Handler, ...args: Handler[]): Hono;
-    all(arg: string | Handler, ...args: Handler[]): Hono;
+    strict: boolean;
+    constructor(init?: Init);
+    get<Path extends string>(path: Path, ...args: Handler<ParamKeys<Path>>[]): Hono;
+    post<Path extends string>(path: Path, ...args: Handler<ParamKeys<Path>>[]): Hono;
+    put<Path extends string>(path: Path, ...args: Handler<ParamKeys<Path>>[]): Hono;
+    head<Path extends string>(path: Path, ...args: Handler<ParamKeys<Path>>[]): Hono;
+    delete<Path extends string>(path: Path, ...args: Handler<ParamKeys<Path>>[]): Hono;
+    options<Path extends string>(path: Path, ...args: Handler<ParamKeys<Path>>[]): Hono;
+    patch<Path extends string>(path: Path, ...args: Handler<ParamKeys<Path>>[]): Hono;
+    all<Path extends string>(path: Path, ...args: Handler<ParamKeys<Path>>[]): Hono;
     route(path: string): Hono;
     use(path: string, middleware: MiddlewareHandler): void;
-    addRoute(method: string, arg: string | Handler, ...args: Handler[]): Hono;
+    addRoute(method: string, path: string, ...args: Handler[]): Hono;
     matchRoute(method: string, path: string): Promise<Result<Handler[]>>;
     dispatch(request: Request, env?: Env, event?: FetchEvent): Promise<Response>;
     handleEvent(event: FetchEvent): Promise<Response>;
     fetch(request: Request, env?: Env, event?: FetchEvent): Promise<Response>;
     fire(): void;
-    onError(err: any): Response;
+    onError(err: Error): Response;
     notFound(): Response;
 }
+export {};

package/dist/hono.js

@@ -4,9 +4,7 @@ exports.Hono = exports.Router = void 0;
 const node_1 = require("./node");
 const compose_1 = require("./compose");
 const url_1 = require("./utils/url");
-const middleware_1 = require("./middleware");
 const context_1 = require("./context");
-const METHOD_NAME_OF_ALL = 'ALL';
 class Router {
     constructor() {
         this.node = new node_1.Node();
@@ -20,102 +18,95 @@ class Router {
 }
 exports.Router = Router;
 class Hono {
-    constructor() {
+    constructor(init = { strict: true }) {
         this.router = new Router();
         this.middlewareRouters = [];
-        this.tempPath = '/';
-    }
-    /* HTTP METHODS */
-    get(arg, ...args) {
-        return this.addRoute('get', arg, ...args);
-    }
-    post(arg, ...args) {
-        return this.addRoute('post', arg, ...args);
-    }
-    put(arg, ...args) {
-        return this.addRoute('put', arg, ...args);
-    }
-    head(arg, ...args) {
-        return this.addRoute('head', arg, ...args);
-    }
-    delete(arg, ...args) {
-        return this.addRoute('delete', arg, ...args);
-    }
-    options(arg, ...args) {
-        return this.addRoute('options', arg, ...args);
-    }
-    patch(arg, ...args) {
-        return this.addRoute('patch', arg, ...args);
-    }
-    /*
-    We may implement these HTTP methods:
-    trace
-    copy
-    lock
-    purge
-    unlock
-    report
-    checkout
-    merge
-    notify
-    subscribe
-    unsubscribe
-    search
-    connect
-    */
-    all(arg, ...args) {
-        return this.addRoute('all', arg, ...args);
+        this.tempPath = null;
+        this.strict = init.strict; // strict routing - default is true
+    }
+    get(path, ...args) {
+        return this.addRoute('get', path, ...args);
+    }
+    post(path, ...args) {
+        return this.addRoute('post', path, ...args);
+    }
+    put(path, ...args) {
+        return this.addRoute('put', path, ...args);
+    }
+    head(path, ...args) {
+        return this.addRoute('head', path, ...args);
+    }
+    delete(path, ...args) {
+        return this.addRoute('delete', path, ...args);
+    }
+    options(path, ...args) {
+        return this.addRoute('options', path, ...args);
+    }
+    patch(path, ...args) {
+        return this.addRoute('patch', path, ...args);
+    }
+    all(path, ...args) {
+        return this.addRoute('all', path, ...args);
     }
     route(path) {
-        this.tempPath = path;
-        return this;
+        const newHono = new Hono();
+        newHono.tempPath = path;
+        newHono.router = this.router;
+        return newHono;
     }
     use(path, middleware) {
         if (middleware.constructor.name !== 'AsyncFunction') {
             throw new TypeError('middleware must be a async function!');
         }
         const router = new Router();
-        router.add(METHOD_NAME_OF_ALL, path, middleware);
+        router.add(node_1.METHOD_NAME_OF_ALL, path, middleware);
         this.middlewareRouters.push(router);
     }
     // addRoute('get', '/', handler)
-    addRoute(method, arg, ...args) {
+    addRoute(method, path, ...args) {
         method = method.toUpperCase();
-        if (typeof arg === 'string') {
-            this.tempPath = arg;
-            this.router.add(method, arg, args);
-        }
-        else {
-            args.unshift(arg);
-            this.router.add(method, this.tempPath, args);
+        if (this.tempPath) {
+            path = (0, url_1.mergePath)(this.tempPath, path);
         }
+        this.router.add(method, path, args);
         return this;
     }
     async matchRoute(method, path) {
         return this.router.match(method, path);
     }
     async dispatch(request, env, event) {
-        const [method, path] = [request.method, (0, url_1.getPathFromURL)(request.url)];
+        const path = (0, url_1.getPathFromURL)(request.url, { strict: this.strict });
+        const method = request.method;
         const result = await this.matchRoute(method, path);
+        // Methods for Request object
         request.param = (key) => {
             if (result) {
                 return result.params[key];
             }
-            return '';
+        };
+        request.header = (name) => {
+            return request.headers.get(name);
+        };
+        request.query = (key) => {
+            const url = new URL(c.req.url);
+            return url.searchParams.get(key);
         };
         const handler = result ? result.handler[0] : this.notFound; // XXX
         const middleware = [];
         for (const mr of this.middlewareRouters) {
-            const mwResult = mr.match(METHOD_NAME_OF_ALL, path);
+            const mwResult = mr.match(node_1.METHOD_NAME_OF_ALL, path);
             if (mwResult) {
                 middleware.push(mwResult.handler);
             }
         }
         const wrappedHandler = async (context, next) => {
-            context.res = await handler(context);
+            const res = await handler(context);
+            if (!(res instanceof Response)) {
+                throw new TypeError('response must be a instace of Response');
+            }
+            context.res = res;
             await next();
         };
-        middleware.push(middleware_1.Middleware.default);
         middleware.push(wrappedHandler);
         const composed = (0, compose_1.compose)(middleware);
         const c = new context_1.Context(request, { env: env, event: event, res: null });
@@ -149,7 +140,7 @@ class Hono {
     }
     notFound() {
         const message = 'Not Found';
-        return new Response('Not Found', {
+        return new Response(message, {
             status: 404,
             headers: {
                 'Content-Length': message.length.toString(),

package/dist/middleware/mustache/mustache.d.ts

@@ -1,6 +1,6 @@
 import type { Context } from '../../context';
-declare type Options = {
+declare type Init = {
     root: string;
 };
-export declare const mustache: (opt?: Options) => (c: Context, next: Function) => Promise<void>;
+export declare const mustache: (init?: Init) => (c: Context, next: Function) => Promise<void>;
 export {};

package/dist/middleware/mustache/mustache.js

@@ -4,8 +4,8 @@ exports.mustache = void 0;
 const cloudflare_1 = require("../../utils/cloudflare");
 const EXTENSION = '.mustache';
 const DEFAULT_DOCUMENT = 'index.mustache';
-const mustache = (opt = { root: '' }) => {
-    const { root } = opt;
+const mustache = (init = { root: '' }) => {
+    const { root } = init;
     return async (c, next) => {
         let Mustache;
         try {
@@ -14,8 +14,12 @@ const mustache = (opt = { root: '' }) => {
         catch (_a) {
             throw new Error('If you want to use Mustache Middleware, install "mustache" package first.');
         }
-        c.render = async (filename, view = {}, options) => {
-            const path = (0, cloudflare_1.getKVFilePath)({ filename: `${filename}${EXTENSION}`, root: root, defaultDocument: DEFAULT_DOCUMENT });
+        c.render = async (filename, params = {}, options) => {
+            const path = (0, cloudflare_1.getKVFilePath)({
+                filename: `${filename}${EXTENSION}`,
+                root: root,
+                defaultDocument: DEFAULT_DOCUMENT,
+            });
             const buffer = await (0, cloudflare_1.getContentFromKVAsset)(path);
             if (!buffer) {
                 throw new Error(`Template "${path}" is not found or blank.`);
@@ -37,7 +41,7 @@ const mustache = (opt = { root: '' }) => {
                     partialArgs[key] = bufferToString(partialBuffer);
                 }
             }
-            const output = Mustache.render(content, view, partialArgs);
+            const output = Mustache.render(content, params, partialArgs);
             return c.html(output);
         };
         await next();

package/dist/node.d.ts

@@ -1,24 +1,15 @@
+export declare const METHOD_NAME_OF_ALL = "ALL";
 export declare class Result<T> {
     handler: T;
-    params: {
-        [key: string]: string;
-    };
-    constructor(handler: T, params: {
-        [key: string]: string;
-    });
+    params: Record<string, string>;
+    constructor(handler: T, params: Record<string, string>);
 }
 export declare class Node<T> {
-    method: {
-        [key: string]: T;
-    };
+    method: Record<string, T>;
     handler: T;
-    children: {
-        [key: string]: Node<T>;
-    };
+    children: Record<string, Node<T>>;
     middlewares: [];
-    constructor(method?: string, handler?: any, children?: {
-        [key: string]: Node<T>;
-    });
+    constructor(method?: string, handler?: T, children?: Record<string, Node<T>>);
     insert(method: string, path: string, handler: T): Node<T>;
     search(method: string, path: string): Result<T>;
 }

package/dist/node.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Node = exports.Result = void 0;
+exports.Node = exports.Result = exports.METHOD_NAME_OF_ALL = void 0;
 const url_1 = require("./utils/url");
-const METHOD_NAME_OF_ALL = 'ALL';
+exports.METHOD_NAME_OF_ALL = 'ALL';
 class Result {
     constructor(handler, params) {
         this.handler = handler;
@@ -95,7 +95,7 @@ class Node {
                 return noRoute();
             }
         }
-        const handler = curNode.method[METHOD_NAME_OF_ALL] || curNode.method[method];
+        const handler = curNode.method[exports.METHOD_NAME_OF_ALL] || curNode.method[method];
         if (!handler) {
             return noRoute();
         }

package/dist/utils/buffer.d.ts

@@ -1,4 +1,4 @@
 export declare const equal: (a: ArrayBuffer, b: ArrayBuffer) => boolean;
 export declare const decodeBase64: (str: string) => any;
-export declare const sha256: (a: string) => Promise<string>;
-export declare const timingSafeEqual: (a: any, b: any) => Promise<boolean>;
+export declare const sha256: (a: string | object | boolean) => Promise<string>;
+export declare const timingSafeEqual: (a: string | object | boolean, b: string | object | boolean) => Promise<boolean>;

package/dist/utils/http-status.d.ts

@@ -0,0 +1 @@
+export declare const getStatusText: (statusNumber: number) => string;

package/dist/utils/http-status.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getStatusText = void 0;
+const getStatusText = (statusNumber) => {
+    const text = statuses[statusNumber];
+    return text;
+};
+exports.getStatusText = getStatusText;
+const statuses = {
+    200: 'OK',
+    201: 'Created',
+    202: 'Accepted',
+    204: 'No Content',
+    206: 'Partial Content',
+    301: 'Moved Permanently',
+    302: 'Moved Temporarily',
+    303: 'See Other',
+    304: 'Not Modified',
+    307: 'Temporary Redirect',
+    308: 'Permanent Redirect',
+    400: 'Bad Request',
+    401: 'Unauthorized',
+    402: 'Payment Required',
+    403: 'Forbidden',
+    404: 'Not Found',
+    405: 'Not Allowed',
+    406: 'Not Acceptable',
+    408: 'Request Time-out',
+    409: 'Conflict',
+    410: 'Gone',
+    411: 'Length Required',
+    412: 'Precondition Failed',
+    413: 'Request Entity Too Large',
+    414: 'Request-URI Too Large',
+    415: 'Unsupported Media Type',
+    416: 'Requested Range Not Satisfiable',
+    421: 'Misdirected Request',
+    429: 'Too Many Requests',
+    500: 'Internal Server Error',
+    501: 'Not Implemented',
+    502: 'Bad Gateway',
+    503: 'Service Temporarily Unavailable',
+    504: 'Gateway Time-out',
+    505: 'HTTP Version Not Supported',
+    507: 'Insufficient Storage',
+};

package/dist/utils/url.d.ts

@@ -1,4 +1,9 @@
 export declare const splitPath: (path: string) => string[];
 export declare const getPattern: (label: string) => string[] | null;
-export declare const getPathFromURL: (url: string) => string;
+declare type Params = {
+    strict: boolean;
+};
+export declare const getPathFromURL: (url: string, params?: Params) => string;
 export declare const isAbsoluteURL: (url: string) => boolean;
+export declare const mergePath: (...paths: string[]) => string;
+export {};

package/dist/utils/url.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isAbsoluteURL = exports.getPathFromURL = exports.getPattern = exports.splitPath = void 0;
+exports.mergePath = exports.isAbsoluteURL = exports.getPathFromURL = exports.getPattern = exports.splitPath = void 0;
 const URL_REGEXP = /^(([^:\/?#]+):)?(\/\/([^\/?#]*))?([^?#]*)(\?([^#]*))?(#(.*))?/;
 const splitPath = (path) => {
     const paths = path.split(/\//); // faster than path.split('/')
@@ -26,7 +26,12 @@ const getPattern = (label) => {
     return null;
 };
 exports.getPattern = getPattern;
-const getPathFromURL = (url) => {
+const getPathFromURL = (url, params = { strict: true }) => {
+    // if strict routing is false => `/hello/hey/` and `/hello/hey` are treated the same
+    // default is true
+    if (!params.strict && url.endsWith('/')) {
+        url = url.slice(0, -1);
+    }
     const match = url.match(URL_REGEXP);
     if (match) {
         return match[5];
@@ -42,3 +47,27 @@ const isAbsoluteURL = (url) => {
     return false;
 };
 exports.isAbsoluteURL = isAbsoluteURL;
+const mergePath = (...paths) => {
+    let p = '';
+    let endsWithSlash = false;
+    for (let path of paths) {
+        /* ['/hey/','/say'] => ['/hey', '/say'] */
+        if (p.endsWith('/')) {
+            p = p.slice(0, -1);
+            endsWithSlash = true;
+        }
+        /* ['/hey','say'] => ['/hey', '/say'] */
+        if (!path.startsWith('/')) {
+            path = `/${path}`;
+        }
+        /* ['/hey/', '/'] => `/hey/` */
+        if (path === '/' && endsWithSlash) {
+            p = `${p}/`;
+        }
+        else if (path !== '/') {
+            p = `${p}${path}`;
+        }
+    }
+    return p;
+};
+exports.mergePath = mergePath;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hono",
-  "version": "0.3.5",
+  "version": "0.4.0",
   "description": "[炎] Ultrafast web framework for Cloudflare Workers.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -16,7 +16,9 @@
     "./logger": "./dist/middleware/logger/logger.js",
     "./mustache": "./dist/middleware/mustache/mustache.js",
     "./powered-by": "./dist/middleware/powered-by/powered-by.js",
-    "./serve-static": "./dist/middleware/serve-static/serve-static.js"
+    "./serve-static": "./dist/middleware/serve-static/serve-static.js",
+    "./utils/buffer": "./dist/utils/buffer.js",
+    "./package.json": "./package.json"
   },
   "typesVersions": {
     "*": {

package/dist/middleware/default.d.ts

@@ -1,2 +0,0 @@
-import type { Context } from '../context';
-export declare const defaultMiddleware: (c: Context, next: Function) => Promise<void>;

package/dist/middleware/default.js

@@ -1,15 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.defaultMiddleware = void 0;
-const defaultMiddleware = async (c, next) => {
-    c.req.query = (key) => {
-        // eslint-disable-next-line
-        const url = new URL(c.req.url);
-        return url.searchParams.get(key);
-    };
-    c.req.header = (name) => {
-        return c.req.headers.get(name);
-    };
-    await next();
-};
-exports.defaultMiddleware = defaultMiddleware;

package/dist/middleware.d.ts

@@ -1,3 +0,0 @@
-export declare class Middleware {
-    static default: (c: import("./context").Context, next: Function) => Promise<void>;
-}

package/dist/middleware.js

@@ -1,8 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Middleware = void 0;
-const default_1 = require("./middleware/default");
-class Middleware {
-}
-exports.Middleware = Middleware;
-Middleware.default = default_1.defaultMiddleware;