hono 0.3.0 → 0.3.4

package/dist/compose.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.compose = void 0;
 // Based on the code in the MIT licensed `koa-compose` package.
 const compose = (middleware) => {
+    const errors = [];
     return function (context, next) {
         let index = -1;
         return dispatch(0);
@@ -16,7 +17,10 @@ const compose = (middleware) => {
             if (!fn)
                 return Promise.resolve();
             try {
-                return Promise.resolve(fn(context, dispatch.bind(null, i + 1)));
+                return Promise.resolve(fn(context, dispatch.bind(null, i + 1))).catch((e) => {
+                    errors.push(e);
+                    throw errors[0]; // XXX
+                });
             }
             catch (err) {
                 return Promise.reject(err);

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

@@ -18,23 +18,20 @@ const auth = (req) => {
     if (!match) {
         return undefined;
     }
-    const userPass = USER_PASS_REGEXP.exec(decodeBase64(match[1]));
+    const userPass = USER_PASS_REGEXP.exec((0, buffer_1.decodeBase64)(match[1]));
     if (!userPass) {
         return undefined;
     }
     return { username: userPass[1], password: userPass[2] };
 };
-function decodeBase64(str) {
-    return Buffer.from(str, 'base64').toString();
-}
 const basicAuth = (options) => {
     if (!options.realm) {
         options.realm = 'Secure Area';
     }
     return async (ctx, next) => {
         const user = auth(ctx.req);
-        const usernameEqual = user && await (0, buffer_1.timingSafeEqual)(options.username, user.username);
-        const passwordEqual = user && await (0, buffer_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/mustache/mustache.js

@@ -4,16 +4,13 @@ exports.mustache = void 0;
 const cloudflare_1 = require("../../utils/cloudflare");
 const EXTENSION = '.mustache';
 const mustache = () => {
-    let Mustache;
-    try {
-        Mustache = require('mustache');
-    }
-    catch (_a) {
-        // Do nothing.
-    }
     return async (c, next) => {
-        if (!Mustache) {
-            throw new Error('If you want to use Mustache Middleware, install mustache module.');
+        let Mustache;
+        try {
+            Mustache = require('mustache');
+        }
+        catch (_a) {
+            throw new Error('If you want to use Mustache Middleware, install "mustache" package first.');
         }
         c.render = async (filename, view = {}, options) => {
             const buffer = await (0, cloudflare_1.getContentFromKVAsset)(`${filename}${EXTENSION}`);

package/dist/utils/buffer.d.ts

@@ -1,2 +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>;

package/dist/utils/buffer.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.timingSafeEqual = exports.equal = void 0;
+exports.timingSafeEqual = exports.sha256 = exports.decodeBase64 = exports.equal = void 0;
 const equal = (a, b) => {
     if (a === b) {
         return true;
@@ -19,13 +19,50 @@ const equal = (a, b) => {
     return true;
 };
 exports.equal = equal;
+const decodeBase64 = (str) => {
+    try {
+        const text = atob(str);
+        const length = text.length;
+        const bytes = new Uint8Array(length);
+        for (let i = 0; i < length; i++) {
+            bytes[i] = text.charCodeAt(i);
+        }
+        const decoder = new TextDecoder();
+        return decoder.decode(bytes);
+    }
+    catch (_a) { }
+    try {
+        const { Buffer } = require('buffer');
+        return Buffer.from(str, 'base64').toString();
+    }
+    catch (e) {
+        console.error('If you want to do "decodeBase64", polyfill "buffer" module.');
+        throw e;
+    }
+};
+exports.decodeBase64 = decodeBase64;
+const sha256 = async (a) => {
+    if (crypto && crypto.subtle) {
+        const buffer = await crypto.subtle.digest({
+            name: 'SHA-256',
+        }, new TextEncoder().encode(String(a)));
+        const hash = Array.prototype.map.call(new Uint8Array(buffer), (x) => ('00' + x.toString(16)).slice(-2)).join('');
+        return hash;
+    }
+    try {
+        const crypto = require('crypto');
+        const hash = crypto.createHash('sha256').update(a).digest('hex');
+        return hash;
+    }
+    catch (e) {
+        console.error('If you want to do "sha256", polyfill "crypto" module.');
+        throw e;
+    }
+};
+exports.sha256 = sha256;
 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;
+    const sa = await (0, exports.sha256)(a);
+    const sb = await (0, exports.sha256)(b);
+    return sa === sb && a === b;
 };
 exports.timingSafeEqual = timingSafeEqual;

package/package.json

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