hono 4.7.10 → 4.8.0

package/dist/jsx/streaming.js

@@ -4,8 +4,10 @@ import { HtmlEscapedCallbackPhase, resolveCallback } from "../utils/html.js";
 import { JSXNode } from "./base.js";
 import { childrenToString } from "./components.js";
 import { DOM_RENDERER, DOM_STASH } from "./constants.js";
+import { createContext, useContext } from "./context.js";
 import { Suspense as SuspenseDomRenderer } from "./dom/components.js";
 import { buildDataStack } from "./dom/render.js";
+var StreamingContext = createContext(null);
 var suspenseCounter = 0;
 var Suspense = async ({
   children,
@@ -17,6 +19,7 @@ var Suspense = async ({
   if (!Array.isArray(children)) {
     children = [children];
   }
+  const nonce = useContext(StreamingContext)?.scriptNonce;
   let resArray = [];
   const stackNode = { [DOM_STASH]: [0, []] };
   const popNodeStack = (value) => {
@@ -62,7 +65,7 @@ var Suspense = async ({
               content
             );
           }
-          let html = buffer ? "" : `<template data-hono-target="H:${index}">${content}</template><script>
+          let html = buffer ? "" : `<template data-hono-target="H:${index}">${content}</template><script${nonce ? ` nonce="${nonce}"` : ""}>
 ((d,c,n) => {
 c=d.currentScript.previousSibling
 d=d.getElementById('H:${index}')
@@ -137,6 +140,7 @@ var renderToReadableStream = (content, onError = console.trace) => {
   return reader;
 };
 export {
+  StreamingContext,
   Suspense,
   renderToReadableStream
 };

package/dist/middleware/cache/index.js

@@ -1,4 +1,5 @@
 // src/middleware/cache/index.ts
+var defaultCacheableStatusCodes = [200];
 var cache = (options) => {
   if (!globalThis.caches) {
     console.log("Cache Middleware is not enabled because caches is not defined.");
@@ -14,6 +15,9 @@ var cache = (options) => {
       'Middleware vary configuration cannot include "*", as it disallows effective caching.'
     );
   }
+  const cacheableStatusCodes = new Set(
+    options.cacheableStatusCodes ?? defaultCacheableStatusCodes
+  );
   const addHeader = (c) => {
     if (cacheControlDirectives) {
       const existingDirectives = c.res.headers.get("Cache-Control")?.split(",").map((d) => d.trim().split("=", 1)[0]) ?? [];
@@ -51,7 +55,7 @@ var cache = (options) => {
       return new Response(response.body, response);
     }
     await next();
-    if (!c.res.ok) {
+    if (!cacheableStatusCodes.has(c.res.status)) {
       return;
     }
     addHeader(c);

package/dist/middleware/cors/index.js

@@ -23,6 +23,15 @@ var cors = (options) => {
       return (origin) => optsOrigin.includes(origin) ? origin : null;
     }
   })(opts.origin);
+  const findAllowMethods = ((optsAllowMethods) => {
+    if (typeof optsAllowMethods === "function") {
+      return optsAllowMethods;
+    } else if (Array.isArray(optsAllowMethods)) {
+      return () => optsAllowMethods;
+    } else {
+      return () => [];
+    }
+  })(opts.allowMethods);
   return async function cors2(c, next) {
     function set(key, value) {
       c.res.headers.set(key, value);
@@ -49,8 +58,9 @@ var cors = (options) => {
       if (opts.maxAge != null) {
         set("Access-Control-Max-Age", opts.maxAge.toString());
       }
-      if (opts.allowMethods?.length) {
-        set("Access-Control-Allow-Methods", opts.allowMethods.join(","));
+      const allowMethods = findAllowMethods(c.req.header("origin") || "", c);
+      if (allowMethods.length) {
+        set("Access-Control-Allow-Methods", allowMethods.join(","));
       }
       let headers = opts.allowHeaders;
       if (!headers?.length) {

package/dist/middleware/etag/index.js

@@ -8,8 +8,9 @@ var RETAINED_304_HEADERS = [
   "expires",
   "vary"
 ];
+var stripWeak = (tag) => tag.replace(/^W\//, "");
 function etagMatches(etag2, ifNoneMatch) {
-  return ifNoneMatch != null && ifNoneMatch.split(/,\s*/).indexOf(etag2) > -1;
+  return ifNoneMatch != null && ifNoneMatch.split(/,\s*/).some((t) => stripWeak(t) === stripWeak(etag2));
 }
 function initializeGenerator(generator) {
   if (!generator) {

package/dist/middleware/jwk/jwk.js

@@ -51,6 +51,9 @@ var jwk = (options, init) => {
       }
     }
     if (!token) {
+      if (options.allow_anon) {
+        return next();
+      }
       const errDescription = "no authorization included in request";
       throw new HTTPException(401, {
         message: errDescription,
@@ -64,7 +67,9 @@ var jwk = (options, init) => {
     let payload;
     let cause;
     try {
-      payload = await Jwt.verifyFromJwks(token, options, init);
+      const keys = typeof options.keys === "function" ? await options.keys(ctx) : options.keys;
+      const jwks_uri = typeof options.jwks_uri === "function" ? await options.jwks_uri(ctx) : options.jwks_uri;
+      payload = await Jwt.verifyFromJwks(token, { keys, jwks_uri }, init);
     } catch (e) {
       cause = e;
     }

package/dist/middleware/jwt/jwt.js

@@ -11,7 +11,8 @@ var jwt = (options) => {
     throw new Error("`crypto.subtle.importKey` is undefined. JWT auth middleware requires it.");
   }
   return async function jwt2(ctx, next) {
-    const credentials = ctx.req.raw.headers.get("Authorization");
+    const headerName = options.headerName || "Authorization";
+    const credentials = ctx.req.raw.headers.get(headerName);
     let token;
     if (credentials) {
       const parts = credentials.split(/\s+/);

package/dist/middleware/logger/index.js

@@ -1,5 +1,5 @@
 // src/middleware/logger/index.ts
-import { getColorEnabled } from "../../utils/color.js";
+import { getColorEnabledAsync } from "../../utils/color.js";
 var humanize = (times) => {
   const [delimiter, separator] = [",", "."];
   const orderTimes = times.map((v) => v.replace(/(\d)(?=(\d\d\d)+(?!\d))/g, "$1" + delimiter));
@@ -9,8 +9,8 @@ var time = (start) => {
   const delta = Date.now() - start;
   return humanize([delta < 1e3 ? delta + "ms" : Math.round(delta / 1e3) + "s"]);
 };
-var colorStatus = (status) => {
-  const colorEnabled = getColorEnabled();
+var colorStatus = async (status) => {
+  const colorEnabled = await getColorEnabledAsync();
   if (colorEnabled) {
     switch (status / 100 | 0) {
       case 5:
@@ -25,18 +25,18 @@ var colorStatus = (status) => {
   }
   return `${status}`;
 };
-function log(fn, prefix, method, path, status = 0, elapsed) {
-  const out = prefix === "<--" /* Incoming */ ? `${prefix} ${method} ${path}` : `${prefix} ${method} ${path} ${colorStatus(status)} ${elapsed}`;
+async function log(fn, prefix, method, path, status = 0, elapsed) {
+  const out = prefix === "<--" /* Incoming */ ? `${prefix} ${method} ${path}` : `${prefix} ${method} ${path} ${await colorStatus(status)} ${elapsed}`;
   fn(out);
 }
 var logger = (fn = console.log) => {
   return async function logger2(c, next) {
     const { method, url } = c.req;
     const path = url.slice(url.indexOf("/", 8));
-    log(fn, "<--" /* Incoming */, method, path);
+    await log(fn, "<--" /* Incoming */, method, path);
     const start = Date.now();
     await next();
-    log(fn, "-->" /* Outgoing */, method, path, c.res.status, time(start));
+    await log(fn, "-->" /* Outgoing */, method, path, c.res.status, time(start));
   };
 };
 export {

package/dist/request/constants.js

@@ -0,0 +1,5 @@
+// src/request/constants.ts
+var GET_MATCH_RESULT = Symbol();
+export {
+  GET_MATCH_RESULT
+};

package/dist/request.js

@@ -1,4 +1,5 @@
 // src/request.ts
+import { GET_MATCH_RESULT } from "./request/constants.js";
 import { parseBody } from "./utils/body.js";
 import { decodeURIComponent_, getQueryParam, getQueryParams, tryDecode } from "./utils/url.js";
 var tryDecodeURIComponent = (str) => tryDecode(str, decodeURIComponent_);
@@ -100,6 +101,9 @@ var HonoRequest = class {
   get method() {
     return this.raw.method;
   }
+  get [GET_MATCH_RESULT]() {
+    return this.#matchResult;
+  }
   get matchedRoutes() {
     return this.#matchResult[0].map(([[, route]]) => route);
   }

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

@@ -28,11 +28,10 @@ var Node = class {
       const nextP = parts[i + 1];
       const pattern = getPattern(p, nextP);
       const key = Array.isArray(pattern) ? pattern[0] : p;
-      if (Object.keys(curNode.#children).includes(key)) {
+      if (key in curNode.#children) {
         curNode = curNode.#children[key];
-        const pattern2 = getPattern(p, nextP);
-        if (pattern2) {
-          possibleKeys.push(pattern2[1]);
+        if (pattern) {
+          possibleKeys.push(pattern[1]);
         }
         continue;
       }
@@ -43,14 +42,13 @@ var Node = class {
       }
       curNode = curNode.#children[key];
     }
-    const m = /* @__PURE__ */ Object.create(null);
-    const handlerSet = {
-      handler,
-      possibleKeys: possibleKeys.filter((v, i, a) => a.indexOf(v) === i),
-      score: this.#order
-    };
-    m[method] = handlerSet;
-    curNode.#methods.push(m);
+    curNode.#methods.push({
+      [method]: {
+        handler,
+        possibleKeys: possibleKeys.filter((v, i, a) => a.indexOf(v) === i),
+        score: this.#order
+      }
+    });
     return curNode;
   }
   #getHandlerSets(node, method, nodeParams, params) {
@@ -113,7 +111,7 @@ var Node = class {
             }
             continue;
           }
-          if (part === "") {
+          if (!part) {
             continue;
           }
           const [key, name, matcher] = pattern;

package/dist/types/adapter/cloudflare-pages/handler.d.ts

@@ -6,6 +6,7 @@ export type EventContext<Env = {}, P extends string = any, Data = Record<string,
     functionPath: string;
     waitUntil: (promise: Promise<unknown>) => void;
     passThroughOnException: () => void;
+    props: any;
     next: (input?: Request | string, init?: RequestInit) => Promise<Response>;
     env: Env & {
         ASSETS: {

package/dist/types/adapter/service-worker/handler.d.ts

@@ -5,10 +5,11 @@
 import type { Hono } from '../../hono';
 import type { FetchEvent } from './types';
 type Handler = (evt: FetchEvent) => void;
+export type HandleOptions = {
+    fetch?: typeof fetch;
+};
 /**
  * Adapter for Service Worker
  */
-export declare const handle: (app: Hono, opts?: {
-    fetch?: typeof fetch;
-}) => Handler;
+export declare const handle: (app: Hono, opts?: HandleOptions) => Handler;
 export {};

package/dist/types/adapter/service-worker/index.d.ts

@@ -2,4 +2,26 @@
  * Service Worker Adapter for Hono.
  * @module
  */
-export { handle } from './handler';
+import type { Hono } from '../../hono';
+import { handle } from './handler';
+import type { HandleOptions } from './handler';
+/**
+ * Registers a Hono app to handle fetch events in a service worker.
+ * This sets up `addEventListener('fetch', handle(app, options))` for the provided app.
+ *
+ * @param app - The Hono application instance
+ * @param options - Options for handling requests (fetch defaults to undefined)
+ * @example
+ * ```ts
+ * import { Hono } from 'hono'
+ * import { fire } from 'hono/service-worker'
+ *
+ * const app = new Hono()
+ *
+ * app.get('/', (c) => c.text('Hi'))
+ *
+ * fire(app)
+ * ```
+ */
+declare const fire: (app: Hono, options?: HandleOptions) => void;
+export { handle, fire };

package/dist/types/context.d.ts

@@ -24,6 +24,10 @@ export interface ExecutionContext {
      * Allows the event to be passed through to subsequent event listeners.
      */
     passThroughOnException(): void;
+    /**
+     * For compatibility with Wrangler 4.x.
+     */
+    props: any;
 }
 /**
  * Interface for context variable mapping.
@@ -316,7 +320,7 @@ export declare class Context<E extends Env = any, P extends string = any, I exte
     /**
      * `.header()` can set headers.
      *
-     * @see {@link https://hono.dev/docs/api/context#body}
+     * @see {@link https://hono.dev/docs/api/context#header}
      *
      * @example
      * ```ts

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

@@ -6,7 +6,7 @@ import type { Context } from '../../context';
 export type Runtime = "node" | "deno" | "bun" | "workerd" | "fastly" | "edge-light" | "other";
 export declare const env: <T extends Record<string, unknown>, C extends Context = Context<{
     Bindings: T;
-}>>(c: T extends Record<string, unknown> ? Context : C, runtime?: Runtime) => T & C["env"];
+}, any, {}>>(c: T extends Record<string, unknown> ? Context : C, runtime?: Runtime) => T & C["env"];
 export declare const knownUserAgents: Partial<Record<Runtime, string>>;
 export declare const getRuntimeKey: () => Runtime;
 export declare const checkUserAgentEquals: (platform: string) => boolean;

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

@@ -0,0 +1,67 @@
+import type { Context } from '../../context';
+import type { RouterRoute } from '../../types';
+/**
+ * Get matched routes in the handler
+ *
+ * @param {Context} c - The context object
+ * @returns An array of matched routes
+ *
+ * @example
+ * ```ts
+ * import { matchedRoutes } from 'hono/route'
+ *
+ * app.use('*', async function logger(c, next) {
+ *   await next()
+ *   matchedRoutes(c).forEach(({ handler, method, path }, i) => {
+ *     const name = handler.name || (handler.length < 2 ? '[handler]' : '[middleware]')
+ *     console.log(
+ *       method,
+ *       ' ',
+ *       path,
+ *       ' '.repeat(Math.max(10 - path.length, 0)),
+ *       name,
+ *       i === c.req.routeIndex ? '<- respond from here' : ''
+ *     )
+ *   })
+ * })
+ * ```
+ */
+export declare const matchedRoutes: (c: Context) => RouterRoute[];
+/**
+ * Get the route path registered within the handler
+ *
+ * @param {Context} c - The context object
+ * @returns The route path registered within the handler
+ *
+ * @example
+ * ```ts
+ * import { routePath } from 'hono/route'
+ *
+ * app.get('/posts/:id', (c) => {
+ *   return c.text(routePath(c)) // '/posts/:id'
+ * })
+ * ```
+ */
+export declare const routePath: (c: Context) => string;
+/**
+ * Get the basePath of the as-is route specified by routing.
+ *
+ * @param {Context} c - The context object
+ * @returns The basePath of the as-is route specified by routing.
+ *
+ * @example
+ * ```ts
+ * import { baseRoutePath } from 'hono/route'
+ *
+ * const app = new Hono()
+ *
+ * const subApp = new Hono()
+ * subApp.get('/posts/:id', (c) => {
+ *   return c.text(baseRoutePath(c)) // '/:sub'
+ * })
+ *
+ * app.route('/:sub', subApp)
+ * ```
+ */
+export declare const baseRoutePath: (c: Context) => string;
+export declare const basePath: (c: Context) => string;

package/dist/types/helper/ssg/ssg.d.ts

@@ -1,5 +1,6 @@
 import type { Hono } from '../../hono';
 import type { Env, Schema } from '../../types';
+export declare const DEFAULT_OUTPUT_DIR = "./static";
 /**
  * @experimental
  * `FileSystemModule` is an experimental feature.
@@ -24,10 +25,15 @@ export interface ToSSGResult {
 export declare const defaultExtensionMap: Record<string, string>;
 export type BeforeRequestHook = (req: Request) => Request | false | Promise<Request | false>;
 export type AfterResponseHook = (res: Response) => Response | false | Promise<Response | false>;
-export type AfterGenerateHook = (result: ToSSGResult) => void | Promise<void>;
+export type AfterGenerateHook = (result: ToSSGResult, fsModule: FileSystemModule, options?: ToSSGOptions) => void | Promise<void>;
 export declare const combineBeforeRequestHooks: (hooks: BeforeRequestHook | BeforeRequestHook[]) => BeforeRequestHook;
 export declare const combineAfterResponseHooks: (hooks: AfterResponseHook | AfterResponseHook[]) => AfterResponseHook;
-export declare const combineAfterGenerateHooks: (hooks: AfterGenerateHook | AfterGenerateHook[]) => AfterGenerateHook;
+export declare const combineAfterGenerateHooks: (hooks: AfterGenerateHook | AfterGenerateHook[], fsModule: FileSystemModule, options?: ToSSGOptions) => AfterGenerateHook;
+export interface SSGPlugin {
+    beforeRequestHook?: BeforeRequestHook | BeforeRequestHook[];
+    afterResponseHook?: AfterResponseHook | AfterResponseHook[];
+    afterGenerateHook?: AfterGenerateHook | AfterGenerateHook[];
+}
 export interface ToSSGOptions {
     dir?: string;
     beforeRequestHook?: BeforeRequestHook | BeforeRequestHook[];
@@ -35,6 +41,7 @@ export interface ToSSGOptions {
     afterGenerateHook?: AfterGenerateHook | AfterGenerateHook[];
     concurrency?: number;
     extensionMap?: Record<string, string>;
+    plugins?: SSGPlugin[];
 }
 /**
  * @experimental

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

@@ -2,11 +2,11 @@
  * @module
  * Testing Helper for Hono.
  */
-import type { Client } from '../../client/types';
+import type { Client, ClientRequestOptions } from '../../client/types';
 import type { ExecutionContext } from '../../context';
 import type { Hono } from '../../hono';
 import type { Schema } from '../../types';
 import type { UnionToIntersection } from '../../utils/types';
 type ExtractEnv<T> = T extends Hono<infer E, Schema, string> ? E : never;
-export declare const testClient: <T extends Hono<any, Schema, string>>(app: T, Env?: ExtractEnv<T>["Bindings"] | {}, executionCtx?: ExecutionContext) => UnionToIntersection<Client<T>>;
+export declare const testClient: <T extends Hono<any, Schema, string>>(app: T, Env?: ExtractEnv<T>["Bindings"] | {}, executionCtx?: ExecutionContext, options?: Omit<ClientRequestOptions, "fetch">) => UnionToIntersection<Client<T>>;
 export {};

package/dist/types/hono-base.d.ts

@@ -204,6 +204,16 @@ declare class Hono<E extends Env = Env, S extends Schema = {}, BasePath extends
     /**
      * `.fire()` automatically adds a global fetch event listener.
      * This can be useful for environments that adhere to the Service Worker API, such as non-ES module Cloudflare Workers.
+     * @deprecated
+     * Use `fire` from `hono/service-worker` instead.
+     * ```ts
+     * import { Hono } from 'hono'
+     * import { fire } from 'hono/service-worker'
+     *
+     * const app = new Hono()
+     * // ...
+     * fire(app)
+     * ```
      * @see https://hono.dev/docs/api/hono#fire
      * @see https://developer.mozilla.org/en-US/docs/Web/API/Service_Worker_API
      * @see https://developers.cloudflare.com/workers/reference/migrate-to-module-workers/

package/dist/types/jsx/streaming.d.ts

@@ -4,7 +4,22 @@
  */
 import type { HtmlEscapedString } from '../utils/html';
 import { JSXNode } from './base';
-import type { FC, PropsWithChildren } from './';
+import type { FC, PropsWithChildren, Context as JSXContext } from './';
+/**
+ * Used to specify nonce for scripts generated by `Suspense` and `ErrorBoundary`.
+ *
+ * @example
+ * ```tsx
+ * <StreamingContext.Provider value={{ scriptNonce: 'test-nonce' }}>
+ *   <Suspense fallback={<p>Loading...</p>}>
+ *     <Content />
+ *   </Suspense>
+ * </StreamingContext.Provider>
+ * ```
+ */
+export declare const StreamingContext: JSXContext<{
+    scriptNonce: string;
+} | null>;
 /**
  * @experimental
  * `Suspense` is an experimental feature.

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

@@ -4,6 +4,7 @@
  */
 import type { Context } from '../../context';
 import type { MiddlewareHandler } from '../../types';
+import type { StatusCode } from '../../utils/http-status';
 /**
  * Cache Middleware for Hono.
  *
@@ -15,6 +16,7 @@ import type { MiddlewareHandler } from '../../types';
  * @param {string} [options.cacheControl] - A string of directives for the `Cache-Control` header.
  * @param {string | string[]} [options.vary] - Sets the `Vary` header in the response. If the original response header already contains a `Vary` header, the values are merged, removing any duplicates.
  * @param {Function} [options.keyGenerator] - Generates keys for every request in the `cacheName` store. This can be used to cache data based on request parameters or context parameters.
+ * @param {number[]} [options.cacheableStatusCodes=[200]] - An array of status codes that can be cached.
  * @returns {MiddlewareHandler} The middleware handler function.
  * @throws {Error} If the `vary` option includes "*".
  *
@@ -35,4 +37,5 @@ export declare const cache: (options: {
     cacheControl?: string;
     vary?: string | string[];
     keyGenerator?: (c: Context) => Promise<string> | string;
+    cacheableStatusCodes?: StatusCode[];
 }) => MiddlewareHandler;

package/dist/types/middleware/cors/index.d.ts

@@ -6,7 +6,7 @@ import type { Context } from '../../context';
 import type { MiddlewareHandler } from '../../types';
 type CORSOptions = {
     origin: string | string[] | ((origin: string, c: Context) => string | undefined | null);
-    allowMethods?: string[];
+    allowMethods?: string[] | ((origin: string, c: Context) => string[]);
     allowHeaders?: string[];
     maxAge?: number;
     credentials?: boolean;
@@ -19,7 +19,7 @@ type CORSOptions = {
  *
  * @param {CORSOptions} [options] - The options for the CORS middleware.
  * @param {string | string[] | ((origin: string, c: Context) => string | undefined | null)} [options.origin='*'] - The value of "Access-Control-Allow-Origin" CORS header.
- * @param {string[]} [options.allowMethods=['GET', 'HEAD', 'PUT', 'POST', 'DELETE', 'PATCH']] - The value of "Access-Control-Allow-Methods" CORS header.
+ * @param {string[] | ((origin: string, c: Context) => string[])} [options.allowMethods=['GET', 'HEAD', 'PUT', 'POST', 'DELETE', 'PATCH']] - The value of "Access-Control-Allow-Methods" CORS header.
  * @param {string[]} [options.allowHeaders=[]] - The value of "Access-Control-Allow-Headers" CORS header.
  * @param {number} [options.maxAge] - The value of "Access-Control-Max-Age" CORS header.
  * @param {boolean} [options.credentials] - The value of "Access-Control-Allow-Credentials" CORS header.

package/dist/types/middleware/jwk/jwk.d.ts

@@ -2,6 +2,7 @@
  * @module
  * JWK Auth Middleware for Hono.
  */
+import type { Context } from '../../context';
 import type { MiddlewareHandler } from '../../types';
 import type { CookiePrefixOptions } from '../../utils/cookie';
 import '../../context';
@@ -12,17 +13,18 @@ import type { HonoJsonWebKey } from '../../utils/jwt/jws';
  * @see {@link https://hono.dev/docs/middleware/builtin/jwk}
  *
  * @param {object} options - The options for the JWK middleware.
- * @param {HonoJsonWebKey[] | (() => Promise<HonoJsonWebKey[]>)} [options.keys] - The values of your public keys, or a function that returns them.
- * @param {string} [options.jwks_uri] - If this value is set, attempt to fetch JWKs from this URI, expecting a JSON response with `keys` which are added to the provided options.keys
- * @param {string} [options.cookie] - If this value is set, then the value is retrieved from the cookie header using that value as a key, which is then validated as a token.
- * @param {RequestInit} [init] - Optional initialization options for the `fetch` request when retrieving JWKS from a URI.
+ * @param {HonoJsonWebKey[] | ((ctx: Context) => Promise<HonoJsonWebKey[]> | HonoJsonWebKey[])} [options.keys] - The public keys used for JWK verification, or a function that returns them.
+ * @param {string | ((ctx: Context) => Promise<string> | string)} [options.jwks_uri] - If set to a URI string or a function that returns a URI string, attempt to fetch JWKs from it. The response must be a JSON object containing a `keys` array, which will be merged with the `keys` option.
+ * @param {boolean} [options.allow_anon] - If set to `true`, the middleware allows requests without a token to proceed without authentication.
+ * @param {string} [options.cookie] - If set, the middleware attempts to retrieve the token from a cookie with these options (optionally signed) only if no token is found in the header.
+ * @param {RequestInit} [init] - Optional init options for the `fetch` request when retrieving JWKS from a URI.
  * @returns {MiddlewareHandler} The middleware handler function.
  *
  * @example
  * ```ts
  * const app = new Hono()
  *
- * app.use("/auth/*", jwk({ jwks_uri: "https://example-backend.hono.dev/.well-known/jwks.json" }))
+ * app.use("/auth/*", jwk({ jwks_uri: (c) => `https://${c.env.authServer}/.well-known/jwks.json` }))
  *
  * app.get('/auth/page', (c) => {
  *   return c.text('You are authorized')
@@ -30,8 +32,9 @@ import type { HonoJsonWebKey } from '../../utils/jwt/jws';
  * ```
  */
 export declare const jwk: (options: {
-    keys?: HonoJsonWebKey[] | (() => Promise<HonoJsonWebKey[]>);
-    jwks_uri?: string;
+    keys?: HonoJsonWebKey[] | ((ctx: Context) => Promise<HonoJsonWebKey[]> | HonoJsonWebKey[]);
+    jwks_uri?: string | ((ctx: Context) => Promise<string> | string);
+    allow_anon?: boolean;
     cookie?: string | {
         key: string;
         secret?: string | BufferSource;

package/dist/types/middleware/jwt/jwt.d.ts

@@ -19,6 +19,7 @@ export type JwtVariables<T = any> = {
  * @param {SignatureKey} [options.secret] - A value of your secret key.
  * @param {string} [options.cookie] - If this value is set, then the value is retrieved from the cookie header using that value as a key, which is then validated as a token.
  * @param {SignatureAlgorithm} [options.alg=HS256] - An algorithm type that is used for verifying. Available types are `HS256` | `HS384` | `HS512` | `RS256` | `RS384` | `RS512` | `PS256` | `PS384` | `PS512` | `ES256` | `ES384` | `ES512` | `EdDSA`.
+ * @param {string} [options.headerName='Authorization'] - The name of the header to look for the JWT token. Default is 'Authorization'.
  * @returns {MiddlewareHandler} The middleware handler function.
  *
  * @example
@@ -29,6 +30,7 @@ export type JwtVariables<T = any> = {
  *   '/auth/*',
  *   jwt({
  *     secret: 'it-is-very-secret',
+ *     headerName: 'x-custom-auth-header', // Optional, default is 'Authorization'
  *   })
  * )
  *
@@ -45,6 +47,7 @@ export declare const jwt: (options: {
         prefixOptions?: CookiePrefixOptions;
     };
     alg?: SignatureAlgorithm;
+    headerName?: string;
 }) => MiddlewareHandler;
 export declare const verify: (token: string, publicKey: SignatureKey, alg?: SignatureAlgorithm) => Promise<import("../../utils/jwt/types").JWTPayload>;
 export declare const decode: (token: string) => {

package/dist/types/request/constants.d.ts

@@ -0,0 +1 @@
+export declare const GET_MATCH_RESULT: symbol;

package/dist/types/request.d.ts

@@ -235,6 +235,10 @@ export declare class HonoRequest<P extends string = "/", I extends Input["out"]
     /**
      * `.matchedRoutes()` can return a matched route in the handler
      *
+     * @deprecated
+     *
+     * Use matchedRoutes helper defined in "hono/route" instead.
+     *
      * @see {@link https://hono.dev/docs/api/request#matchedroutes}
      *
      * @example
@@ -259,6 +263,10 @@ export declare class HonoRequest<P extends string = "/", I extends Input["out"]
     /**
      * `routePath()` can retrieve the path registered within the handler
      *
+     * @deprecated
+     *
+     * Use routePath helper defined in "hono/route" instead.
+     *
      * @see {@link https://hono.dev/docs/api/request#routepath}
      *
      * @example

package/dist/types/types.d.ts

@@ -24,6 +24,7 @@ export type Input = {
 export type BlankSchema = {};
 export type BlankInput = {};
 export interface RouterRoute {
+    basePath: string;
     path: string;
     method: string;
     handler: H;

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

@@ -5,8 +5,17 @@
 /**
  * Get whether color change on terminal is enabled or disabled.
  * If `NO_COLOR` environment variable is set, this function returns `false`.
+ * Unlike getColorEnabledAsync(), this cannot check Cloudflare environment variables.
  * @see {@link https://no-color.org/}
  *
  * @returns {boolean}
  */
 export declare function getColorEnabled(): boolean;
+/**
+ * Get whether color change on terminal is enabled or disabled.
+ * If `NO_COLOR` environment variable is set, this function returns `false`.
+ * @see {@link https://no-color.org/}
+ *
+ * @returns {boolean}
+ */
+export declare function getColorEnabledAsync(): Promise<boolean>;