hono 4.9.7 → 4.9.9

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

@@ -27,17 +27,17 @@ module.exports = __toCommonJS(route_exports);
 var import_constants = require("../../request/constants");
 var import_url = require("../../utils/url");
 const matchedRoutes = (c) => c.req[import_constants.GET_MATCH_RESULT][0].map(([[, route]]) => route);
-const routePath = (c) => matchedRoutes(c)[c.req.routeIndex].path;
-const baseRoutePath = (c) => matchedRoutes(c)[c.req.routeIndex].basePath;
+const routePath = (c, index) => matchedRoutes(c).at(index ?? c.req.routeIndex)?.path ?? "";
+const baseRoutePath = (c, index) => matchedRoutes(c).at(index ?? c.req.routeIndex)?.basePath ?? "";
 const basePathCacheMap = /* @__PURE__ */ new WeakMap();
-const basePath = (c) => {
-  const routeIndex = c.req.routeIndex;
+const basePath = (c, index) => {
+  index ??= c.req.routeIndex;
   const cache = basePathCacheMap.get(c) || [];
-  if (typeof cache[routeIndex] === "string") {
-    return cache[routeIndex];
+  if (typeof cache[index] === "string") {
+    return cache[index];
   }
   let result;
-  const rp = baseRoutePath(c);
+  const rp = baseRoutePath(c, index);
   if (!/[:*]/.test(rp)) {
     result = rp;
   } else {
@@ -56,7 +56,7 @@ const basePath = (c) => {
     }
     result = reqPath.substring(0, basePathLength);
   }
-  cache[routeIndex] = result;
+  cache[index] = result;
   basePathCacheMap.set(c, cache);
   return result;
 };

package/dist/cjs/request.js

@@ -44,14 +44,14 @@ 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 : void 0;
+    return param && /\%/.test(param) ? tryDecodeURIComponent(param) : param;
   }
   #getAllDecodedParams() {
     const decoded = {};
     const keys = Object.keys(this.#matchResult[0][this.routeIndex][1]);
     for (const key of keys) {
       const value = this.#getParamValue(this.#matchResult[0][this.routeIndex][1][key]);
-      if (value && typeof value === "string") {
+      if (value !== void 0) {
         decoded[key] = /\%/.test(value) ? tryDecodeURIComponent(value) : value;
       }
     }

package/dist/helper/route/index.js

@@ -2,17 +2,17 @@
 import { GET_MATCH_RESULT } from "../../request/constants.js";
 import { getPattern, splitRoutingPath } from "../../utils/url.js";
 var matchedRoutes = (c) => c.req[GET_MATCH_RESULT][0].map(([[, route]]) => route);
-var routePath = (c) => matchedRoutes(c)[c.req.routeIndex].path;
-var baseRoutePath = (c) => matchedRoutes(c)[c.req.routeIndex].basePath;
+var routePath = (c, index) => matchedRoutes(c).at(index ?? c.req.routeIndex)?.path ?? "";
+var baseRoutePath = (c, index) => matchedRoutes(c).at(index ?? c.req.routeIndex)?.basePath ?? "";
 var basePathCacheMap = /* @__PURE__ */ new WeakMap();
-var basePath = (c) => {
-  const routeIndex = c.req.routeIndex;
+var basePath = (c, index) => {
+  index ??= c.req.routeIndex;
   const cache = basePathCacheMap.get(c) || [];
-  if (typeof cache[routeIndex] === "string") {
-    return cache[routeIndex];
+  if (typeof cache[index] === "string") {
+    return cache[index];
   }
   let result;
-  const rp = baseRoutePath(c);
+  const rp = baseRoutePath(c, index);
   if (!/[:*]/.test(rp)) {
     result = rp;
   } else {
@@ -31,7 +31,7 @@ var basePath = (c) => {
     }
     result = reqPath.substring(0, basePathLength);
   }
-  cache[routeIndex] = result;
+  cache[index] = result;
   basePathCacheMap.set(c, cache);
   return result;
 };

package/dist/request.js

@@ -22,14 +22,14 @@ var HonoRequest = class {
   #getDecodedParam(key) {
     const paramKey = this.#matchResult[0][this.routeIndex][1][key];
     const param = this.#getParamValue(paramKey);
-    return param ? /\%/.test(param) ? tryDecodeURIComponent(param) : param : void 0;
+    return param && /\%/.test(param) ? tryDecodeURIComponent(param) : param;
   }
   #getAllDecodedParams() {
     const decoded = {};
     const keys = Object.keys(this.#matchResult[0][this.routeIndex][1]);
     for (const key of keys) {
       const value = this.#getParamValue(this.#matchResult[0][this.routeIndex][1][key]);
-      if (value && typeof value === "string") {
+      if (value !== void 0) {
         decoded[key] = /\%/.test(value) ? tryDecodeURIComponent(value) : value;
       }
     }

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

@@ -3,6 +3,7 @@
  * @module
  */
 import type { Hono } from '../../hono';
+import type { Env, Schema } from '../../types';
 import type { FetchEvent } from './types';
 type Handler = (evt: FetchEvent) => void;
 export type HandleOptions = {
@@ -11,5 +12,5 @@ export type HandleOptions = {
 /**
  * Adapter for Service Worker
  */
-export declare const handle: (app: Hono, opts?: HandleOptions) => Handler;
+export declare const handle: <E extends Env, S extends Schema, BasePath extends string>(app: Hono<E, S, BasePath>, opts?: HandleOptions) => Handler;
 export {};

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

@@ -3,6 +3,7 @@
  * @module
  */
 import type { Hono } from '../../hono';
+import type { Env, Schema } from '../../types';
 import { handle } from './handler';
 import type { HandleOptions } from './handler';
 /**
@@ -23,5 +24,5 @@ import type { HandleOptions } from './handler';
  * fire(app)
  * ```
  */
-declare const fire: (app: Hono, options?: HandleOptions) => void;
+declare const fire: <E extends Env, S extends Schema, BasePath extends string>(app: Hono<E, S, BasePath>, options?: HandleOptions) => void;
 export { handle, fire };

package/dist/types/context.d.ts

@@ -4,7 +4,7 @@ import type { Env, FetchEventLike, H, Input, NotFoundHandler, RouterRoute, Typed
 import type { ResponseHeader } from './utils/headers';
 import type { ContentfulStatusCode, RedirectStatusCode, StatusCode } from './utils/http-status';
 import type { BaseMime } from './utils/mime';
-import type { InvalidJSONValue, IsAny, JSONParsed, JSONValue, SimplifyDeepArray } from './utils/types';
+import type { InvalidJSONValue, IsAny, JSONParsed, JSONValue } from './utils/types';
 type HeaderRecord = Record<"Content-Type", BaseMime> | Record<ResponseHeader, string | string[]> | Record<string, string | string[]>;
 /**
  * Data type can be a string, ArrayBuffer, Uint8Array (buffer), or ReadableStream.
@@ -128,16 +128,16 @@ interface TextRespond {
  * @returns {JSONRespondReturn<T, U>} - The response after rendering the JSON object, typed with the provided object and status code types.
  */
 interface JSONRespond {
-    <T extends JSONValue | SimplifyDeepArray<unknown> | InvalidJSONValue, U extends ContentfulStatusCode = ContentfulStatusCode>(object: T, status?: U, headers?: HeaderRecord): JSONRespondReturn<T, U>;
-    <T extends JSONValue | SimplifyDeepArray<unknown> | InvalidJSONValue, U extends ContentfulStatusCode = ContentfulStatusCode>(object: T, init?: ResponseOrInit<U>): JSONRespondReturn<T, U>;
+    <T extends JSONValue | {} | InvalidJSONValue, U extends ContentfulStatusCode = ContentfulStatusCode>(object: T, status?: U, headers?: HeaderRecord): JSONRespondReturn<T, U>;
+    <T extends JSONValue | {} | InvalidJSONValue, U extends ContentfulStatusCode = ContentfulStatusCode>(object: T, init?: ResponseOrInit<U>): JSONRespondReturn<T, U>;
 }
 /**
  * @template T - The type of the JSON value or simplified unknown type.
  * @template U - The type of the status code.
  *
- * @returns {Response & TypedResponse<SimplifyDeepArray<T> extends JSONValue ? (JSONValue extends SimplifyDeepArray<T> ? never : JSONParsed<T>) : never, U, 'json'>} - The response after rendering the JSON object, typed with the provided object and status code types.
+ * @returns {Response & TypedResponse<JSONParsed<T>, U, 'json'>} - The response after rendering the JSON object, typed with the provided object and status code types.
  */
-type JSONRespondReturn<T extends JSONValue | SimplifyDeepArray<unknown> | InvalidJSONValue, U extends ContentfulStatusCode> = Response & TypedResponse<SimplifyDeepArray<T> extends JSONValue ? JSONValue extends SimplifyDeepArray<T> ? never : JSONParsed<T> : never, U, "json">;
+export type JSONRespondReturn<T extends JSONValue | {} | InvalidJSONValue, U extends ContentfulStatusCode> = Response & TypedResponse<JSONParsed<T>, U, "json">;
 /**
  * Interface representing a function that responds with HTML content.
  *

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

@@ -31,22 +31,30 @@ export declare const matchedRoutes: (c: Context) => RouterRoute[];
  * Get the route path registered within the handler
  *
  * @param {Context} c - The context object
+ * @param {number} index - The index of the root from which to retrieve the path, similar to Array.prototype.at(), where a negative number is the index counted from the end of the matching root. Defaults to the current root index.
  * @returns The route path registered within the handler
  *
  * @example
  * ```ts
  * import { routePath } from 'hono/route'
  *
+ * app.use('*', (c, next) => {
+ *   console.log(routePath(c)) // '*'
+ *   console.log(routePath(c, -1)) // '/posts/:id'
+ *   return next()
+ * })
+ *
  * app.get('/posts/:id', (c) => {
  *   return c.text(routePath(c)) // '/posts/:id'
  * })
  * ```
  */
-export declare const routePath: (c: Context) => string;
+export declare const routePath: (c: Context, index?: number) => string;
 /**
  * Get the basePath of the as-is route specified by routing.
  *
  * @param {Context} c - The context object
+ * @param {number} index - The index of the root from which to retrieve the path, similar to Array.prototype.at(), where a negative number is the index counted from the end of the matching root. Defaults to the current root index.
  * @returns The basePath of the as-is route specified by routing.
  *
  * @example
@@ -63,5 +71,5 @@ export declare const routePath: (c: Context) => string;
  * app.route('/:sub', subApp)
  * ```
  */
-export declare const baseRoutePath: (c: Context) => string;
-export declare const basePath: (c: Context) => string;
+export declare const baseRoutePath: (c: Context, index?: number) => string;
+export declare const basePath: (c: Context, index?: number) => string;

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

@@ -23,15 +23,28 @@ type OmitSymbolKeys<T> = {
     [K in keyof T as K extends symbol ? never : K]: T[K];
 };
 export type JSONValue = JSONObject | JSONArray | JSONPrimitive;
-export type JSONParsed<T> = T extends {
+/**
+ * Convert a type to a JSON-compatible type.
+ *
+ * Non-JSON values such as `Date` implement `.toJSON()`,
+ * so they can be transformed to a value assignable to `JSONObject`
+ *
+ * `JSON.stringify()` throws a `TypeError` when it encounters a `bigint` value,
+ * unless a custom `replacer` function or `.toJSON()` method is provided.
+ *
+ * This behaviour can be controlled by the `TError` generic type parameter,
+ * which defaults to `bigint | ReadonlyArray<bigint>`.
+ * You can set it to `never` to disable this check.
+ */
+export type JSONParsed<T, TError = bigint | ReadonlyArray<bigint>> = T extends TError ? never : T extends {
     toJSON(): infer J;
 } ? (() => J) extends () => JSONPrimitive ? J : (() => J) extends () => {
     toJSON(): unknown;
-} ? {} : JSONParsed<J> : T extends JSONPrimitive ? T : T extends InvalidJSONValue ? never : T extends ReadonlyArray<unknown> ? {
-    [K in keyof T]: JSONParsed<InvalidToNull<T[K]>>;
-} : T extends Set<unknown> | Map<unknown, unknown> ? {} : T extends object ? {
-    [K in keyof OmitSymbolKeys<T> as IsInvalid<T[K]> extends true ? never : K]: boolean extends IsInvalid<T[K]> ? JSONParsed<T[K]> | undefined : JSONParsed<T[K]>;
-} : never;
+} ? {} : JSONParsed<J, TError> : T extends JSONPrimitive ? T : T extends InvalidJSONValue ? never : T extends ReadonlyArray<unknown> ? {
+    [K in keyof T]: JSONParsed<InvalidToNull<T[K]>, TError>;
+} : T extends Set<unknown> | Map<unknown, unknown> | Record<string, never> ? {} : T extends object ? T[keyof T] extends TError ? never : {
+    [K in keyof OmitSymbolKeys<T> as IsInvalid<T[K]> extends true ? never : K]: boolean extends IsInvalid<T[K]> ? JSONParsed<T[K], TError> | undefined : JSONParsed<T[K], TError>;
+} : T extends unknown ? JSONValue : never;
 /**
  * Useful to flatten the type output to improve type hints shown in editors. And also to transform an interface into a type to aide with assignability.
  * @copyright from sindresorhus/type-fest

package/package.json

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