hono 2.3.2 → 2.4.0

package/dist/cjs/hono.js

@@ -1,165 +1,188 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Hono = void 0;
-const compose_1 = require("./compose");
-const context_1 = require("./context");
-const request_1 = require("./request");
-const router_1 = require("./router");
-const router_2 = require("./router");
-const reg_exp_router_1 = require("./router/reg-exp-router");
-const smart_router_1 = require("./router/smart-router");
-const static_router_1 = require("./router/static-router");
-const trie_router_1 = require("./router/trie-router");
-const url_1 = require("./utils/url");
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var hono_exports = {};
+__export(hono_exports, {
+  Hono: () => Hono
+});
+module.exports = __toCommonJS(hono_exports);
+var import_compose = require("./compose");
+var import_context = require("./context");
+var import_request = require("./request");
+var import_router = require("./router");
+var import_reg_exp_router = require("./router/reg-exp-router");
+var import_smart_router = require("./router/smart-router");
+var import_static_router = require("./router/static-router");
+var import_trie_router = require("./router/trie-router");
+var import_url = require("./utils/url");
 function defineDynamicClass() {
-    return class {
-    };
+  return class {
+  };
 }
 class Hono extends defineDynamicClass() {
-    constructor(init = {}) {
-        super();
-        this.router = new smart_router_1.SmartRouter({
-            routers: [new static_router_1.StaticRouter(), new reg_exp_router_1.RegExpRouter(), new trie_router_1.TrieRouter()],
-        });
-        this.strict = true; // strict routing - default is true
-        this._tempPath = '';
-        this.path = '/';
-        this.routes = [];
-        this.notFoundHandler = (c) => {
-            return c.text('404 Not Found', 404);
-        };
-        this.errorHandler = (err, c) => {
-            console.trace(err.message);
-            const message = 'Internal Server Error';
-            return c.text(message, 500);
-        };
-        this.handleEvent = (event) => {
-            return this.dispatch(event.request, event);
-        };
-        this.fetch = (request, Environment, executionCtx) => {
-            return this.dispatch(request, executionCtx, Environment);
-        };
-        this.request = async (input, requestInit) => {
-            const req = input instanceof Request ? input : new Request(input, requestInit);
-            return await this.fetch(req);
-        };
-        (0, request_1.extendRequestPrototype)();
-        const allMethods = [...router_1.METHODS, router_2.METHOD_NAME_ALL_LOWERCASE];
-        allMethods.map((method) => {
-            this[method] = (args1, ...args) => {
-                if (typeof args1 === 'string') {
-                    this.path = args1;
-                }
-                else {
-                    this.addRoute(method, this.path, args1);
-                }
-                args.map((handler) => {
-                    if (typeof handler !== 'string') {
-                        this.addRoute(method, this.path, handler);
-                    }
-                });
-                return this;
-            };
-        });
-        Object.assign(this, init);
-    }
-    route(path, app) {
-        this._tempPath = path;
-        if (app) {
-            app.routes.map((r) => {
-                this.addRoute(r.method, r.path, r.handler);
-            });
-            this._tempPath = '';
-        }
-        return this;
-    }
-    use(arg1, ...handlers) {
-        if (typeof arg1 === 'string') {
-            this.path = arg1;
-        }
-        else {
-            handlers.unshift(arg1);
+  constructor(init = {}) {
+    super();
+    this.router = new import_smart_router.SmartRouter({
+      routers: [new import_static_router.StaticRouter(), new import_reg_exp_router.RegExpRouter(), new import_trie_router.TrieRouter()]
+    });
+    this.strict = true;
+    this._tempPath = "";
+    this.path = "/";
+    this.routes = [];
+    this.notFoundHandler = (c) => {
+      return c.text("404 Not Found", 404);
+    };
+    this.errorHandler = (err, c) => {
+      console.trace(err.message);
+      const message = "Internal Server Error";
+      return c.text(message, 500);
+    };
+    this.handleEvent = (event) => {
+      return this.dispatch(event.request, event);
+    };
+    this.fetch = (request, Environment, executionCtx) => {
+      return this.dispatch(request, executionCtx, Environment);
+    };
+    this.request = async (input, requestInit) => {
+      const req = input instanceof Request ? input : new Request(input, requestInit);
+      return await this.fetch(req);
+    };
+    (0, import_request.extendRequestPrototype)();
+    const allMethods = [...import_router.METHODS, import_router.METHOD_NAME_ALL_LOWERCASE];
+    allMethods.map((method) => {
+      this[method] = (args1, ...args) => {
+        if (typeof args1 === "string") {
+          this.path = args1;
+        } else {
+          this.addRoute(method, this.path, args1);
         }
-        handlers.map((handler) => {
-            this.addRoute(router_2.METHOD_NAME_ALL, this.path, handler);
+        args.map((handler) => {
+          if (typeof handler !== "string") {
+            this.addRoute(method, this.path, handler);
+          }
         });
         return this;
+      };
+    });
+    Object.assign(this, init);
+  }
+  route(path, app) {
+    this._tempPath = path;
+    if (app) {
+      app.routes.map((r) => {
+        this.addRoute(r.method, r.path, r.handler);
+      });
+      this._tempPath = "";
     }
-    onError(handler) {
-        this.errorHandler = handler;
-        return this;
-    }
-    notFound(handler) {
-        this.notFoundHandler = handler;
-        return this;
+    return this;
+  }
+  use(arg1, ...handlers) {
+    if (typeof arg1 === "string") {
+      this.path = arg1;
+    } else {
+      handlers.unshift(arg1);
     }
-    addRoute(method, path, handler) {
-        method = method.toUpperCase();
-        if (this._tempPath) {
-            path = (0, url_1.mergePath)(this._tempPath, path);
-        }
-        this.router.add(method, path, handler);
-        const r = { path: path, method: method, handler: handler };
-        this.routes.push(r);
+    handlers.map((handler) => {
+      this.addRoute(import_router.METHOD_NAME_ALL, this.path, handler);
+    });
+    return this;
+  }
+  onError(handler) {
+    this.errorHandler = handler;
+    return this;
+  }
+  notFound(handler) {
+    this.notFoundHandler = handler;
+    return this;
+  }
+  addRoute(method, path, handler) {
+    method = method.toUpperCase();
+    if (this._tempPath) {
+      path = (0, import_url.mergePath)(this._tempPath, path);
     }
-    matchRoute(method, path) {
-        return this.router.match(method, path);
+    this.router.add(method, path, handler);
+    const r = { path, method, handler };
+    this.routes.push(r);
+  }
+  matchRoute(method, path) {
+    return this.router.match(method, path);
+  }
+  handleError(err, c) {
+    if (err instanceof Error) {
+      return this.errorHandler(err, c);
     }
-    handleError(err, c) {
-        if (err instanceof Error) {
-            return this.errorHandler(err, c);
+    throw err;
+  }
+  dispatch(request, eventOrExecutionCtx, env) {
+    const path = (0, import_url.getPathFromURL)(request.url, this.strict);
+    const method = request.method;
+    const result = this.matchRoute(method, path);
+    request.paramData = result?.params;
+    const c = new import_context.HonoContext(request, env, eventOrExecutionCtx, this.notFoundHandler);
+    if (result && result.handlers.length === 1) {
+      const handler = result.handlers[0];
+      let res;
+      try {
+        res = handler(c, async () => {
+        });
+        if (!res)
+          return this.notFoundHandler(c);
+      } catch (err) {
+        return this.handleError(err, c);
+      }
+      if (res instanceof Response)
+        return res;
+      return (async () => {
+        let awaited;
+        try {
+          awaited = await res;
+        } catch (err) {
+          return this.handleError(err, c);
         }
-        throw err;
-    }
-    dispatch(request, eventOrExecutionCtx, env) {
-        const path = (0, url_1.getPathFromURL)(request.url, this.strict);
-        const method = request.method;
-        const result = this.matchRoute(method, path);
-        request.paramData = result?.params;
-        const c = new context_1.HonoContext(request, env, eventOrExecutionCtx, this.notFoundHandler);
-        // Do not `compose` if it has only one handler
-        if (result && result.handlers.length === 1) {
-            const handler = result.handlers[0];
-            let res;
-            try {
-                res = handler(c, async () => { });
-                if (!res)
-                    return this.notFoundHandler(c);
-            }
-            catch (err) {
-                return this.handleError(err, c);
-            }
-            if (res instanceof Response)
-                return res;
-            return (async () => {
-                let awaited;
-                try {
-                    awaited = await res;
-                }
-                catch (err) {
-                    return this.handleError(err, c);
-                }
-                if (!awaited) {
-                    return this.notFoundHandler(c);
-                }
-                return awaited;
-            })();
+        if (!awaited) {
+          return this.notFoundHandler(c);
         }
-        const handlers = result ? result.handlers : [this.notFoundHandler];
-        const composed = (0, compose_1.compose)(handlers, this.notFoundHandler, this.errorHandler);
-        return (async () => {
-            try {
-                const tmp = composed(c);
-                const 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()`');
-                }
-                return context.res;
-            }
-            catch (err) {
-                return this.handleError(err, c);
-            }
-        })();
+        return awaited;
+      })();
     }
+    const handlers = result ? result.handlers : [this.notFoundHandler];
+    const composed = (0, import_compose.compose)(
+      handlers,
+      this.notFoundHandler,
+      this.errorHandler
+    );
+    return (async () => {
+      try {
+        const tmp = composed(c);
+        const 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()`"
+          );
+        }
+        return context.res;
+      } catch (err) {
+        return this.handleError(err, c);
+      }
+    })();
+  }
 }
-exports.Hono = Hono;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Hono
+});

package/dist/cjs/index.js

@@ -1,13 +1,33 @@
 "use strict";
-// @denoify-ignore
-// eslint-disable-next-line @typescript-eslint/triple-slash-reference
-/// <reference path="./request.ts" /> Import "declare global" for the Request interface.
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Hono = void 0;
-const hono_1 = require("./hono");
-Object.defineProperty(exports, "Hono", { enumerable: true, get: function () { return hono_1.Hono; } });
-hono_1.Hono.prototype.fire = function () {
-    addEventListener('fetch', (event) => {
-        void event.respondWith(this.handleEvent(event));
-    });
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var src_exports = {};
+__export(src_exports, {
+  Hono: () => import_hono.Hono
+});
+module.exports = __toCommonJS(src_exports);
+var import_hono = require("./hono");
+import_hono.Hono.prototype.fire = function() {
+  addEventListener("fetch", (event) => {
+    void event.respondWith(this.handleEvent(event));
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Hono
+});

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

@@ -1,47 +1,78 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.basicAuth = void 0;
-const buffer_1 = require("../../utils/buffer");
-const encode_1 = require("../../utils/encode");
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var basic_auth_exports = {};
+__export(basic_auth_exports, {
+  basicAuth: () => basicAuth
+});
+module.exports = __toCommonJS(basic_auth_exports);
+var import_buffer = require("../../utils/buffer");
+var import_encode = require("../../utils/encode");
 const CREDENTIALS_REGEXP = /^ *(?:[Bb][Aa][Ss][Ii][Cc]) +([A-Za-z0-9._~+/-]+=*) *$/;
 const USER_PASS_REGEXP = /^([^:]*):(.*)$/;
 const auth = (req) => {
-    const match = CREDENTIALS_REGEXP.exec(req.headers.get('Authorization') || '');
-    if (!match) {
-        return undefined;
-    }
-    const userPass = USER_PASS_REGEXP.exec((0, encode_1.decodeBase64)(match[1]));
-    if (!userPass) {
-        return undefined;
-    }
-    return { username: userPass[1], password: userPass[2] };
+  const match = CREDENTIALS_REGEXP.exec(req.headers.get("Authorization") || "");
+  if (!match) {
+    return void 0;
+  }
+  const userPass = USER_PASS_REGEXP.exec((0, import_encode.decodeBase64)(match[1]));
+  if (!userPass) {
+    return void 0;
+  }
+  return { username: userPass[1], password: userPass[2] };
 };
 const basicAuth = (options, ...users) => {
-    if (!options) {
-        throw new Error('basic auth middleware requires options for "username and password"');
-    }
-    if (!options.realm) {
-        options.realm = 'Secure Area';
-    }
-    users.unshift({ username: options.username, password: options.password });
-    return async (ctx, next) => {
-        const requestUser = auth(ctx.req);
-        if (requestUser) {
-            for (const user of users) {
-                const usernameEqual = await (0, buffer_1.timingSafeEqual)(user.username, requestUser.username, options.hashFunction);
-                const passwordEqual = await (0, buffer_1.timingSafeEqual)(user.password, requestUser.password, options.hashFunction);
-                if (usernameEqual && passwordEqual) {
-                    await next();
-                    return;
-                }
-            }
+  if (!options) {
+    throw new Error('basic auth middleware requires options for "username and password"');
+  }
+  if (!options.realm) {
+    options.realm = "Secure Area";
+  }
+  users.unshift({ username: options.username, password: options.password });
+  return async (ctx, next) => {
+    const requestUser = auth(ctx.req);
+    if (requestUser) {
+      for (const user of users) {
+        const usernameEqual = await (0, import_buffer.timingSafeEqual)(
+          user.username,
+          requestUser.username,
+          options.hashFunction
+        );
+        const passwordEqual = await (0, import_buffer.timingSafeEqual)(
+          user.password,
+          requestUser.password,
+          options.hashFunction
+        );
+        if (usernameEqual && passwordEqual) {
+          await next();
+          return;
         }
-        return new Response('Unauthorized', {
-            status: 401,
-            headers: {
-                'WWW-Authenticate': 'Basic realm="' + options.realm?.replace(/"/g, '\\"') + '"',
-            },
-        });
-    };
+      }
+    }
+    return new Response("Unauthorized", {
+      status: 401,
+      headers: {
+        "WWW-Authenticate": 'Basic realm="' + options.realm?.replace(/"/g, '\\"') + '"'
+      }
+    });
+  };
 };
-exports.basicAuth = basicAuth;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  basicAuth
+});

package/dist/cjs/middleware/bearer-auth/index.js

@@ -1,57 +1,75 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.bearerAuth = void 0;
-const buffer_1 = require("../../utils/buffer");
-const TOKEN_STRINGS = '[A-Za-z0-9._~+/-]+=*';
-const PREFIX = 'Bearer';
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var bearer_auth_exports = {};
+__export(bearer_auth_exports, {
+  bearerAuth: () => bearerAuth
+});
+module.exports = __toCommonJS(bearer_auth_exports);
+var import_buffer = require("../../utils/buffer");
+const TOKEN_STRINGS = "[A-Za-z0-9._~+/-]+=*";
+const PREFIX = "Bearer";
 const bearerAuth = (options) => {
-    if (!options.token) {
-        throw new Error('bearer auth middleware requires options for "token"');
-    }
-    if (!options.realm) {
-        options.realm = '';
-    }
-    if (!options.prefix) {
-        options.prefix = PREFIX;
-    }
-    const realm = options.realm?.replace(/"/g, '\\"');
-    return async (c, next) => {
-        const headerToken = c.req.headers.get('Authorization');
-        if (!headerToken) {
-            // No Authorization header
-            return new Response('Unauthorized', {
-                status: 401,
-                headers: {
-                    'WWW-Authenticate': `${options.prefix} realm="` + realm + '"',
-                },
-            });
+  if (!options.token) {
+    throw new Error('bearer auth middleware requires options for "token"');
+  }
+  if (!options.realm) {
+    options.realm = "";
+  }
+  if (!options.prefix) {
+    options.prefix = PREFIX;
+  }
+  const realm = options.realm?.replace(/"/g, '\\"');
+  return async (c, next) => {
+    const headerToken = c.req.headers.get("Authorization");
+    if (!headerToken) {
+      return new Response("Unauthorized", {
+        status: 401,
+        headers: {
+          "WWW-Authenticate": `${options.prefix} realm="` + realm + '"'
         }
-        else {
-            const regexp = new RegExp('^' + options.prefix + ' +(' + TOKEN_STRINGS + ') *$');
-            const match = regexp.exec(headerToken);
-            if (!match) {
-                // Invalid Request
-                return new Response('Bad Request', {
-                    status: 400,
-                    headers: {
-                        'WWW-Authenticate': `${options.prefix} error="invalid_request"`,
-                    },
-                });
-            }
-            else {
-                const equal = await (0, buffer_1.timingSafeEqual)(options.token, match[1], options.hashFunction);
-                if (!equal) {
-                    // Invalid Token
-                    return new Response('Unauthorized', {
-                        status: 401,
-                        headers: {
-                            'WWW-Authenticate': `${options.prefix} error="invalid_token"`,
-                        },
-                    });
-                }
+      });
+    } else {
+      const regexp = new RegExp("^" + options.prefix + " +(" + TOKEN_STRINGS + ") *$");
+      const match = regexp.exec(headerToken);
+      if (!match) {
+        return new Response("Bad Request", {
+          status: 400,
+          headers: {
+            "WWW-Authenticate": `${options.prefix} error="invalid_request"`
+          }
+        });
+      } else {
+        const equal = await (0, import_buffer.timingSafeEqual)(options.token, match[1], options.hashFunction);
+        if (!equal) {
+          return new Response("Unauthorized", {
+            status: 401,
+            headers: {
+              "WWW-Authenticate": `${options.prefix} error="invalid_token"`
             }
+          });
         }
-        await next();
-    };
+      }
+    }
+    await next();
+  };
 };
-exports.bearerAuth = bearerAuth;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  bearerAuth
+});