hono 4.12.34 → 4.13.0

package/dist/cjs/context.js

@@ -295,11 +295,11 @@ class Context {
     return Object.fromEntries(this.#var);
   }
   #newResponse(data, arg, headers) {
-    const responseHeaders = this.#res ? new Headers(this.#res.headers) : this.#preparedHeaders ?? new Headers();
-    if (typeof arg === "object" && "headers" in arg) {
-      const argHeaders = arg.headers instanceof Headers ? arg.headers : new Headers(arg.headers);
-      for (const [key, value] of argHeaders) {
-        if (key.toLowerCase() === "set-cookie") {
+    let responseHeaders = this.#res ? new Headers(this.#res.headers) : this.#preparedHeaders;
+    if (typeof arg === "object" && arg.headers) {
+      responseHeaders ??= new Headers();
+      for (const [key, value] of new Headers(arg.headers)) {
+        if (key === "set-cookie") {
           responseHeaders.append(key, value);
         } else {
           responseHeaders.set(key, value);
@@ -307,19 +307,34 @@ class Context {
       }
     }
     if (headers) {
-      for (const [k, v] of Object.entries(headers)) {
-        if (typeof v === "string") {
-          responseHeaders.set(k, v);
-        } else {
-          responseHeaders.delete(k);
-          for (const v2 of v) {
-            responseHeaders.append(k, v2);
+      if (!responseHeaders) {
+        let count = 0;
+        for (const k in headers) {
+          if (++count > 1 || typeof headers[k] !== "string") {
+            responseHeaders = new Headers();
+            break;
+          }
+        }
+      }
+      if (responseHeaders) {
+        for (const k in headers) {
+          const v = headers[k];
+          if (typeof v === "string") {
+            responseHeaders.set(k, v);
+          } else {
+            responseHeaders.delete(k);
+            for (const v2 of v) {
+              responseHeaders.append(k, v2);
+            }
           }
         }
       }
     }
     const status = typeof arg === "number" ? arg : arg?.status ?? this.#status;
-    return createResponseInstance(data, { status, headers: responseHeaders });
+    return createResponseInstance(data, {
+      status,
+      headers: responseHeaders ?? headers
+    });
   }
   newResponse = (...args) => this.#newResponse(...args);
   /**

package/dist/cjs/hono-base.js

@@ -43,6 +43,7 @@ class Hono {
   delete;
   options;
   patch;
+  query;
   all;
   on;
   use;
@@ -342,8 +343,8 @@ class Hono {
    * @see {@link https://hono.dev/docs/api/hono#fetch}
    *
    * @param {Request} request - request Object of request
-   * @param {Env} Env - env Object
-   * @param {ExecutionContext} - context of execution
+   * @param {Env} env - env Object
+   * @param {ExecutionContext} executionCtx - context of execution
    * @returns {Response | Promise<Response>} response of request
    *
    */

package/dist/cjs/jsx/base.js

@@ -100,6 +100,18 @@ const booleanAttributes = [
   "reversed",
   "selected"
 ];
+const resolveFunctionComponentResult = (result, suspendedContext) => result.then((resolved) => {
+  if (!Array.isArray(resolved) && !(resolved instanceof JSXNode)) {
+    return resolved;
+  }
+  const children = Array.isArray(resolved) ? resolved : [resolved];
+  const render = () => {
+    const buffer = [""];
+    childrenToStringToBuffer(children, buffer);
+    return buffer.length === 1 ? (0, import_html.raw)(buffer[0], buffer.callbacks) : (0, import_html2.stringBufferToString)(buffer, buffer.callbacks);
+  };
+  return suspendedContext ? suspendedContext(render) : (0, import_context.runWithRenderContext)(render);
+});
 const childrenToStringToBuffer = (children, buffer) => {
   for (let i = 0, len = children.length; i < len; i++) {
     const child = children[i];
@@ -109,9 +121,17 @@ const childrenToStringToBuffer = (children, buffer) => {
       continue;
     } else if (child instanceof JSXNode) {
       child.toStringToBuffer(buffer);
-    } else if (typeof child === "number" || child.isEscaped) {
+    } else if (typeof child === "number") {
       ;
       buffer[0] += child;
+    } else if (child.isEscaped) {
+      ;
+      buffer[0] += child;
+      const callbacks = child.callbacks;
+      if (callbacks) {
+        buffer.callbacks ||= [];
+        buffer.callbacks.push(...callbacks);
+      }
     } else if (child instanceof Promise) {
       buffer.unshift("", child);
     } else {
@@ -125,7 +145,6 @@ class JSXNode {
   key;
   children;
   isEscaped = true;
-  suspendedContext;
   constructor(tag, props, children) {
     if (typeof tag !== "function" && !(0, import_utils.isValidTagName)(tag)) {
       throw new Error(`Invalid JSX tag name: ${tag}`);
@@ -148,7 +167,7 @@ class JSXNode {
       this.toStringToBuffer(buffer);
       return buffer.length === 1 ? "callbacks" in buffer ? (0, import_html2.resolveCallbackSync)((0, import_html.raw)(buffer[0], buffer.callbacks)).toString() : buffer[0] : (0, import_html2.stringBufferToString)(buffer, buffer.callbacks);
     };
-    return this.suspendedContext ? this.suspendedContext(render) : (0, import_context.runWithRenderContext)(render);
+    return (0, import_context.runWithRenderContext)(render);
   }
   toStringToBuffer(buffer) {
     const tag = this.tag;
@@ -222,21 +241,14 @@ class JSXFunctionNode extends JSXNode {
       return;
     } else if (res instanceof Promise) {
       if (import_context.globalContexts.length === 0) {
-        buffer.unshift("", res);
+        buffer.unshift("", resolveFunctionComponentResult(res));
       } else {
-        const suspendedContext = (0, import_context.captureRenderContext)();
-        buffer.unshift(
-          "",
-          res.then((childRes) => {
-            if (childRes instanceof JSXNode) {
-              childRes.suspendedContext = suspendedContext;
-            }
-            return childRes;
-          })
-        );
+        buffer.unshift("", resolveFunctionComponentResult(res, (0, import_context.captureRenderContext)()));
       }
     } else if (res instanceof JSXNode) {
       res.toStringToBuffer(buffer);
+    } else if (Array.isArray(res)) {
+      childrenToStringToBuffer(res, buffer);
     } else if (typeof res === "number" || res.isEscaped) {
       buffer[0] += res;
       if (res.callbacks) {

package/dist/cjs/jsx/hooks/index.js

@@ -263,7 +263,7 @@ const useCallback = (callback, deps) => {
   }
   return callback;
 };
-const useRef = (initialValue) => {
+function useRef(initialValue) {
   const buildData = import_render.buildDataStack.at(-1);
   if (!buildData) {
     return { current: initialValue };
@@ -272,7 +272,7 @@ const useRef = (initialValue) => {
   const refArray = node[import_constants.DOM_STASH][1][STASH_REF] ||= [];
   const hookIndex = node[import_constants.DOM_STASH][0]++;
   return refArray[hookIndex] ||= { current: initialValue };
-};
+}
 const use = (promise) => {
   const cachedRes = resolvedPromiseValueMap.get(promise);
   if (cachedRes) {

package/dist/cjs/middleware/cache/index.js

@@ -20,7 +20,21 @@ __export(cache_exports, {
   cache: () => cache
 });
 module.exports = __toCommonJS(cache_exports);
+var import_request = require("../../request");
+var import_crypto = require("../../utils/crypto");
 const defaultCacheableStatusCodes = [200];
+const defaultMaxQueryBodySize = 64 * 1024;
+const cacheKeyPath = "/.hono/cache";
+const cacheKeyParameter = "__hono_cache_key";
+const cacheMethodKeyParameter = "__hono_cache_method";
+const queryDigestKeyParameter = "__hono_query_digest";
+const cacheVaryKeyParameter = "__hono_cache_vary";
+const queryRepresentationMetadataHeaders = [
+  "content-type",
+  "content-encoding",
+  "content-language",
+  "content-location"
+];
 const shouldSkipCacheControl = (cacheControl) => !!cacheControl && /(?:^|,\s*)(?:private|no-(?:store|cache))(?:\s*(?:=|,|$))/i.test(cacheControl);
 const parseVaryDirectives = (vary) => {
   if (vary == null) {
@@ -28,17 +42,86 @@ const parseVaryDirectives = (vary) => {
   }
   return (Array.isArray(vary) ? vary : vary.split(",")).map((directive) => directive.trim().toLowerCase()).filter(Boolean);
 };
+const createCacheKey = (key, requestUrl, request, varyHeaders) => {
+  const url = new URL(cacheKeyPath, requestUrl);
+  url.searchParams.append(cacheKeyParameter, key.split("#", 1)[0]);
+  url.searchParams.append(cacheMethodKeyParameter, request.method);
+  if (request.method === "QUERY") {
+    url.searchParams.append(queryDigestKeyParameter, request.digest);
+  }
+  for (const header of varyHeaders) {
+    url.searchParams.append(cacheVaryKeyParameter, JSON.stringify(header));
+  }
+  return url.href;
+};
 const shouldSkipCache = (res, optionsVaryDirectives, responseVary) => responseVary.length && (!optionsVaryDirectives || responseVary.some((name) => !optionsVaryDirectives.has(name))) || shouldSkipCacheControl(res.headers.get("Cache-Control")) || res.headers.has("Set-Cookie");
+const reportCacheNotAvailable = (onCacheNotAvailable, reason) => {
+  if (onCacheNotAvailable === false) {
+  } else if (onCacheNotAvailable) {
+    onCacheNotAvailable(reason);
+  } else {
+    console.log(reason);
+  }
+};
+const createQueryDigest = async (c, maxQueryBodySize) => {
+  if (!globalThis.crypto?.subtle) {
+    return void 0;
+  }
+  if (c.req.raw.bodyUsed && Object.keys(c.req.bodyCache)[0] === "formData") {
+    return void 0;
+  }
+  try {
+    const requestHeaders = c.req.raw.headers;
+    const metadata = new TextEncoder().encode(
+      JSON.stringify(
+        queryRepresentationMetadataHeaders.map((header) => [header, requestHeaders.get(header)])
+      )
+    );
+    const body = (await (0, import_request.cloneRawRequest)(c.req)).body;
+    const chunks = [];
+    let bodySize = 0;
+    if (body) {
+      const reader = body.getReader();
+      for (; ; ) {
+        const { done, value } = await reader.read();
+        if (done) {
+          break;
+        }
+        bodySize += value.byteLength;
+        if (bodySize > maxQueryBodySize) {
+          void reader.cancel().catch(() => {
+          });
+          return void 0;
+        }
+        chunks.push(value);
+      }
+    }
+    const data = new Uint8Array(metadata.byteLength + bodySize);
+    data.set(metadata);
+    let offset = metadata.byteLength;
+    for (const chunk of chunks) {
+      data.set(chunk, offset);
+      offset += chunk.byteLength;
+    }
+    return await (0, import_crypto.sha256)(data) ?? void 0;
+  } catch {
+    return void 0;
+  }
+};
 const cache = (options) => {
   if (!globalThis.caches) {
-    if (options.onCacheNotAvailable === false) {
-    } else if (options.onCacheNotAvailable) {
-      options.onCacheNotAvailable();
-    } else {
-      console.log("Cache Middleware is not enabled because caches is not defined.");
-    }
+    reportCacheNotAvailable(
+      options.onCacheNotAvailable,
+      "Cache Middleware is not enabled because caches is not defined."
+    );
     return async (_c, next) => await next();
   }
+  if (!globalThis.crypto?.subtle) {
+    reportCacheNotAvailable(
+      options.onCacheNotAvailable,
+      "Cache Middleware cannot cache QUERY requests because Web Crypto is not available."
+    );
+  }
   if (options.wait === void 0) {
     options.wait = false;
   }
@@ -53,6 +136,7 @@ const cache = (options) => {
   const cacheableStatusCodes = new Set(
     options.cacheableStatusCodes ?? defaultCacheableStatusCodes
   );
+  const maxQueryBodySize = options.maxQueryBodySize ?? defaultMaxQueryBodySize;
   const addHeader = (c, responseVary) => {
     if (cacheControlDirectives) {
       const existingDirectives = c.res.headers.get("Cache-Control")?.split(",").map((d) => d.trim().split("=", 1)[0].toLowerCase()) ?? [];
@@ -81,20 +165,31 @@ const cache = (options) => {
     }
   };
   return async function cache2(c, next) {
-    if (c.req.method !== "GET" || c.req.raw.headers.has("Authorization")) {
+    if (c.req.method !== "GET" && c.req.method !== "QUERY" || c.req.raw.headers.has("Authorization")) {
       await next();
       return;
     }
+    let cacheKeyRequest = { method: "GET" };
+    if (c.req.method === "QUERY") {
+      const digest = await createQueryDigest(c, maxQueryBodySize);
+      if (digest === void 0) {
+        await next();
+        return;
+      }
+      cacheKeyRequest = { method: "QUERY", digest };
+    }
     let key = c.req.url;
     if (options.keyGenerator) {
       key = await options.keyGenerator(c);
     }
+    const varyHeaders = [];
     if (varyDirectives) {
       for (const directive of varyDirectives) {
         const value = c.req.raw.headers.get(directive) ?? "";
-        key += `::${directive}=${encodeURIComponent(value)}`;
+        varyHeaders.push([directive, value]);
       }
     }
+    key = createCacheKey(key, c.req.url, cacheKeyRequest, varyHeaders);
     const cacheName = typeof options.cacheName === "function" ? await options.cacheName(c) : options.cacheName;
     const cache3 = await caches.open(cacheName);
     const response = await cache3.match(key);

package/dist/cjs/middleware/compress/index.js

@@ -43,6 +43,7 @@ const selectEncoding = (header, candidates) => {
   }
   return best?.encoding;
 };
+const varyAcceptEncodingRegExp = /(?:^|,)\s*accept-encoding\s*(?:,|$)/i;
 const compress = (options) => {
   const threshold = options?.threshold ?? 1024;
   const candidates = options?.encoding ? [options.encoding] : ENCODING_TYPES;
@@ -66,6 +67,10 @@ const compress = (options) => {
     !shouldTransform(ctx.res)) {
       return;
     }
+    const current = ctx.res.headers.get("Vary");
+    if (current !== "*" && !(current && varyAcceptEncodingRegExp.test(current))) {
+      ctx.header("Vary", current ? `${current}, Accept-Encoding` : "Accept-Encoding");
+    }
     const accepted = ctx.req.header("Accept-Encoding");
     const encoding = selectEncoding(accepted, candidates);
     if (!encoding || !ctx.res.body) {

package/dist/cjs/middleware/cors/index.js

@@ -23,7 +23,7 @@ module.exports = __toCommonJS(cors_exports);
 const cors = (options) => {
   const opts = {
     origin: "*",
-    allowMethods: ["GET", "HEAD", "PUT", "POST", "DELETE", "PATCH"],
+    allowMethods: ["GET", "HEAD", "PUT", "POST", "DELETE", "PATCH", "QUERY"],
     allowHeaders: [],
     exposeHeaders: [],
     ...options

package/dist/cjs/middleware/etag/index.js

@@ -70,7 +70,7 @@ const etag = (options) => {
       }
       etag3 = weak ? `W/"${hash}"` : `"${hash}"`;
     }
-    const matched = ifNoneMatch === "*" ? (c.req.method === "GET" || c.req.method === "HEAD") && res.ok : etagMatches(etag3, ifNoneMatch);
+    const matched = ifNoneMatch === "*" ? (c.req.method === "GET" || c.req.method === "HEAD" || c.req.method === "QUERY") && res.ok : etagMatches(etag3, ifNoneMatch);
     if (matched) {
       c.res = new Response(null, {
         status: 304,

package/dist/cjs/middleware/jwk/jwk.js

@@ -45,7 +45,8 @@ const jwk = (options, init) => {
           res: unauthorizedResponse({
             ctx,
             error: "invalid_request",
-            errDescription
+            errDescription,
+            realm: options.realm
           })
         });
       } else {
@@ -83,7 +84,8 @@ const jwk = (options, init) => {
         res: unauthorizedResponse({
           ctx,
           error: "invalid_request",
-          errDescription
+          errDescription,
+          realm: options.realm
         })
       });
     }
@@ -110,7 +112,8 @@ const jwk = (options, init) => {
           ctx,
           error: "invalid_token",
           statusText: "Unauthorized",
-          errDescription: "token verification failure"
+          errDescription: "token verification failure",
+          realm: options.realm
         }),
         cause
       });
@@ -120,11 +123,13 @@ const jwk = (options, init) => {
   };
 };
 function unauthorizedResponse(opts) {
+  const realm = (opts.realm ?? opts.ctx.req.url).replace(/"/g, '\\"');
+  const errDescription = opts.errDescription.replace(/"/g, '\\"');
   return new Response("Unauthorized", {
     status: 401,
     statusText: opts.statusText,
     headers: {
-      "WWW-Authenticate": `Bearer realm="${opts.ctx.req.url}",error="${opts.error}",error_description="${opts.errDescription}"`
+      "WWW-Authenticate": `Bearer realm="${realm}",error="${opts.error}",error_description="${errDescription}"`
     }
   });
 }

package/dist/cjs/middleware/jwt/jwt.js

@@ -52,7 +52,8 @@ const jwt = (options) => {
           res: unauthorizedResponse({
             ctx,
             error: "invalid_request",
-            errDescription
+            errDescription,
+            realm: options.realm
           })
         });
       } else {
@@ -87,7 +88,8 @@ const jwt = (options) => {
         res: unauthorizedResponse({
           ctx,
           error: "invalid_request",
-          errDescription
+          errDescription,
+          realm: options.realm
         })
       });
     }
@@ -108,7 +110,8 @@ const jwt = (options) => {
           ctx,
           error: "invalid_token",
           statusText: "Unauthorized",
-          errDescription: "token verification failure"
+          errDescription: "token verification failure",
+          realm: options.realm
         }),
         cause
       });
@@ -118,11 +121,13 @@ const jwt = (options) => {
   };
 };
 function unauthorizedResponse(opts) {
+  const realm = (opts.realm ?? opts.ctx.req.url).replace(/"/g, '\\"');
+  const errDescription = opts.errDescription.replace(/"/g, '\\"');
   return new Response("Unauthorized", {
     status: 401,
     statusText: opts.statusText,
     headers: {
-      "WWW-Authenticate": `Bearer realm="${opts.ctx.req.url}",error="${opts.error}",error_description="${opts.errDescription}"`
+      "WWW-Authenticate": `Bearer realm="${realm}",error="${opts.error}",error_description="${errDescription}"`
     }
   });
 }

package/dist/cjs/middleware/method-not-allowed/index.js

@@ -0,0 +1,90 @@
+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 method_not_allowed_exports = {};
+__export(method_not_allowed_exports, {
+  methodNotAllowed: () => methodNotAllowed
+});
+module.exports = __toCommonJS(method_not_allowed_exports);
+var import_route = require("../../helper/route");
+var import_router = require("../../router");
+var import_trie_router = require("../../router/trie-router");
+const methodNotAllowed = (options) => {
+  let methodRouter;
+  return async function methodNotAllowed2(c, next) {
+    const routeIndex = c.req.routeIndex;
+    await next();
+    if (c.res.status !== 404) {
+      return;
+    }
+    if (c.error) {
+      return;
+    }
+    if (!methodRouter) {
+      const methodsByPath = /* @__PURE__ */ new Map();
+      for (const route of options.app.routes) {
+        if (route.method === import_router.METHOD_NAME_ALL || route.method === "HEAD") {
+          continue;
+        }
+        const methods2 = methodsByPath.get(route.path) ?? /* @__PURE__ */ new Set();
+        methods2.add(route.method);
+        if (route.method === "GET") {
+          methods2.add("HEAD");
+        }
+        methodsByPath.set(route.path, methods2);
+      }
+      methodRouter = new import_trie_router.TrieRouter();
+      for (const [path, methods2] of methodsByPath) {
+        methodRouter.add(import_router.METHOD_NAME_ALL, path, [...methods2]);
+      }
+    }
+    let requestPath = c.req.path;
+    const routes = (0, import_route.matchedRoutes)(c);
+    const currentRoute = routes[routeIndex];
+    const sourceRoute = options.app.routes.find((route) => route.handler === methodNotAllowed2);
+    if (currentRoute && sourceRoute) {
+      const currentBasePathParts = (0, import_route.basePath)(c, routeIndex).split("/").filter(Boolean);
+      const sourceBasePathLength = sourceRoute.basePath.split("/").filter(Boolean).length;
+      const mountBasePathParts = currentBasePathParts.slice(
+        0,
+        currentBasePathParts.length - sourceBasePathLength
+      );
+      if (mountBasePathParts.length > 0) {
+        const mountBasePath = `/${mountBasePathParts.join("/")}`;
+        requestPath = c.req.path.slice(mountBasePath.length) || "/";
+      }
+    }
+    const allowedMethods = /* @__PURE__ */ new Set();
+    for (const [methods2] of methodRouter.match(import_router.METHOD_NAME_ALL, requestPath)[0]) {
+      for (const method of methods2) {
+        allowedMethods.add(method);
+      }
+    }
+    if (allowedMethods.size === 0 || allowedMethods.has(c.req.method)) {
+      return;
+    }
+    c.res.headers.delete("Allow");
+    c.res.headers.delete("Content-Length");
+    const methods = [...allowedMethods];
+    const allow = methods.join(", ");
+    c.res = options.onMethodNotAllowed ? await options.onMethodNotAllowed(c, methods) : c.text("Method Not Allowed", 405, { Allow: allow });
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  methodNotAllowed
+});

package/dist/cjs/request.js

@@ -25,7 +25,6 @@ var import_http_exception = require("./http-exception");
 var import_constants = require("./request/constants");
 var import_body = require("./utils/body");
 var import_url = require("./utils/url");
-const tryDecodeURIComponent = (str) => (0, import_url.tryDecode)(str, import_url.decodeURIComponent_);
 class HonoRequest {
   /**
    * `.raw` can get the raw Request object.
@@ -64,7 +63,6 @@ class HonoRequest {
     this.raw = request;
     this.path = path;
     this.#matchResult = matchResult;
-    this.#validatedData = {};
   }
   param(key) {
     return key ? this.#getDecodedParam(key) : this.#getAllDecodedParams();
@@ -72,7 +70,7 @@ class HonoRequest {
   #getDecodedParam(key) {
     const paramKey = this.#matchResult[0][this.routeIndex][1][key];
     const param = this.#getParamValue(paramKey);
-    return param && /\%/.test(param) ? tryDecodeURIComponent(param) : param;
+    return param && (0, import_url.tryDecodeURIComponent)(param);
   }
   #getAllDecodedParams() {
     const decoded = {};
@@ -80,7 +78,7 @@ class HonoRequest {
     for (const key of keys) {
       const value = this.#getParamValue(this.#matchResult[0][this.routeIndex][1][key]);
       if (value !== void 0) {
-        decoded[key] = /\%/.test(value) ? tryDecodeURIComponent(value) : value;
+        decoded[key] = (0, import_url.tryDecodeURIComponent)(value);
       }
     }
     return decoded;
@@ -113,8 +111,7 @@ class HonoRequest {
     if (cachedBody) {
       return cachedBody;
     }
-    const anyCachedKey = Object.keys(bodyCache)[0];
-    if (anyCachedKey) {
+    for (const anyCachedKey in bodyCache) {
       return bodyCache[anyCachedKey].then((body) => {
         if (anyCachedKey === "json") {
           body = JSON.stringify(body);
@@ -217,10 +214,11 @@ class HonoRequest {
    * @param data - The validated data to add.
    */
   addValidatedData(target, data) {
-    this.#validatedData[target] = data;
+    ;
+    (this.#validatedData ??= {})[target] = data;
   }
   valid(target) {
-    return this.#validatedData[target];
+    return this.#validatedData?.[target];
   }
   /**
    * `.url()` can get the request url strings.