hono 0.0.15 → 0.2.1

package/README.md

@@ -23,19 +23,19 @@ app.fire()
 **Hono is fastest** compared to other routers for Cloudflare Workers.
 
 ```plain
-hono x 748,188 ops/sec ±5.40% (77 runs sampled)
-itty-router x 158,817 ops/sec ±3.62% (87 runs sampled)
-sunder x 332,339 ops/sec ±1.11% (95 runs sampled)
-worktop x 205,906 ops/sec ±4.43% (83 runs sampled)
+hono x 708,671 ops/sec ±2.58% (58 runs sampled)
+itty-router x 159,610 ops/sec ±2.86% (87 runs sampled)
+sunder x 322,846 ops/sec ±2.24% (86 runs sampled)
+worktop x 223,625 ops/sec ±2.01% (95 runs sampled)
 Fastest is hono
-✨  Done in 52.79s.
+✨  Done in 57.83s.
 ```
 
 ## Hono in 1 minute
 
 Below is a demonstration to create an application of Cloudflare Workers with Hono.
 
-![Demo](https://user-images.githubusercontent.com/10682/148223268-2484a891-57c1-472f-9df3-936a5586f002.gif)
+![Demo](https://user-images.githubusercontent.com/10682/151102477-be0f950e-8d23-49c5-b6d8-d8ecb6b7484e.gif)
 
 ## Install
 
@@ -90,7 +90,7 @@ app.all('/hello', (c) => c.text('Any Method /hello'))
 
 ```js
 app.get('/user/:name', (c) => {
-  const name = c.req.params('name')
+  const name = c.req.param('name')
   ...
 })
 ```
@@ -99,8 +99,8 @@ app.get('/user/:name', (c) => {
 
 ```js
 app.get('/post/:date{[0-9]+}/:title{[a-z]+}', (c) => {
-  const date = c.req.params('date')
-  const title = c.req.params('title')
+  const date = c.req.param('date')
+  const title = c.req.param('title')
   ...
 ```
 
@@ -114,6 +114,16 @@ app
     .put(() => {...})
 ```
 
+### Custom 404 Response
+
+You can customize 404 Not Found response:
+
+```js
+app.get('*', (c) => {
+  return c.text('Custom 404 Error', 404)
+})
+```
+
 ## async/await
 
 ```js
@@ -165,19 +175,6 @@ app.use('/message/*', async (c, next) => {
 app.get('/message/hello', (c) => c.text('Hello Middleware!'))
 ```
 
-### Custom 404 Response
-
-You can customize 404 Not Found response:
-
-```js
-app.use('*', async (c, next) => {
-  await next()
-  if (c.res.status === 404) {
-    c.res = new Response('Custom 404 Not Found', { status: 404 })
-  }
-})
-```
-
 ### Handling Error
 
 ```js
@@ -186,7 +183,7 @@ app.use('*', async (c, next) => {
     await next()
   } catch (err) {
     console.error(`${err}`)
-    c.res = new Response('Custom Error Message', { status: 500 })
+    c.res = c.text('Custom Error Message', { status: 500 })
   }
 })
 ```
@@ -219,13 +216,18 @@ To handle Request and Reponse easily, you can use Context object:
 ### c.req
 
 ```js
-
 // Get Request object
 app.get('/hello', (c) => {
   const userAgent = c.req.headers.get('User-Agent')
   ...
 })
 
+// Shortcut to get a header value
+app.get('/shortcut', (c) => {
+  const userAgent = c.req.header('User-Agent')
+  ...
+})
+
 // Query params
 app.get('/search', (c) => {
   const query = c.req.query('q')
@@ -234,40 +236,34 @@ app.get('/search', (c) => {
 
 // Captured params
 app.get('/entry/:id', (c) => {
-  const id = c.req.params('id')
+  const id = c.req.param('id')
   ...
 })
 ```
 
-### c.res
+### Shortcuts for Response
 
 ```js
-// Response object
-app.use('/', (c, next) => {
-  next()
-  c.res.headers.append('X-Debug', 'Debug message')
-})
-```
-
-### c.event
-
-```js
-// FetchEvent object
-app.use('*', async (c, next) => {
-  c.event.waitUntil(
-    ...
-  )
-  await next()
-})
-```
-
-### c.env
-
-```js
-// Environment object for Cloudflare Workers
-app.get('*', async c => {
-  const counter = c.env.COUNTER
-  ...
+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')
+
+  /*
+  Same as:
+  return new Response('Thank you for comming', {
+    status: 201,
+    statusText: '201 Content Created',
+    headers: {
+      'X-Message': 'Hello',
+      'Content-Type': 'text/plain',
+      'Content-Length: '22'
+    }
+  })
+  */
 })
 ```
 
@@ -310,6 +306,38 @@ app.get('/redirect', (c) => c.redirect('/'))
 app.get('/redirect-permanently', (c) => c.redirect('/', 301))
 ```
 
+### c.res
+
+```js
+// Response object
+app.use('/', (c, next) => {
+  next()
+  c.res.headers.append('X-Debug', 'Debug message')
+})
+```
+
+### c.event
+
+```js
+// FetchEvent object
+app.use('*', async (c, next) => {
+  c.event.waitUntil(
+    ...
+  )
+  await next()
+})
+```
+
+### c.env
+
+```js
+// Environment object for Cloudflare Workers
+app.get('*', async c => {
+  const counter = c.env.COUNTER
+  ...
+})
+```
+
 ## fire
 
 `app.fire()` do:

package/dist/context.d.ts

@@ -9,12 +9,20 @@ export declare class Context {
     res: Response;
     env: Env;
     event: FetchEvent;
+    private _headers;
+    private _status;
+    private _statusText;
+    render: (template: string, params?: object, options?: object) => Promise<Response>;
     constructor(req: Request, opts?: {
         res: Response;
         env: Env;
         event: FetchEvent;
     });
-    newResponse(body?: BodyInit | null | undefined, init?: ResponseInit | undefined): Response;
+    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;
     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

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Context = void 0;
-const util_1 = require("./util");
+const url_1 = require("./utils/url");
 class Context {
     constructor(req, opts) {
         this.req = req;
@@ -10,46 +10,58 @@ class Context {
             this.env = opts.env;
             this.event = opts.event;
         }
+        this._headers = {};
     }
-    newResponse(body, init) {
-        return new Response(body, init);
+    header(name, value) {
+        this._headers[name] = value;
     }
-    text(text, status = 200, headers = {}) {
+    status(number) {
+        this._status = number;
+    }
+    statusText(text) {
+        this._statusText = text;
+    }
+    newResponse(data, init = {}) {
+        init.status = init.status || this._status;
+        init.statusText = init.statusText || this._statusText;
+        const Encoder = new TextEncoder();
+        const length = data ? data.bytelength || Encoder.encode(data).byteLength : 0;
+        init.headers = Object.assign(Object.assign(Object.assign({}, this._headers), init.headers), { 'Content-Length': String(length) });
+        return new Response(data, init);
+    }
+    body(data, status = this._status, headers = this._headers) {
+        return this.newResponse(data, {
+            status: status,
+            headers: headers,
+        });
+    }
+    text(text, status = this._status, headers = {}) {
         if (typeof text !== 'string') {
             throw new TypeError('text method arg must be a string!');
         }
         headers['Content-Type'] = 'text/plain';
-        return this.newResponse(text, {
-            status: status,
-            headers: headers,
-        });
+        return this.body(text, status, headers);
     }
-    json(object, status = 200, headers = {}) {
+    json(object, status = this._status, headers = {}) {
         if (typeof object !== 'object') {
             throw new TypeError('json method arg must be a object!');
         }
         const body = JSON.stringify(object);
         headers['Content-Type'] = 'application/json; charset=UTF-8';
-        return this.newResponse(body, {
-            status: status,
-            headers: headers,
-        });
+        return this.body(body, status, headers);
     }
-    html(html, status = 200, headers = {}) {
+    html(html, status = this._status, headers = {}) {
         if (typeof html !== 'string') {
             throw new TypeError('html method arg must be a string!');
         }
         headers['Content-Type'] = 'text/html; charset=UTF-8';
-        return this.newResponse(html, {
-            status: status,
-            headers: headers,
-        });
+        return this.body(html, status, headers);
     }
     redirect(location, status = 302) {
         if (typeof location !== 'string') {
             throw new TypeError('location must be a string!');
         }
-        if (!(0, util_1.isAbsoluteURL)(location)) {
+        if (!(0, url_1.isAbsoluteURL)(location)) {
             const url = new URL(this.req.url);
             url.pathname = location;
             location = url.toString();

package/dist/hono.d.ts

@@ -5,9 +5,9 @@ import { Context } from './context';
 import type { Env } from './context';
 declare global {
     interface Request {
-        params: (key: string) => string;
+        param: (key: string) => string;
         query: (key: string) => string | null;
-        parsedBody: any;
+        header: (name: string) => string;
     }
 }
 export declare type Handler = (c: Context, next?: Function) => Response | Promise<Response>;

package/dist/hono.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Hono = exports.Router = void 0;
 const node_1 = require("./node");
 const compose_1 = require("./compose");
-const util_1 = require("./util");
+const url_1 = require("./utils/url");
 const middleware_1 = require("./middleware");
 const context_1 = require("./context");
 const METHOD_NAME_OF_ALL = 'ALL';
@@ -94,9 +94,9 @@ class Hono {
         return this.router.match(method, path);
     }
     async dispatch(request, env, event) {
-        const [method, path] = [request.method, (0, util_1.getPathFromURL)(request.url)];
+        const [method, path] = [request.method, (0, url_1.getPathFromURL)(request.url)];
         const result = await this.matchRoute(method, path);
-        request.params = (key) => {
+        request.param = (key) => {
             if (result) {
                 return result.params[key];
             }
@@ -137,11 +137,23 @@ class Hono {
         });
     }
     onError(err) {
-        console.error(err);
-        return new Response('Internal Server Error', { status: 500 });
+        console.error(`${err}`);
+        const message = 'Internal Server Error';
+        return new Response(message, {
+            status: 500,
+            headers: {
+                'Content-Length': message.length.toString(),
+            },
+        });
     }
     notFound() {
-        return new Response('Not Found', { status: 404 });
+        const message = 'Not Found';
+        return new Response('Not Found', {
+            status: 404,
+            headers: {
+                'Content-Length': message.length.toString(),
+            },
+        });
     }
 }
 exports.Hono = Hono;

package/dist/middleware/basic-auth/basic-auth.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.basicAuth = void 0;
-const util_1 = require("../../util");
+const buffer_1 = require("../../utils/buffer");
 const CREDENTIALS_REGEXP = /^ *(?:[Bb][Aa][Ss][Ii][Cc]) +([A-Za-z0-9._~+/-]+=*) *$/;
 const USER_PASS_REGEXP = /^([^:]*):(.*)$/;
 const auth = (req) => {
@@ -33,8 +33,8 @@ const basicAuth = (options) => {
     }
     return async (ctx, next) => {
         const user = auth(ctx.req);
-        const usernameEqual = user && await (0, util_1.timingSafeEqual)(options.username, user.username);
-        const passwordEqual = user && await (0, util_1.timingSafeEqual)(options.password, user.password);
+        const usernameEqual = user && await (0, buffer_1.timingSafeEqual)(options.username, user.username);
+        const passwordEqual = user && await (0, buffer_1.timingSafeEqual)(options.password, user.password);
         if (!user || !usernameEqual || !passwordEqual) {
             ctx.res = new Response('Unauthorized', {
                 status: 401,

package/dist/middleware/body-parse/body-parse.d.ts

@@ -1,2 +1,7 @@
 import type { Context } from '../../context';
+declare global {
+    interface Request {
+        parsedBody: any;
+    }
+}
 export declare const bodyParse: () => (ctx: Context, next: Function) => Promise<void>;

package/dist/middleware/cookie/cookie.d.ts

@@ -0,0 +1,25 @@
+import type { Context } from '../../context';
+declare global {
+    interface Request {
+        cookie: (name: string) => string;
+    }
+}
+declare module '../../context' {
+    interface Context {
+        cookie: (name: string, value: string, options?: CookieOptions) => void;
+    }
+}
+export declare type Cookie = {
+    [key: string]: string;
+};
+export declare type CookieOptions = {
+    domain?: string;
+    expires?: Date;
+    httpOnly?: boolean;
+    maxAge?: number;
+    path?: string;
+    secure?: boolean;
+    signed?: boolean;
+    sameSite?: 'Strict' | 'Lax' | 'None';
+};
+export declare const cookie: () => (c: Context, next: Function) => Promise<void>;

package/dist/middleware/cookie/cookie.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cookie = void 0;
+const cookie = () => {
+    return async (c, next) => {
+        c.req.cookie = (name) => {
+            const cookie = c.req.headers.get('Cookie');
+            const obj = parse(cookie);
+            const value = obj[name];
+            return value;
+        };
+        c.cookie = (name, value, opt) => {
+            const cookie = serialize(name, value, opt);
+            c.header('Set-Cookie', cookie);
+        };
+        await next();
+    };
+};
+exports.cookie = cookie;
+const parse = (cookie) => {
+    const pairs = cookie.split(/;\s*/g);
+    const parsedCookie = {};
+    for (let i = 0, len = pairs.length; i < len; i++) {
+        const pair = pairs[i].split(/\s*=\s*([^\s]+)/);
+        parsedCookie[pair[0]] = decodeURIComponent(pair[1]);
+    }
+    return parsedCookie;
+};
+const serialize = (name, value, opt = {}) => {
+    value = encodeURIComponent(value);
+    let cookie = `${name}=${value}`;
+    if (opt.maxAge) {
+        cookie += `; Max-Age=${Math.floor(opt.maxAge)}`;
+    }
+    if (opt.domain) {
+        cookie += '; Domain=' + opt.domain;
+    }
+    if (opt.path) {
+        cookie += '; Path=' + opt.path;
+    }
+    if (opt.expires) {
+        cookie += '; Expires=' + opt.expires.toUTCString();
+    }
+    if (opt.httpOnly) {
+        cookie += '; HttpOnly';
+    }
+    if (opt.secure) {
+        cookie += '; Secure';
+    }
+    if (opt.sameSite) {
+        cookie += `; SameSaite=${opt.sameSite}`;
+    }
+    return cookie;
+};

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

@@ -0,0 +1,11 @@
+import type { Context } from '../../context';
+declare type CORSOptions = {
+    origin: string;
+    allowMethods?: string[];
+    allowHeaders?: string[];
+    maxAge?: number;
+    credentials?: boolean;
+    exposeHeaders?: string[];
+};
+export declare const cors: (options?: CORSOptions) => (c: Context, next: Function) => Promise<void>;
+export {};

package/dist/middleware/cors/cors.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cors = void 0;
+const cors = (options) => {
+    const defaults = {
+        origin: '*',
+        allowMethods: ['GET', 'HEAD', 'PUT', 'POST', 'DELETE', 'PATCH'],
+        allowHeaders: [],
+        exposeHeaders: [],
+    };
+    const opts = Object.assign(Object.assign({}, defaults), options);
+    return async (c, next) => {
+        await next();
+        function set(key, value) {
+            c.res.headers.append(key, value);
+        }
+        set('Access-Control-Allow-Origin', opts.origin);
+        // Suppose the server sends a response with an Access-Control-Allow-Origin value with an explicit origin (rather than the "*" wildcard).
+        // https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Access-Control-Allow-Origin
+        if (opts.origin !== '*') {
+            set('Vary', 'Origin');
+        }
+        if (opts.credentials) {
+            set('Access-Control-Allow-Credentials', 'true');
+        }
+        if (opts.exposeHeaders.length) {
+            set('Access-Control-Expose-Headers', opts.exposeHeaders.join(','));
+        }
+        if (c.req.method === 'OPTIONS') {
+            // Preflight
+            if (opts.maxAge != null) {
+                set('Access-Control-Max-Age', opts.maxAge.toString());
+            }
+            if (opts.allowMethods.length) {
+                set('Access-Control-Allow-Methods', opts.allowMethods.join(','));
+            }
+            let headers = opts.allowHeaders;
+            if (!headers.length) {
+                const requestHeaders = c.req.headers.get('Access-Control-Request-Headers');
+                if (requestHeaders) {
+                    headers = requestHeaders.split(/\s*,\s*/);
+                }
+            }
+            if (headers.length) {
+                set('Access-Control-Allow-Headers', headers.join(','));
+                set('Vary', 'Access-Control-Request-Headers');
+            }
+            c.res.headers.delete('Content-Length');
+            c.res.headers.delete('Content-Type');
+            c.res = new Response(null, {
+                headers: c.res.headers,
+                status: 204,
+                statusText: c.res.statusText,
+            });
+        }
+    };
+};
+exports.cors = cors;

package/dist/middleware/default.js

@@ -7,10 +7,9 @@ const defaultMiddleware = async (c, next) => {
         const url = new URL(c.req.url);
         return url.searchParams.get(key);
     };
+    c.req.header = (name) => {
+        return c.req.headers.get(name);
+    };
     await next();
-    if (c.res.body) {
-        const buff = await c.res.clone().arrayBuffer();
-        c.res.headers.append('Content-Length', buff.byteLength.toString());
-    }
 };
 exports.defaultMiddleware = defaultMiddleware;

package/dist/middleware/logger/logger.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.logger = void 0;
-const util_1 = require("../../util");
+const url_1 = require("../../utils/url");
 const humanize = (n, opts) => {
     const options = opts || {};
     const d = options.delimiter || ',';
@@ -33,16 +33,16 @@ const colorStatus = (status = 0) => {
     };
     return out[(status / 100) | 0];
 };
-function log(fn, prefix, method, path, status, elasped) {
+function log(fn, prefix, method, path, status, elasped, contentLength) {
     const out = prefix === LogPrefix.Incoming
         ? `  ${prefix} ${method} ${path}`
-        : `  ${prefix} ${method} ${path} ${colorStatus(status)} ${elasped}`;
+        : `  ${prefix} ${method} ${path} ${colorStatus(status)} ${elasped} ${contentLength}`;
     fn(out);
 }
 const logger = (fn = console.log) => {
     return async (c, next) => {
         const { method } = c.req;
-        const path = (0, util_1.getPathFromURL)(c.req.url);
+        const path = (0, url_1.getPathFromURL)(c.req.url);
         log(fn, LogPrefix.Incoming, method, path);
         const start = Date.now();
         try {
@@ -52,7 +52,13 @@ const logger = (fn = console.log) => {
             log(fn, LogPrefix.Error, method, path, c.res.status || 500, time(start));
             throw e;
         }
-        log(fn, LogPrefix.Outgoing, method, path, c.res.status, time(start));
+        const len = parseFloat(c.res.headers.get('Content-Length'));
+        const contentLength = isNaN(len)
+            ? '0'
+            : len < 1024
+                ? `${len}b`
+                : `${len / 1024}kB`;
+        log(fn, LogPrefix.Outgoing, method, path, c.res.status, time(start), contentLength);
     };
 };
 exports.logger = logger;

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

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

package/dist/middleware/mustache/mustache.js

@@ -0,0 +1,57 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mustache = void 0;
+const cloudflare_1 = require("../../utils/cloudflare");
+const EXTENSION = '.mustache';
+const mustache = () => {
+    return async (c, next) => {
+        let Mustache;
+        try {
+            Mustache = await Promise.resolve().then(() => __importStar(require('mustache')));
+        }
+        catch (e) {
+            console.error(`Mustache is not found! ${e}`);
+            throw new Error(`${e}`);
+        }
+        c.render = async (filename, view = {}, options) => {
+            const content = await (0, cloudflare_1.getContentFromKVAsset)(`${filename}${EXTENSION}`);
+            if (!content) {
+                throw new Error(`Template "${filename}${EXTENSION}" is not found`);
+            }
+            const partialArgs = {};
+            if (options) {
+                const partials = options;
+                for (const key of Object.keys(partials)) {
+                    const partialContent = await (0, cloudflare_1.getContentFromKVAsset)(`${partials[key]}${EXTENSION}`);
+                    if (!partialContent) {
+                        throw new Error(`Partial Template "${partials[key]}${EXTENSION}" is not found`);
+                    }
+                    partialArgs[key] = partialContent;
+                }
+            }
+            const output = Mustache.render(content, view, partialArgs);
+            return c.html(output);
+        };
+        await next();
+    };
+};
+exports.mustache = mustache;

package/dist/middleware.d.ts

@@ -12,4 +12,14 @@ export declare class Middleware {
         realm?: string;
     }) => (ctx: import("./context").Context, next: Function) => Promise<any>;
     static bodyParse: () => (ctx: import("./context").Context, next: Function) => Promise<void>;
+    static cors: (options?: {
+        origin: string;
+        allowMethods?: string[];
+        allowHeaders?: string[];
+        maxAge?: number;
+        credentials?: boolean;
+        exposeHeaders?: string[];
+    }) => (c: import("./context").Context, next: Function) => Promise<void>;
+    static cookie: () => (c: import("./context").Context, next: Function) => Promise<void>;
+    static mustache: () => (c: import("./context").Context, next: Function) => Promise<void>;
 }

package/dist/middleware.js

@@ -6,6 +6,9 @@ const powered_by_1 = require("./middleware/powered-by/powered-by");
 const logger_1 = require("./middleware/logger/logger");
 const basic_auth_1 = require("./middleware/basic-auth/basic-auth");
 const body_parse_1 = require("./middleware/body-parse/body-parse");
+const cors_1 = require("./middleware/cors/cors");
+const cookie_1 = require("./middleware/cookie/cookie");
+const mustache_1 = require("./middleware/mustache/mustache");
 class Middleware {
 }
 exports.Middleware = Middleware;
@@ -14,3 +17,6 @@ Middleware.poweredBy = powered_by_1.poweredBy;
 Middleware.logger = logger_1.logger;
 Middleware.basicAuth = basic_auth_1.basicAuth;
 Middleware.bodyParse = body_parse_1.bodyParse;
+Middleware.cors = cors_1.cors;
+Middleware.cookie = cookie_1.cookie;
+Middleware.mustache = mustache_1.mustache;

package/dist/node.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Node = exports.Result = void 0;
-const util_1 = require("./util");
+const url_1 = require("./utils/url");
 const METHOD_NAME_OF_ALL = 'ALL';
 class Result {
     constructor(handler, params) {
@@ -25,7 +25,7 @@ class Node {
     insert(method, path, handler) {
         // eslint-disable-next-line @typescript-eslint/no-this-alias
         let curNode = this;
-        const parts = (0, util_1.splitPath)(path);
+        const parts = (0, url_1.splitPath)(path);
         for (let i = 0, len = parts.length; i < len; i++) {
             const p = parts[i];
             if (Object.keys(curNode.children).includes(p)) {
@@ -42,7 +42,7 @@ class Node {
         // eslint-disable-next-line @typescript-eslint/no-this-alias
         let curNode = this;
         const params = {};
-        const parts = (0, util_1.splitPath)(path);
+        const parts = (0, url_1.splitPath)(path);
         for (let i = 0, len = parts.length; i < len; i++) {
             const p = parts[i];
             // '*' => match any path
@@ -74,7 +74,7 @@ class Node {
                     isWildcard = true;
                     break;
                 }
-                const pattern = (0, util_1.getPattern)(key);
+                const pattern = (0, url_1.getPattern)(key);
                 // Named match
                 if (pattern) {
                     const match = p.match(new RegExp(pattern[1]));

package/dist/utils/buffer.d.ts

@@ -0,0 +1,2 @@
+export declare const equal: (a: ArrayBuffer, b: ArrayBuffer) => boolean;
+export declare const timingSafeEqual: (a: any, b: any) => Promise<boolean>;

package/dist/utils/buffer.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.timingSafeEqual = exports.equal = void 0;
+const equal = (a, b) => {
+    if (a === b) {
+        return true;
+    }
+    if (a.byteLength !== b.byteLength) {
+        return false;
+    }
+    const va = new DataView(a);
+    const vb = new DataView(b);
+    let i = va.byteLength;
+    while (i--) {
+        if (va.getUint8(i) !== vb.getUint8(i)) {
+            return false;
+        }
+    }
+    return true;
+};
+exports.equal = equal;
+const timingSafeEqual = async (a, b) => {
+    const sa = await crypto.subtle.digest({
+        name: 'SHA-256',
+    }, new TextEncoder().encode(String(a)));
+    const sb = await crypto.subtle.digest({
+        name: 'SHA-256',
+    }, new TextEncoder().encode(String(b)));
+    return (0, exports.equal)(sa, sb) && a === b;
+};
+exports.timingSafeEqual = timingSafeEqual;

package/dist/utils/cloudflare.d.ts

@@ -0,0 +1 @@
+export declare const getContentFromKVAsset: (path: string) => Promise<string>;

package/dist/utils/cloudflare.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getContentFromKVAsset = void 0;
+const getContentFromKVAsset = async (path) => {
+    let ASSET_MANIFEST;
+    if (typeof __STATIC_CONTENT_MANIFEST === 'string') {
+        ASSET_MANIFEST = JSON.parse(__STATIC_CONTENT_MANIFEST);
+    }
+    else {
+        ASSET_MANIFEST = __STATIC_CONTENT_MANIFEST;
+    }
+    const ASSET_NAMESPACE = __STATIC_CONTENT;
+    const key = ASSET_MANIFEST[path] || path;
+    if (!key) {
+        return;
+    }
+    let content;
+    content = await ASSET_NAMESPACE.get(key, { type: 'text' });
+    if (content) {
+        content = content;
+    }
+    return content;
+};
+exports.getContentFromKVAsset = getContentFromKVAsset;

package/dist/{util.d.ts → utils/url.d.ts}

@@ -2,4 +2,3 @@ export declare const splitPath: (path: string) => string[];
 export declare const getPattern: (label: string) => string[] | null;
 export declare const getPathFromURL: (url: string) => string;
 export declare const isAbsoluteURL: (url: string) => boolean;
-export declare const timingSafeEqual: (a: any, b: any) => Promise<boolean>;

package/dist/{util.js → utils/url.js}

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.timingSafeEqual = exports.isAbsoluteURL = exports.getPathFromURL = exports.getPattern = exports.splitPath = void 0;
+exports.isAbsoluteURL = exports.getPathFromURL = exports.getPattern = exports.splitPath = void 0;
 const URL_REGEXP = /^(([^:\/?#]+):)?(\/\/([^\/?#]*))?([^?#]*)(\?([^#]*))?(#(.*))?/;
 const splitPath = (path) => {
     const paths = path.split(/\//); // faster than path.split('/')
@@ -27,7 +27,6 @@ const getPattern = (label) => {
 };
 exports.getPattern = getPattern;
 const getPathFromURL = (url) => {
-    // XXX
     const match = url.match(URL_REGEXP);
     if (match) {
         return match[5];
@@ -43,30 +42,3 @@ const isAbsoluteURL = (url) => {
     return false;
 };
 exports.isAbsoluteURL = isAbsoluteURL;
-const bufferEqual = (a, b) => {
-    if (a === b) {
-        return true;
-    }
-    if (a.byteLength !== b.byteLength) {
-        return false;
-    }
-    const va = new DataView(a);
-    const vb = new DataView(b);
-    let i = va.byteLength;
-    while (i--) {
-        if (va.getUint8(i) !== vb.getUint8(i)) {
-            return false;
-        }
-    }
-    return true;
-};
-const timingSafeEqual = async (a, b) => {
-    const sa = await crypto.subtle.digest({
-        name: 'SHA-256',
-    }, new TextEncoder().encode(String(a)));
-    const sb = await crypto.subtle.digest({
-        name: 'SHA-256',
-    }, new TextEncoder().encode(String(b)));
-    return bufferEqual(sa, sb) && a === b;
-};
-exports.timingSafeEqual = timingSafeEqual;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hono",
-  "version": "0.0.15",
+  "version": "0.2.1",
   "description": "[炎] Ultrafast web framework for Cloudflare Workers.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -36,6 +36,7 @@
   "devDependencies": {
     "@cloudflare/workers-types": "^3.3.0",
     "@types/jest": "^27.4.0",
+    "@types/mustache": "^4.1.2",
     "@types/node": "^17.0.8",
     "@typescript-eslint/eslint-plugin": "^5.9.0",
     "@typescript-eslint/parser": "^5.9.0",
@@ -51,6 +52,7 @@
     "form-data": "^4.0.0",
     "jest": "^27.4.5",
     "jest-environment-miniflare": "^2.0.0",
+    "mustache": "^4.2.0",
     "rimraf": "^3.0.2",
     "ts-jest": "^27.1.2",
     "typescript": "^4.5.4"