hono 2.3.1 → 2.4.0

package/dist/hono.js

@@ -1,161 +1,165 @@
-import { compose } from './compose';
-import { HonoContext } from './context';
-import { extendRequestPrototype } from './request';
-import { METHODS } from './router';
-import { METHOD_NAME_ALL, METHOD_NAME_ALL_LOWERCASE } from './router';
-import { RegExpRouter } from './router/reg-exp-router';
-import { SmartRouter } from './router/smart-router';
-import { StaticRouter } from './router/static-router';
-import { TrieRouter } from './router/trie-router';
-import { getPathFromURL, mergePath } from './utils/url';
+// src/hono.ts
+import { compose } from "./compose.js";
+import { HonoContext } from "./context.js";
+import { extendRequestPrototype } from "./request.js";
+import { METHOD_NAME_ALL, METHOD_NAME_ALL_LOWERCASE, METHODS } from "./router.js";
+import { RegExpRouter } from "./router/reg-exp-router/index.js";
+import { SmartRouter } from "./router/smart-router/index.js";
+import { StaticRouter } from "./router/static-router/index.js";
+import { TrieRouter } from "./router/trie-router/index.js";
+import { getPathFromURL, mergePath } from "./utils/url.js";
 function defineDynamicClass() {
-    return class {
-    };
+  return class {
+  };
 }
-export class Hono extends defineDynamicClass() {
-    constructor(init = {}) {
-        super();
-        this.router = new SmartRouter({
-            routers: [new StaticRouter(), new RegExpRouter(), new 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);
-        };
-        extendRequestPrototype();
-        const allMethods = [...METHODS, 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);
+var Hono = class extends defineDynamicClass() {
+  constructor(init = {}) {
+    super();
+    this.router = new SmartRouter({
+      routers: [new StaticRouter(), new RegExpRouter(), new 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);
+    };
+    extendRequestPrototype();
+    const allMethods = [...METHODS, 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(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 = 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(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 = 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 = getPathFromURL(request.url, this.strict);
+    const method = request.method;
+    const result = this.matchRoute(method, path);
+    request.paramData = result?.params;
+    const c = new 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 = getPathFromURL(request.url, this.strict);
-        const method = request.method;
-        const result = this.matchRoute(method, path);
-        request.paramData = result?.params;
-        const c = new 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 = 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 = 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);
+      }
+    })();
+  }
+};
+export {
+  Hono
+};

package/dist/index.d.ts

@@ -1,7 +1,10 @@
 /// <reference path="request.d.ts" />
 import { Hono } from './hono';
-export type { Handler, Next, ContextVariableMap } from './hono';
+export type { Next, ContextVariableMap, MiddlewareHandler } from './types';
 export type { Context } from './context';
+export type { Validator } from './validator/validator';
+import type { CustomHandler } from './types';
+export type { CustomHandler as Handler };
 declare module './hono' {
     interface Hono {
         fire(): void;

package/dist/index.js

@@ -1,10 +1,10 @@
-// @denoify-ignore
-// eslint-disable-next-line @typescript-eslint/triple-slash-reference
-/// <reference path="./request.ts" /> Import "declare global" for the Request interface.
-import { Hono } from './hono';
-Hono.prototype.fire = function () {
-    addEventListener('fetch', (event) => {
-        void event.respondWith(this.handleEvent(event));
-    });
+// src/index.ts
+import { Hono } from "./hono.js";
+Hono.prototype.fire = function() {
+  addEventListener("fetch", (event) => {
+    void event.respondWith(this.handleEvent(event));
+  });
+};
+export {
+  Hono
 };
-export { Hono };

package/dist/middleware/basic-auth/index.d.ts

@@ -1,4 +1,4 @@
-import type { MiddlewareHandler } from '../../hono';
+import type { MiddlewareHandler } from '../../types';
 export declare const basicAuth: (options: {
     username: string;
     password: string;

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

@@ -1,43 +1,55 @@
-import { timingSafeEqual } from '../../utils/buffer';
-import { decodeBase64 } from '../../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(decodeBase64(match[1]));
-    if (!userPass) {
-        return undefined;
-    }
-    return { username: userPass[1], password: userPass[2] };
+// src/middleware/basic-auth/index.ts
+import { timingSafeEqual } from "../../utils/buffer.js";
+import { decodeBase64 } from "../../utils/encode.js";
+var CREDENTIALS_REGEXP = /^ *(?:[Bb][Aa][Ss][Ii][Cc]) +([A-Za-z0-9._~+/-]+=*) *$/;
+var USER_PASS_REGEXP = /^([^:]*):(.*)$/;
+var auth = (req) => {
+  const match = CREDENTIALS_REGEXP.exec(req.headers.get("Authorization") || "");
+  if (!match) {
+    return void 0;
+  }
+  const userPass = USER_PASS_REGEXP.exec(decodeBase64(match[1]));
+  if (!userPass) {
+    return void 0;
+  }
+  return { username: userPass[1], password: userPass[2] };
 };
-export 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 timingSafeEqual(user.username, requestUser.username, options.hashFunction);
-                const passwordEqual = await timingSafeEqual(user.password, requestUser.password, options.hashFunction);
-                if (usernameEqual && passwordEqual) {
-                    await next();
-                    return;
-                }
-            }
+var 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 timingSafeEqual(
+          user.username,
+          requestUser.username,
+          options.hashFunction
+        );
+        const passwordEqual = await 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, '\\"') + '"'
+      }
+    });
+  };
+};
+export {
+  basicAuth
 };

package/dist/middleware/bearer-auth/index.d.ts

@@ -1,4 +1,4 @@
-import type { MiddlewareHandler } from '../../hono';
+import type { MiddlewareHandler } from '../../types';
 export declare const bearerAuth: (options: {
     token: string;
     realm?: string;

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

@@ -1,53 +1,52 @@
-import { timingSafeEqual } from '../../utils/buffer';
-const TOKEN_STRINGS = '[A-Za-z0-9._~+/-]+=*';
-const PREFIX = 'Bearer';
-export 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 + '"',
-                },
-            });
+// src/middleware/bearer-auth/index.ts
+import { timingSafeEqual } from "../../utils/buffer.js";
+var TOKEN_STRINGS = "[A-Za-z0-9._~+/-]+=*";
+var PREFIX = "Bearer";
+var 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) {
+      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 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 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();
+  };
+};
+export {
+  bearerAuth
 };

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

@@ -1,4 +1,4 @@
-import type { MiddlewareHandler } from '../../hono';
+import type { MiddlewareHandler } from '../../types';
 export declare const cache: (options: {
     cacheName: string;
     wait?: boolean;

package/dist/middleware/cache/index.js

@@ -1,28 +1,30 @@
-export const cache = (options) => {
-    if (options.wait === undefined) {
-        options.wait = false;
+// src/middleware/cache/index.ts
+var cache = (options) => {
+  if (options.wait === void 0) {
+    options.wait = false;
+  }
+  const addHeader = (response) => {
+    if (options.cacheControl)
+      response.headers.append("Cache-Control", options.cacheControl);
+  };
+  return async (c, next) => {
+    const key = c.req;
+    const cache2 = await caches.open(options.cacheName);
+    const response = await cache2.match(key);
+    if (!response) {
+      await next();
+      addHeader(c.res);
+      const response2 = c.res.clone();
+      if (options.wait) {
+        await cache2.put(key, response2);
+      } else {
+        c.executionCtx.waitUntil(cache2.put(key, response2));
+      }
+    } else {
+      return response;
     }
-    const addHeader = (response) => {
-        if (options.cacheControl)
-            response.headers.append('Cache-Control', options.cacheControl);
-    };
-    return async (c, next) => {
-        const key = c.req;
-        const cache = await caches.open(options.cacheName);
-        const response = await cache.match(key);
-        if (!response) {
-            await next();
-            addHeader(c.res);
-            const response = c.res.clone();
-            if (options.wait) {
-                await cache.put(key, response);
-            }
-            else {
-                c.executionCtx.waitUntil(cache.put(key, response));
-            }
-        }
-        else {
-            return response;
-        }
-    };
+  };
+};
+export {
+  cache
 };

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

@@ -1,4 +1,4 @@
-import type { MiddlewareHandler } from '../../hono';
+import type { MiddlewareHandler } from '../../types';
 declare type EncodingType = 'gzip' | 'deflate';
 interface CompressionOptions {
     encoding?: EncodingType;