hono 4.6.5 → 4.6.7

package/dist/router/trie-router/node.js

@@ -6,21 +6,18 @@ var Node = class {
   children;
   patterns;
   order = 0;
-  name;
   params = /* @__PURE__ */ Object.create(null);
   constructor(method, handler, children) {
     this.children = children || /* @__PURE__ */ Object.create(null);
     this.methods = [];
-    this.name = "";
     if (method && handler) {
       const m = /* @__PURE__ */ Object.create(null);
-      m[method] = { handler, possibleKeys: [], score: 0, name: this.name };
+      m[method] = { handler, possibleKeys: [], score: 0 };
       this.methods = [m];
     }
     this.patterns = [];
   }
   insert(method, path, handler) {
-    this.name = `${method} ${path}`;
     this.order = ++this.order;
     let curNode = this;
     const parts = splitRoutingPath(path);
@@ -50,7 +47,6 @@ var Node = class {
     const handlerSet = {
       handler,
       possibleKeys: possibleKeys.filter((v, i, a) => a.indexOf(v) === i),
-      name: this.name,
       score: this.order
     };
     m[method] = handlerSet;
@@ -65,11 +61,12 @@ var Node = class {
       const processedSet = /* @__PURE__ */ Object.create(null);
       if (handlerSet !== void 0) {
         handlerSet.params = /* @__PURE__ */ Object.create(null);
-        handlerSet.possibleKeys.forEach((key) => {
-          const processed = processedSet[handlerSet.name];
+        for (let i2 = 0, len2 = handlerSet.possibleKeys.length; i2 < len2; i2++) {
+          const key = handlerSet.possibleKeys[i2];
+          const processed = processedSet[handlerSet.score];
           handlerSet.params[key] = params[key] && !processed ? params[key] : nodeParams[key] ?? params[key];
-          processedSet[handlerSet.name] = true;
-        });
+          processedSet[handlerSet.score] = true;
+        }
         handlerSets.push(handlerSet);
       }
     }
@@ -90,7 +87,7 @@ var Node = class {
         const nextNode = node.children[part];
         if (nextNode) {
           nextNode.params = node.params;
-          if (isLast === true) {
+          if (isLast) {
             if (nextNode.children["*"]) {
               handlerSets.push(
                 ...this.gHSets(nextNode.children["*"], method, node.params, /* @__PURE__ */ Object.create(null))
@@ -123,10 +120,10 @@ var Node = class {
             handlerSets.push(...this.gHSets(child, method, node.params, params));
             continue;
           }
-          if (matcher === true || matcher instanceof RegExp && matcher.test(part)) {
+          if (matcher === true || matcher.test(part)) {
             if (typeof key === "string") {
               params[name] = part;
-              if (isLast === true) {
+              if (isLast) {
                 handlerSets.push(...this.gHSets(child, method, params, node.params));
                 if (child.children["*"]) {
                   handlerSets.push(...this.gHSets(child.children["*"], method, params, node.params));

package/dist/router/trie-router/router.js

@@ -10,8 +10,8 @@ var TrieRouter = class {
   add(method, path, handler) {
     const results = checkOptionalParameter(path);
     if (results) {
-      for (const p of results) {
-        this.node.insert(method, p, handler);
+      for (let i = 0, len = results.length; i < len; i++) {
+        this.node.insert(method, results[i], handler);
       }
       return;
     }

package/dist/types/adapter/bun/websocket.d.ts

@@ -1,5 +1,9 @@
 import type { UpgradeWebSocket } from '../../helper/websocket';
-interface BunServerWebSocket<T> {
+import { WSContext } from '../../helper/websocket';
+/**
+ * @internal
+ */
+export interface BunServerWebSocket<T> {
     send(data: string | ArrayBufferLike, compress?: boolean): void;
     close(code?: number, reason?: string): void;
     data: T;
@@ -19,5 +23,9 @@ export interface BunWebSocketData {
     url: URL;
     protocol: string;
 }
+/**
+ * @internal
+ */
+export declare const createWSContext: (ws: BunServerWebSocket<BunWebSocketData>) => WSContext;
 export declare const createBunWebSocket: <T>() => CreateWebSocket<T>;
 export {};

package/dist/types/adapter/vercel/handler.d.ts

@@ -1,3 +1,2 @@
 import type { Hono } from '../../hono';
-import type { FetchEventLike } from '../../types';
-export declare const handle: (app: Hono<any, any, any>) => (req: Request, requestContext: FetchEventLike) => Response | Promise<Response>;
+export declare const handle: (app: Hono<any, any, any>) => (req: Request) => Response | Promise<Response>;

package/dist/types/client/types.d.ts

@@ -28,8 +28,17 @@ export type ClientRequest<S extends Schema> = {
         input: infer R;
     } ? R extends {
         param: infer P;
+    } ? R extends {
+        query: infer Q;
     } ? {
         param: P;
+        query: Q;
+    } : {
+        param: P;
+    } : R extends {
+        query: infer Q;
+    } ? {
+        query: Q;
     } : {} : {}) => URL;
 } & (S["$get"] extends {
     outputFormat: "ws";

package/dist/types/client/utils.d.ts

@@ -1,5 +1,6 @@
 export declare const mergePath: (base: string, path: string) => string;
 export declare const replaceUrlParam: (urlString: string, params: Record<string, string | undefined>) => string;
+export declare const buildSearchParams: (query: Record<string, string | string[]>) => URLSearchParams;
 export declare const replaceUrlProtocol: (urlString: string, protocol: "ws" | "http") => string;
 export declare const removeIndexString: (urlSting: string) => string;
 export declare function deepMerge<T>(target: T, source: Record<string, unknown>): T;

package/dist/types/helper/websocket/index.d.ts

@@ -19,17 +19,46 @@ export interface WSEvents<T = unknown> {
 export type UpgradeWebSocket<T = unknown, U = any> = (createEvents: (c: Context) => WSEvents<T> | Promise<WSEvents<T>>, options?: U) => MiddlewareHandler<any, string, {
     outputFormat: "ws";
 }>;
+/**
+ * ReadyState for WebSocket
+ */
 export type WSReadyState = 0 | 1 | 2 | 3;
-export type WSContext<T = unknown> = {
-    send(source: string | ArrayBuffer | Uint8Array, options?: {
-        compress: boolean;
-    }): void;
+/**
+ * An argument for WSContext class
+ */
+export interface WSContestInit<T = unknown> {
+    send(data: string | ArrayBuffer, options: SendOptions): void;
+    close(code?: number, reason?: string): void;
     raw?: T;
-    binaryType: BinaryType;
     readyState: WSReadyState;
+    url?: string | URL | null;
+    protocol?: string | null;
+}
+/**
+ * Options for sending message
+ */
+export interface SendOptions {
+    compress?: boolean;
+}
+/**
+ * A context for controlling WebSockets
+ */
+export declare class WSContext<T = unknown> {
+    constructor(init: WSContestInit<T>);
+    send(source: string | ArrayBuffer | Uint8Array, options?: SendOptions): void;
+    raw?: T;
+    binaryType: BinaryType;
+    get readyState(): WSReadyState;
     url: URL | null;
     protocol: string | null;
     close(code?: number, reason?: string): void;
-};
+}
 export type WSMessageReceive = string | Blob | ArrayBufferLike;
 export declare const createWSMessageEvent: (source: WSMessageReceive) => MessageEvent<WSMessageReceive>;
+export interface WebSocketHelperDefineContext {
+}
+export type WebSocketHelperDefineHandler<T, U> = (c: Context, events: WSEvents<T>, options?: U) => Promise<Response | void> | Response | void;
+/**
+ * Create a WebSocket adapter/helper
+ */
+export declare const defineWebSocketHelper: <T = unknown, U = any>(handler: WebSocketHelperDefineHandler<T, U>) => UpgradeWebSocket<T, U>;

package/dist/types/middleware/powered-by/index.d.ts

@@ -4,7 +4,26 @@
  */
 import type { MiddlewareHandler } from '../../types';
 type PoweredByOptions = {
+    /**
+     * The value for X-Powered-By header.
+     * @default Hono
+     */
     serverName?: string;
 };
+/**
+ * Powered By Middleware for Hono.
+ *
+ * @param options - The options for the Powered By Middleware.
+ * @returns {MiddlewareHandler} The middleware handler function.
+ *
+ * @example
+ * ```ts
+ * import { poweredBy } from 'hono/powered-by'
+ *
+ * const app = new Hono()
+ *
+ * app.use(poweredBy()) // With options: poweredBy({ serverName: "My Server" })
+ * ```
+ */
 export declare const poweredBy: (options?: PoweredByOptions) => MiddlewareHandler;
 export {};

package/dist/types/router/trie-router/node.d.ts

@@ -4,14 +4,12 @@ type HandlerSet<T> = {
     handler: T;
     possibleKeys: string[];
     score: number;
-    name: string;
 };
 export declare class Node<T> {
     methods: Record<string, HandlerSet<T>>[];
     children: Record<string, Node<T>>;
     patterns: Pattern[];
     order: number;
-    name: string;
     params: Record<string, string>;
     constructor(method?: string, handler?: T, children?: Record<string, Node<T>>);
     insert(method: string, path: string, handler: T): Node<T>;

package/dist/utils/jwt/jws.js

@@ -21,8 +21,10 @@ async function importPrivateKey(key, alg) {
     throw new Error("`crypto.subtle.importKey` is undefined. JWT auth middleware requires it.");
   }
   if (isCryptoKey(key)) {
-    if (key.type !== "private") {
-      throw new Error(`unexpected non private key: CryptoKey.type is ${key.type}`);
+    if (key.type !== "private" && key.type !== "secret") {
+      throw new Error(
+        `unexpected key type: CryptoKey.type is ${key.type}, expected private or secret`
+      );
     }
     return key;
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hono",
-  "version": "4.6.5",
+  "version": "4.6.7",
   "description": "Web framework built on Web Standards",
   "main": "dist/cjs/index.js",
   "type": "module",