hono 4.6.7 → 4.6.9

package/dist/adapter/bun/websocket.js

@@ -16,16 +16,14 @@ var createWSContext = (ws) => {
   });
 };
 var createBunWebSocket = () => {
-  const websocketConns = [];
   const upgradeWebSocket = defineWebSocketHelper((c, events) => {
     const server = getBunServer(c);
     if (!server) {
       throw new TypeError("env has to include the 2nd argument of fetch.");
     }
-    const connId = websocketConns.push(events) - 1;
     const upgradeResult = server.upgrade(c.req.raw, {
       data: {
-        connId,
+        events,
         url: new URL(c.req.url),
         protocol: c.req.url
       }
@@ -37,13 +35,13 @@ var createBunWebSocket = () => {
   });
   const websocket = {
     open(ws) {
-      const websocketListeners = websocketConns[ws.data.connId];
+      const websocketListeners = ws.data.events;
       if (websocketListeners.onOpen) {
         websocketListeners.onOpen(new Event("open"), createWSContext(ws));
       }
     },
     close(ws, code, reason) {
-      const websocketListeners = websocketConns[ws.data.connId];
+      const websocketListeners = ws.data.events;
       if (websocketListeners.onClose) {
         websocketListeners.onClose(
           new CloseEvent("close", {
@@ -55,7 +53,7 @@ var createBunWebSocket = () => {
       }
     },
     message(ws, message) {
-      const websocketListeners = websocketConns[ws.data.connId];
+      const websocketListeners = ws.data.events;
       if (websocketListeners.onMessage) {
         const normalizedReceiveData = typeof message === "string" ? message : message.buffer;
         websocketListeners.onMessage(

package/dist/adapter/cloudflare-workers/websocket.js

@@ -1,45 +1,40 @@
 // src/adapter/cloudflare-workers/websocket.ts
 import { WSContext, defineWebSocketHelper } from "../../helper/websocket/index.js";
-var upgradeWebSocket = defineWebSocketHelper(
-  async (c, events) => {
-    const upgradeHeader = c.req.header("Upgrade");
-    if (upgradeHeader !== "websocket") {
-      return;
-    }
-    const webSocketPair = new WebSocketPair();
-    const client = webSocketPair[0];
-    const server = webSocketPair[1];
-    const wsContext = new WSContext({
-      close: (code, reason) => server.close(code, reason),
-      get protocol() {
-        return server.protocol;
-      },
-      raw: server,
-      get readyState() {
-        return server.readyState;
-      },
-      url: server.url ? new URL(server.url) : null,
-      send: (source) => server.send(source)
-    });
-    if (events.onOpen) {
-      server.addEventListener("open", (evt) => events.onOpen?.(evt, wsContext));
-    }
-    if (events.onClose) {
-      server.addEventListener("close", (evt) => events.onClose?.(evt, wsContext));
-    }
-    if (events.onMessage) {
-      server.addEventListener("message", (evt) => events.onMessage?.(evt, wsContext));
-    }
-    if (events.onError) {
-      server.addEventListener("error", (evt) => events.onError?.(evt, wsContext));
-    }
-    server.accept?.();
-    return new Response(null, {
-      status: 101,
-      webSocket: client
-    });
+var upgradeWebSocket = defineWebSocketHelper(async (c, events) => {
+  const upgradeHeader = c.req.header("Upgrade");
+  if (upgradeHeader !== "websocket") {
+    return;
   }
-);
+  const webSocketPair = new WebSocketPair();
+  const client = webSocketPair[0];
+  const server = webSocketPair[1];
+  const wsContext = new WSContext({
+    close: (code, reason) => server.close(code, reason),
+    get protocol() {
+      return server.protocol;
+    },
+    raw: server,
+    get readyState() {
+      return server.readyState;
+    },
+    url: server.url ? new URL(server.url) : null,
+    send: (source) => server.send(source)
+  });
+  if (events.onClose) {
+    server.addEventListener("close", (evt) => events.onClose?.(evt, wsContext));
+  }
+  if (events.onMessage) {
+    server.addEventListener("message", (evt) => events.onMessage?.(evt, wsContext));
+  }
+  if (events.onError) {
+    server.addEventListener("error", (evt) => events.onError?.(evt, wsContext));
+  }
+  server.accept?.();
+  return new Response(null, {
+    status: 101,
+    webSocket: client
+  });
+});
 export {
   upgradeWebSocket
 };

package/dist/adapter/deno/serve-static.js

@@ -6,11 +6,12 @@ var serveStatic = (options) => {
     const getContent = async (path) => {
       try {
         const file = await open(path);
-        return file ? file.readable : null;
+        return file.readable;
       } catch (e) {
         if (!(e instanceof errors.NotFound)) {
           console.warn(`${e}`);
         }
+        return null;
       }
     };
     const pathResolve = (path) => {

package/dist/adapter/lambda-edge/handler.js

@@ -31,7 +31,7 @@ var createResult = async (res) => {
     status: res.status.toString(),
     headers: convertHeaders(res.headers),
     body,
-    ...isBase64Encoded ? { bodyEncoding: "base64" } : {}
+    ...isBase64Encoded && { bodyEncoding: "base64" }
   };
 };
 var createRequest = (event) => {

package/dist/cjs/adapter/bun/websocket.js

@@ -39,16 +39,14 @@ const createWSContext = (ws) => {
   });
 };
 const createBunWebSocket = () => {
-  const websocketConns = [];
   const upgradeWebSocket = (0, import_websocket.defineWebSocketHelper)((c, events) => {
     const server = (0, import_server.getBunServer)(c);
     if (!server) {
       throw new TypeError("env has to include the 2nd argument of fetch.");
     }
-    const connId = websocketConns.push(events) - 1;
     const upgradeResult = server.upgrade(c.req.raw, {
       data: {
-        connId,
+        events,
         url: new URL(c.req.url),
         protocol: c.req.url
       }
@@ -60,13 +58,13 @@ const createBunWebSocket = () => {
   });
   const websocket = {
     open(ws) {
-      const websocketListeners = websocketConns[ws.data.connId];
+      const websocketListeners = ws.data.events;
       if (websocketListeners.onOpen) {
         websocketListeners.onOpen(new Event("open"), createWSContext(ws));
       }
     },
     close(ws, code, reason) {
-      const websocketListeners = websocketConns[ws.data.connId];
+      const websocketListeners = ws.data.events;
       if (websocketListeners.onClose) {
         websocketListeners.onClose(
           new CloseEvent("close", {
@@ -78,7 +76,7 @@ const createBunWebSocket = () => {
       }
     },
     message(ws, message) {
-      const websocketListeners = websocketConns[ws.data.connId];
+      const websocketListeners = ws.data.events;
       if (websocketListeners.onMessage) {
         const normalizedReceiveData = typeof message === "string" ? message : message.buffer;
         websocketListeners.onMessage(

package/dist/cjs/adapter/cloudflare-workers/websocket.js

@@ -22,46 +22,41 @@ __export(websocket_exports, {
 });
 module.exports = __toCommonJS(websocket_exports);
 var import_websocket = require("../../helper/websocket");
-const upgradeWebSocket = (0, import_websocket.defineWebSocketHelper)(
-  async (c, events) => {
-    const upgradeHeader = c.req.header("Upgrade");
-    if (upgradeHeader !== "websocket") {
-      return;
-    }
-    const webSocketPair = new WebSocketPair();
-    const client = webSocketPair[0];
-    const server = webSocketPair[1];
-    const wsContext = new import_websocket.WSContext({
-      close: (code, reason) => server.close(code, reason),
-      get protocol() {
-        return server.protocol;
-      },
-      raw: server,
-      get readyState() {
-        return server.readyState;
-      },
-      url: server.url ? new URL(server.url) : null,
-      send: (source) => server.send(source)
-    });
-    if (events.onOpen) {
-      server.addEventListener("open", (evt) => events.onOpen?.(evt, wsContext));
-    }
-    if (events.onClose) {
-      server.addEventListener("close", (evt) => events.onClose?.(evt, wsContext));
-    }
-    if (events.onMessage) {
-      server.addEventListener("message", (evt) => events.onMessage?.(evt, wsContext));
-    }
-    if (events.onError) {
-      server.addEventListener("error", (evt) => events.onError?.(evt, wsContext));
-    }
-    server.accept?.();
-    return new Response(null, {
-      status: 101,
-      webSocket: client
-    });
+const upgradeWebSocket = (0, import_websocket.defineWebSocketHelper)(async (c, events) => {
+  const upgradeHeader = c.req.header("Upgrade");
+  if (upgradeHeader !== "websocket") {
+    return;
   }
-);
+  const webSocketPair = new WebSocketPair();
+  const client = webSocketPair[0];
+  const server = webSocketPair[1];
+  const wsContext = new import_websocket.WSContext({
+    close: (code, reason) => server.close(code, reason),
+    get protocol() {
+      return server.protocol;
+    },
+    raw: server,
+    get readyState() {
+      return server.readyState;
+    },
+    url: server.url ? new URL(server.url) : null,
+    send: (source) => server.send(source)
+  });
+  if (events.onClose) {
+    server.addEventListener("close", (evt) => events.onClose?.(evt, wsContext));
+  }
+  if (events.onMessage) {
+    server.addEventListener("message", (evt) => events.onMessage?.(evt, wsContext));
+  }
+  if (events.onError) {
+    server.addEventListener("error", (evt) => events.onError?.(evt, wsContext));
+  }
+  server.accept?.();
+  return new Response(null, {
+    status: 101,
+    webSocket: client
+  });
+});
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   upgradeWebSocket

package/dist/cjs/adapter/deno/serve-static.js

@@ -28,11 +28,12 @@ const serveStatic = (options) => {
     const getContent = async (path) => {
       try {
         const file = await open(path);
-        return file ? file.readable : null;
+        return file.readable;
       } catch (e) {
         if (!(e instanceof errors.NotFound)) {
           console.warn(`${e}`);
         }
+        return null;
       }
     };
     const pathResolve = (path) => {

package/dist/cjs/adapter/lambda-edge/handler.js

@@ -61,7 +61,7 @@ const createResult = async (res) => {
     status: res.status.toString(),
     headers: convertHeaders(res.headers),
     body,
-    ...isBase64Encoded ? { bodyEncoding: "base64" } : {}
+    ...isBase64Encoded && { bodyEncoding: "base64" }
   };
 };
 const createRequest = (event) => {

package/dist/cjs/client/client.js

@@ -80,8 +80,8 @@ class ClientRequestImpl {
     }
     let methodUpperCase = this.method.toUpperCase();
     const headerValues = {
-      ...args?.header ?? {},
-      ...typeof opt?.headers === "function" ? await opt.headers() : opt?.headers ? opt.headers : {}
+      ...args?.header,
+      ...typeof opt?.headers === "function" ? await opt.headers() : opt?.headers
     };
     if (args?.cookie) {
       const cookies = [];
@@ -172,7 +172,7 @@ const hc = (baseUrl, options) => createProxy(function proxyCallback(opts) {
   const req = new ClientRequestImpl(url, method);
   if (method) {
     options ??= {};
-    const args = (0, import_utils.deepMerge)(options, { ...opts.args[1] ?? {} });
+    const args = (0, import_utils.deepMerge)(options, { ...opts.args[1] });
     return req.fetch(opts.args[0], args);
   }
   return req;

package/dist/cjs/compose.js

@@ -25,6 +25,7 @@ var import_context = require("./context");
 const compose = (middleware, onError, onNotFound) => {
   return (context, next) => {
     let index = -1;
+    const isContext = context instanceof import_context.Context;
     return dispatch(0);
     async function dispatch(i) {
       if (i <= index) {
@@ -36,14 +37,14 @@ const compose = (middleware, onError, onNotFound) => {
       let handler;
       if (middleware[i]) {
         handler = middleware[i][0][0];
-        if (context instanceof import_context.Context) {
+        if (isContext) {
           context.req.routeIndex = i;
         }
       } else {
         handler = i === middleware.length && next || void 0;
       }
       if (!handler) {
-        if (context instanceof import_context.Context && context.finalized === false && onNotFound) {
+        if (isContext && context.finalized === false && onNotFound) {
           res = await onNotFound(context);
         }
       } else {
@@ -52,7 +53,7 @@ const compose = (middleware, onError, onNotFound) => {
             return dispatch(i + 1);
           });
         } catch (err) {
-          if (err instanceof Error && context instanceof import_context.Context && onError) {
+          if (err instanceof Error && isContext && onError) {
             context.error = err;
             res = await onError(err, context);
             isError = true;

package/dist/cjs/context.js

@@ -26,7 +26,9 @@ var import_request = require("./request");
 var import_html = require("./utils/html");
 const TEXT_PLAIN = "text/plain; charset=UTF-8";
 const setHeaders = (headers, map = {}) => {
-  Object.entries(map).forEach(([key, value]) => headers.set(key, value));
+  for (const key of Object.keys(map)) {
+    headers.set(key, map[key]);
+  }
   return headers;
 };
 class Context {
@@ -173,7 +175,7 @@ class Context {
     }
     return Object.fromEntries(this.#var);
   }
-  newResponse = (data, arg, headers) => {
+  #newResponse(data, arg, headers) {
     if (this.#isFresh && !headers && !arg && this.#status === 200) {
       return new Response(data, {
         headers: this.#preparedHeaders
@@ -225,9 +227,10 @@ class Context {
       status,
       headers: this.#headers
     });
-  };
+  }
+  newResponse = (...args) => this.#newResponse(...args);
   body = (data, arg, headers) => {
-    return typeof arg === "number" ? this.newResponse(data, arg, headers) : this.newResponse(data, arg);
+    return typeof arg === "number" ? this.#newResponse(data, arg, headers) : this.#newResponse(data, arg);
   };
   text = (text, arg, headers) => {
     if (!this.#preparedHeaders) {
@@ -237,27 +240,27 @@ class Context {
       this.#preparedHeaders = {};
     }
     this.#preparedHeaders["content-type"] = TEXT_PLAIN;
-    return typeof arg === "number" ? this.newResponse(text, arg, headers) : this.newResponse(text, arg);
+    return typeof arg === "number" ? this.#newResponse(text, arg, headers) : this.#newResponse(text, arg);
   };
   json = (object, arg, headers) => {
     const body = JSON.stringify(object);
     this.#preparedHeaders ??= {};
     this.#preparedHeaders["content-type"] = "application/json; charset=UTF-8";
-    return typeof arg === "number" ? this.newResponse(body, arg, headers) : this.newResponse(body, arg);
+    return typeof arg === "number" ? this.#newResponse(body, arg, headers) : this.#newResponse(body, arg);
   };
   html = (html, arg, headers) => {
     this.#preparedHeaders ??= {};
     this.#preparedHeaders["content-type"] = "text/html; charset=UTF-8";
     if (typeof html === "object") {
       return (0, import_html.resolveCallback)(html, import_html.HtmlEscapedCallbackPhase.Stringify, false, {}).then((html2) => {
-        return typeof arg === "number" ? this.newResponse(html2, arg, headers) : this.newResponse(html2, arg);
+        return typeof arg === "number" ? this.#newResponse(html2, arg, headers) : this.#newResponse(html2, arg);
       });
     }
-    return typeof arg === "number" ? this.newResponse(html, arg, headers) : this.newResponse(html, arg);
+    return typeof arg === "number" ? this.#newResponse(html, arg, headers) : this.#newResponse(html, arg);
   };
   redirect = (location, status) => {
     this.#headers ??= new Headers();
-    this.#headers.set("Location", location);
+    this.#headers.set("Location", String(location));
     return this.newResponse(null, status ?? 302);
   };
   notFound = () => {

package/dist/cjs/helper/cookie/index.js

@@ -82,7 +82,7 @@ const setCookie = (c, name, value, opt) => {
   } else {
     cookie = (0, import_cookie.serialize)(name, value, { path: "/", ...opt });
   }
-  c.header("set-cookie", cookie, { append: true });
+  c.header("Set-Cookie", cookie, { append: true });
 };
 const setSignedCookie = async (c, name, value, secret, opt) => {
   let cookie;

package/dist/cjs/helper/html/index.js

@@ -27,7 +27,7 @@ const html = (strings, ...values) => {
   const buffer = [""];
   for (let i = 0, len = strings.length - 1; i < len; i++) {
     buffer[0] += strings[i];
-    const children = values[i] instanceof Array ? values[i].flat(Infinity) : [values[i]];
+    const children = Array.isArray(values[i]) ? values[i].flat(Infinity) : [values[i]];
     for (let i2 = 0, len2 = children.length; i2 < len2; i2++) {
       const child = children[i2];
       if (typeof child === "string") {

package/dist/cjs/helper/ssg/ssg.js

@@ -261,8 +261,8 @@ const toSSG = async (app, fs, options) => {
     result = { success: false, files: [], error: errorObj };
   }
   if (options?.afterGenerateHook) {
-    const conbinedAfterGenerateHooks = combineAfterGenerateHooks(options?.afterGenerateHook);
-    await conbinedAfterGenerateHooks(result);
+    const combinedAfterGenerateHooks = combineAfterGenerateHooks(options?.afterGenerateHook);
+    await combinedAfterGenerateHooks(result);
   }
   return result;
 };

package/dist/cjs/helper/ssg/utils.js

@@ -26,8 +26,8 @@ module.exports = __toCommonJS(utils_exports);
 var import_router = require("../../router");
 var import_handler = require("../../utils/handler");
 const dirname = (path) => {
-  const splittedPath = path.split(/[\/\\]/);
-  return splittedPath.slice(0, -1).join("/");
+  const separatedPath = path.split(/[\/\\]/);
+  return separatedPath.slice(0, -1).join("/");
 };
 const normalizePath = (path) => {
   return path.replace(/(\\)/g, "/").replace(/\/$/g, "");

package/dist/cjs/helper/websocket/index.js

@@ -32,10 +32,7 @@ class WSContext {
     this.protocol = init.protocol ?? null;
   }
   send(source, options) {
-    this.#init.send(
-      typeof source === "string" ? source : source instanceof Uint8Array ? source.buffer : source,
-      options ?? {}
-    );
+    this.#init.send(source, options ?? {});
   }
   raw;
   binaryType = "arraybuffer";

package/dist/cjs/hono-base.js

@@ -59,11 +59,11 @@ class Hono {
         if (typeof args1 === "string") {
           this.#path = args1;
         } else {
-          this.addRoute(method, this.#path, args1);
+          this.#addRoute(method, this.#path, args1);
         }
         args.forEach((handler) => {
           if (typeof handler !== "string") {
-            this.addRoute(method, this.#path, handler);
+            this.#addRoute(method, this.#path, handler);
           }
         });
         return this;
@@ -74,7 +74,7 @@ class Hono {
         this.#path = p;
         for (const m of [method].flat()) {
           handlers.map((handler) => {
-            this.addRoute(m.toUpperCase(), this.#path, handler);
+            this.#addRoute(m.toUpperCase(), this.#path, handler);
           });
         }
       }
@@ -88,7 +88,7 @@ class Hono {
         handlers.unshift(arg1);
       }
       handlers.forEach((handler) => {
-        this.addRoute(import_router.METHOD_NAME_ALL, this.#path, handler);
+        this.#addRoute(import_router.METHOD_NAME_ALL, this.#path, handler);
       });
       return this;
     };
@@ -97,7 +97,7 @@ class Hono {
     Object.assign(this, options);
     this.getPath = strict ? options.getPath ?? import_url.getPath : import_url.getPathNoStrict;
   }
-  clone() {
+  #clone() {
     const clone = new Hono({
       router: this.router,
       getPath: this.getPath
@@ -105,33 +105,33 @@ class Hono {
     clone.routes = this.routes;
     return clone;
   }
-  notFoundHandler = notFoundHandler;
-  errorHandler = errorHandler;
+  #notFoundHandler = notFoundHandler;
+  #errorHandler = errorHandler;
   route(path, app) {
     const subApp = this.basePath(path);
     app.routes.map((r) => {
       let handler;
-      if (app.errorHandler === errorHandler) {
+      if (app.#errorHandler === errorHandler) {
         handler = r.handler;
       } else {
-        handler = async (c, next) => (await (0, import_compose.compose)([], app.errorHandler)(c, () => r.handler(c, next))).res;
+        handler = async (c, next) => (await (0, import_compose.compose)([], app.#errorHandler)(c, () => r.handler(c, next))).res;
         handler[COMPOSED_HANDLER] = r.handler;
       }
-      subApp.addRoute(r.method, r.path, handler);
+      subApp.#addRoute(r.method, r.path, handler);
     });
     return this;
   }
   basePath(path) {
-    const subApp = this.clone();
+    const subApp = this.#clone();
     subApp._basePath = (0, import_url.mergePath)(this._basePath, path);
     return subApp;
   }
   onError = (handler) => {
-    this.errorHandler = handler;
+    this.#errorHandler = handler;
     return this;
   };
   notFound = (handler) => {
-    this.notFoundHandler = handler;
+    this.#notFoundHandler = handler;
     return this;
   };
   mount(path, applicationHandler, options) {
@@ -172,52 +172,49 @@ class Hono {
       }
       await next();
     };
-    this.addRoute(import_router.METHOD_NAME_ALL, (0, import_url.mergePath)(path, "*"), handler);
+    this.#addRoute(import_router.METHOD_NAME_ALL, (0, import_url.mergePath)(path, "*"), handler);
     return this;
   }
-  addRoute(method, path, handler) {
+  #addRoute(method, path, handler) {
     method = method.toUpperCase();
     path = (0, import_url.mergePath)(this._basePath, path);
     const r = { path, method, handler };
     this.router.add(method, path, [handler, r]);
     this.routes.push(r);
   }
-  matchRoute(method, path) {
-    return this.router.match(method, path);
-  }
-  handleError(err, c) {
+  #handleError(err, c) {
     if (err instanceof Error) {
-      return this.errorHandler(err, c);
+      return this.#errorHandler(err, c);
     }
     throw err;
   }
-  dispatch(request, executionCtx, env, method) {
+  #dispatch(request, executionCtx, env, method) {
     if (method === "HEAD") {
-      return (async () => new Response(null, await this.dispatch(request, executionCtx, env, "GET")))();
+      return (async () => new Response(null, await this.#dispatch(request, executionCtx, env, "GET")))();
     }
     const path = this.getPath(request, { env });
-    const matchResult = this.matchRoute(method, path);
+    const matchResult = this.router.match(method, path);
     const c = new import_context.Context(request, {
       path,
       matchResult,
       env,
       executionCtx,
-      notFoundHandler: this.notFoundHandler
+      notFoundHandler: this.#notFoundHandler
     });
     if (matchResult[0].length === 1) {
       let res;
       try {
         res = matchResult[0][0][0][0](c, async () => {
-          c.res = await this.notFoundHandler(c);
+          c.res = await this.#notFoundHandler(c);
         });
       } catch (err) {
-        return this.handleError(err, c);
+        return this.#handleError(err, c);
       }
       return res instanceof Promise ? res.then(
-        (resolved) => resolved || (c.finalized ? c.res : this.notFoundHandler(c))
-      ).catch((err) => this.handleError(err, c)) : res ?? this.notFoundHandler(c);
+        (resolved) => resolved || (c.finalized ? c.res : this.#notFoundHandler(c))
+      ).catch((err) => this.#handleError(err, c)) : res ?? this.#notFoundHandler(c);
     }
-    const composed = (0, import_compose.compose)(matchResult[0], this.errorHandler, this.notFoundHandler);
+    const composed = (0, import_compose.compose)(matchResult[0], this.#errorHandler, this.#notFoundHandler);
     return (async () => {
       try {
         const context = await composed(c);
@@ -228,12 +225,12 @@ class Hono {
         }
         return context.res;
       } catch (err) {
-        return this.handleError(err, c);
+        return this.#handleError(err, c);
       }
     })();
   }
   fetch = (request, ...rest) => {
-    return this.dispatch(request, rest[1], rest[0], request.method);
+    return this.#dispatch(request, rest[1], rest[0], request.method);
   };
   request = (input, requestInit, Env, executionCtx) => {
     if (input instanceof Request) {
@@ -249,7 +246,7 @@ class Hono {
   };
   fire = () => {
     addEventListener("fetch", (event) => {
-      event.respondWith(this.dispatch(event.request, event, void 0, event.request.method));
+      event.respondWith(this.#dispatch(event.request, event, void 0, event.request.method));
     });
   };
 }