hono 4.4.2 → 4.4.4

package/dist/types/context.d.ts

@@ -1,7 +1,7 @@
 import type { HonoRequest } from './request';
 import type { Env, FetchEventLike, Input, NotFoundHandler, TypedResponse } from './types';
 import type { RedirectStatusCode, StatusCode } from './utils/http-status';
-import type { IsAny, JSONParsed, JSONValue, Simplify } from './utils/types';
+import type { IsAny, JSONParsed, JSONValue, SimplifyDeepArray } from './utils/types';
 type HeaderRecord = Record<string, string | string[]>;
 /**
  * Data type can be a string, ArrayBuffer, or ReadableStream.
@@ -109,12 +109,19 @@ interface TextRespond {
  * @param {U} [status] - An optional status code for the response.
  * @param {HeaderRecord} [headers] - An optional record of headers to include in the response.
  *
- * @returns {Response & TypedResponse<Simplify<T> extends JSONValue ? (JSONValue extends Simplify<T> ? never : JSONParsed<T>) : never, U, 'json'>} - The response after rendering the JSON object, typed with the provided object and status code types.
+ * @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 | Simplify<unknown>, U extends StatusCode>(object: T, status?: U, headers?: HeaderRecord): Response & TypedResponse<Simplify<T> extends JSONValue ? JSONValue extends Simplify<T> ? never : JSONParsed<T> : never, U, 'json'>;
-    <T extends JSONValue | Simplify<unknown>, U extends StatusCode>(object: Simplify<T> extends JSONValue ? T : Simplify<T>, init?: ResponseInit): Response & TypedResponse<Simplify<T> extends JSONValue ? JSONValue extends Simplify<T> ? never : JSONParsed<T> : never, U, 'json'>;
+    <T extends JSONValue | SimplifyDeepArray<unknown>, U extends StatusCode>(object: T, status?: U, headers?: HeaderRecord): JSONRespondReturn<T, U>;
+    <T extends JSONValue | SimplifyDeepArray<unknown>, U extends StatusCode>(object: T, init?: ResponseInit): 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.
+ */
+type JSONRespondReturn<T extends JSONValue | SimplifyDeepArray<unknown>, U extends StatusCode> = Response & TypedResponse<SimplifyDeepArray<T> extends JSONValue ? JSONValue extends SimplifyDeepArray<T> ? never : JSONParsed<T> : never, U, 'json'>;
 /**
  * Interface representing a function that responds with HTML content.
  *
@@ -157,6 +164,9 @@ export declare class Context<E extends Env = any, P extends string = any, I exte
     req: HonoRequest<P, I['out']>;
     /**
      * `.env` can get bindings (environment variables, secrets, KV namespaces, D1 database, R2 bucket etc.) in Cloudflare Workers.
+     *
+     * @see {@link https://hono.dev/api/context#env}
+     *
      * @example
      * ```ts
      * // Environment object for Cloudflare Workers
@@ -164,13 +174,15 @@ export declare class Context<E extends Env = any, P extends string = any, I exte
      *   const counter = c.env.COUNTER
      * })
      * ```
-     * @see https://hono.dev/api/context#env
      */
     env: E['Bindings'];
     private _var;
     finalized: boolean;
     /**
      * `.error` can get the error object from the middleware if the Handler throws an error.
+     *
+     * @see {@link https://hono.dev/api/context#error}
+     *
      * @example
      * ```ts
      * app.use('*', async (c, next) => {
@@ -180,7 +192,6 @@ export declare class Context<E extends Env = any, P extends string = any, I exte
      *   }
      * })
      * ```
-     * @see https://hono.dev/api/context#error
      */
     error: Error | undefined;
     private layout;
@@ -194,25 +205,22 @@ export declare class Context<E extends Env = any, P extends string = any, I exte
      */
     constructor(req: HonoRequest<P, I['out']>, options?: ContextOptions<E>);
     /**
+     * @see {@link https://hono.dev/api/context#event}
      * The FetchEvent associated with the current request.
      *
      * @throws Will throw an error if the context does not have a FetchEvent.
-     *
-     * @see https://hono.dev/api/context#event
      */
     get event(): FetchEventLike;
     /**
+     * @see {@link https://hono.dev/api/context#executionctx}
      * The ExecutionContext associated with the current request.
      *
      * @throws Will throw an error if the context does not have an ExecutionContext.
-     *
-     * @see https://hono.dev/api/context#executionctx
      */
     get executionCtx(): ExecutionContext;
     /**
+     * @see {@link https://hono.dev/api/context#res}
      * The Response object for the current request.
-     *
-     * @see https://hono.dev/api/context#res
      */
     get res(): Response;
     /**
@@ -222,7 +230,9 @@ export declare class Context<E extends Env = any, P extends string = any, I exte
      */
     set res(_res: Response | undefined);
     /**
-     * Renders a response within a layout.
+     * `.render()` can create a response within a layout.
+     *
+     * @see {@link https://hono.dev/api/context#render-setrenderer}
      *
      * @example
      * ```ts
@@ -230,7 +240,6 @@ export declare class Context<E extends Env = any, P extends string = any, I exte
      *   return c.render('Hello!')
      * })
      * ```
-     * @see https://hono.dev/api/context#render-setrenderer
      */
     render: Renderer;
     /**
@@ -254,6 +263,9 @@ export declare class Context<E extends Env = any, P extends string = any, I exte
     }> | undefined;
     /**
      * `.setRenderer()` can set the layout in the custom middleware.
+     *
+     * @see {@link https://hono.dev/api/context#render-setrenderer}
+     *
      * @example
      * ```tsx
      * app.use('*', async (c, next) => {
@@ -269,11 +281,13 @@ export declare class Context<E extends Env = any, P extends string = any, I exte
      *   await next()
      * })
      * ```
-     * @see https://hono.dev/api/context#render-setrenderer
      */
     setRenderer: (renderer: Renderer) => void;
     /**
      * `.header()` can set headers.
+     *
+     * @see {@link https://hono.dev/api/context#body}
+     *
      * @example
      * ```ts
      * app.get('/welcome', (c) => {
@@ -284,7 +298,6 @@ export declare class Context<E extends Env = any, P extends string = any, I exte
      *   return c.body('Thank you for coming')
      * })
      * ```
-     * @see https://hono.dev/api/context#body
      */
     header: (name: string, value: string | undefined, options?: {
         append?: boolean;
@@ -292,6 +305,9 @@ export declare class Context<E extends Env = any, P extends string = any, I exte
     status: (status: StatusCode) => void;
     /**
      * `.set()` can set the value specified by the key.
+     *
+     * @see {@link https://hono.dev/api/context#set-get}
+     *
      * @example
      * ```ts
      * app.use('*', async (c, next) => {
@@ -299,12 +315,14 @@ export declare class Context<E extends Env = any, P extends string = any, I exte
      *   await next()
      * })
      * ```
-     * @see https://hono.dev/api/context#set-get
   ```
      */
     set: Set<E>;
     /**
      * `.get()` can use the value specified by the key.
+     *
+     * @see {@link https://hono.dev/api/context#set-get}
+     *
      * @example
      * ```ts
      * app.get('/', (c) => {
@@ -312,16 +330,17 @@ export declare class Context<E extends Env = any, P extends string = any, I exte
      *   return c.text(`The message is "${message}"`)
      * })
      * ```
-     * @see https://hono.dev/api/context#set-get
      */
     get: Get<E>;
     /**
      * `.var` can access the value of a variable.
+     *
+     * @see {@link https://hono.dev/api/context#var}
+     *
      * @example
      * ```ts
      * const result = c.var.client.oneMethod()
      * ```
-     * @see https://hono.dev/api/context#var
      */
     get var(): Readonly<ContextVariableMap & (IsAny<E['Variables']> extends true ? Record<string, any> : E['Variables'])>;
     newResponse: NewResponse;
@@ -329,6 +348,9 @@ export declare class Context<E extends Env = any, P extends string = any, I exte
      * `.body()` can return the HTTP response.
      * You can set headers with `.header()` and set HTTP status code with `.status`.
      * This can also be set in `.text()`, `.json()` and so on.
+     *
+     * @see {@link https://hono.dev/api/context#body}
+     *
      * @example
      * ```ts
      * app.get('/welcome', (c) => {
@@ -342,34 +364,40 @@ export declare class Context<E extends Env = any, P extends string = any, I exte
      *   return c.body('Thank you for coming')
      * })
      * ```
-     * @see https://hono.dev/api/context#body
      */
     body: BodyRespond;
     /**
      * `.text()` can render text as `Content-Type:text/plain`.
+     *
+     * @see {@link https://hono.dev/api/context#text}
+     *
      * @example
      * ```ts
      * app.get('/say', (c) => {
      *   return c.text('Hello!')
      * })
      * ```
-     * @see https://hono.dev/api/context#text
      */
     text: TextRespond;
     /**
      * `.json()` can render JSON as `Content-Type:application/json`.
+     *
+     * @see {@link https://hono.dev/api/context#json}
+     *
      * @example
      * ```ts
      * app.get('/api', (c) => {
      *   return c.json({ message: 'Hello!' })
      * })
      * ```
-     * @see https://hono.dev/api/context#json
      */
     json: JSONRespond;
     html: HTMLRespond;
     /**
      * `.redirect()` can Redirect, default status code is 302.
+     *
+     * @see {@link https://hono.dev/api/context#redirect}
+     *
      * @example
      * ```ts
      * app.get('/redirect', (c) => {
@@ -379,18 +407,19 @@ export declare class Context<E extends Env = any, P extends string = any, I exte
      *   return c.redirect('/', 301)
      * })
      * ```
-     * @see https://hono.dev/api/context#redirect
      */
-    redirect: (location: string, status?: RedirectStatusCode) => Response;
+    redirect: <T extends RedirectStatusCode = 302>(location: string, status?: T | undefined) => Response & TypedResponse<undefined, T, "redirect">;
     /**
      * `.notFound()` can return the Not Found Response.
+     *
+     * @see {@link https://hono.dev/api/context#notfound}
+     *
      * @example
      * ```ts
      * app.get('/notfound', (c) => {
      *   return c.notFound()
      * })
      * ```
-     * @see https://hono.dev/api/context#notfound
      */
     notFound: () => Response | Promise<Response>;
 }

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

@@ -2,39 +2,4 @@
  * @module
  * ConnInfo Helper for Hono.
  */
-import type { Context } from '../../context';
-export type AddressType = 'IPv6' | 'IPv4' | 'unknown';
-export type NetAddrInfo = {
-    /**
-     * Transport protocol type
-     */
-    transport?: 'tcp' | 'udp';
-    /**
-     * Transport port number
-     */
-    port?: number;
-    address?: string;
-    addressType?: AddressType;
-} & ({
-    /**
-     * Host name such as IP Addr
-     */
-    address: string;
-    /**
-     * Host name type
-     */
-    addressType: AddressType;
-} | {});
-/**
- * HTTP Connection infomation
- */
-export interface ConnInfo {
-    /**
-     * Remote infomation
-     */
-    remote: NetAddrInfo;
-}
-/**
- * Helper type
- */
-export type GetConnInfo = (c: Context) => ConnInfo;
+export type { AddressType, NetAddrInfo, ConnInfo, GetConnInfo } from './types';

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

@@ -0,0 +1,36 @@
+import type { Context } from '../../context';
+export type AddressType = 'IPv6' | 'IPv4' | 'unknown';
+export type NetAddrInfo = {
+    /**
+     * Transport protocol type
+     */
+    transport?: 'tcp' | 'udp';
+    /**
+     * Transport port number
+     */
+    port?: number;
+    address?: string;
+    addressType?: AddressType;
+} & ({
+    /**
+     * Host name such as IP Addr
+     */
+    address: string;
+    /**
+     * Host name type
+     */
+    addressType: AddressType;
+} | {});
+/**
+ * HTTP Connection infomation
+ */
+export interface ConnInfo {
+    /**
+     * Remote infomation
+     */
+    remote: NetAddrInfo;
+}
+/**
+ * Helper type
+ */
+export type GetConnInfo = (c: Context) => ConnInfo;

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

@@ -16,20 +16,28 @@ type GetPath<E extends Env> = (request: Request, options?: {
 export type HonoOptions<E extends Env> = {
     /**
      * `strict` option specifies whether to distinguish whether the last path is a directory or not.
+     *
+     * @see {@link https://hono.dev/api/hono#strict-mode}
+     *
      * @default true
-     * @see https://hono.dev/api/hono#strict-mode
      */
     strict?: boolean;
     /**
      * `router` option specifices which router to use.
+     *
+     * @see {@link https://hono.dev/api/hono#router-option}
+     *
+     * @example
      * ```ts
      * const app = new Hono({ router: new RegExpRouter() })
      * ```
-     * @see https://hono.dev/api/hono#router-option
      */
     router?: Router<[H, RouterRoute]>;
     /**
      * `getPath` can handle the host header value.
+     *
+     * @see {@link https://hono.dev/api/routing#routing-with-host-header-value}
+     *
      * @example
      * ```ts
      * const app = new Hono({
@@ -44,10 +52,15 @@ export type HonoOptions<E extends Env> = {
      * //  headers: { host: 'www1.example.com' },
      * // })
      * ```
-     * @see https://hono.dev/api/routing#routing-with-host-header-value
      */
     getPath?: GetPath<E>;
 };
+type MountOptionHandler = (c: Context) => unknown;
+type MountReplaceRequest = (originalRequest: Request) => Request;
+type MountOptions = MountOptionHandler | {
+    optionHandler?: MountOptionHandler;
+    replaceRequest?: MountReplaceRequest;
+};
 declare class Hono<E extends Env = Env, S extends Schema = {}, BasePath extends string = '/'> {
     #private;
     get: HandlerInterface<E, 'get', S, BasePath>;
@@ -67,18 +80,48 @@ declare class Hono<E extends Env = Env, S extends Schema = {}, BasePath extends
     private clone;
     private notFoundHandler;
     private errorHandler;
+    /**
+     * `.route()` allows grouping other Hono instance in routes.
+     *
+     * @see {@link https://hono.dev/api/routing#grouping}
+     *
+     * @param {string} path - base Path
+     * @param {Hono} app - other Hono instance
+     * @returns {Hono} routed Hono instnace
+     *
+     * @example
+     * ```ts
+     * const app = new Hono()
+     * const app2 = new Hono()
+     *
+     * app2.get("/user", (c) => c.text("user"))
+     * app.route("/api", app2) // GET /api/user
+     * ```
+     */
     route<SubPath extends string, SubEnv extends Env, SubSchema extends Schema, SubBasePath extends string>(path: SubPath, app?: Hono<SubEnv, SubSchema, SubBasePath>): Hono<E, MergeSchemaPath<SubSchema, MergePath<BasePath, SubPath>> & S, BasePath>;
     /**
      * `.basePath()` allows base paths to be specified.
+     *
+     * @see {@link https://hono.dev/api/routing#base-path}
+     *
+     * @param {string} path - base Path
+     * @returns {Hono} changed Hono instance
+     *
      * @example
      * ```ts
      * const api = new Hono().basePath('/api')
      * ```
-     * @see https://hono.dev/api/routing#base-path
      */
     basePath<SubPath extends string>(path: SubPath): Hono<E, S, MergePath<BasePath, SubPath>>;
     /**
      * `.onError()` handles an error and returns a customized Response.
+     *
+     * @see {@link https://hono.dev/api/hono#error-handling}
+     *
+     * @param {ErrorHandler} handler - request Handler for error
+     * @returns {Hono} changed Hono instance
+     *
+     * @example
      * ```ts
      * app.onError((err, c) => {
      *   console.error(`${err}`)
@@ -89,39 +132,67 @@ declare class Hono<E extends Env = Env, S extends Schema = {}, BasePath extends
     onError: (handler: ErrorHandler<E>) => Hono<E, S, BasePath>;
     /**
      * `.notFound()` allows you to customize a Not Found Response.
+     *
+     * @see {@link https://hono.dev/api/hono#not-found}
+     *
+     * @param {NotFoundHandler} handler - request handler for not-found
+     * @returns {Hono} changed Hono instance
+     *
+     * @example
      * ```ts
      * app.notFound((c) => {
      *   return c.text('Custom 404 Message', 404)
      * })
      * ```
-     * @see https://hono.dev/api/hono#not-found
      */
     notFound: (handler: NotFoundHandler<E>) => Hono<E, S, BasePath>;
     /**
-     * Mounts an external application handler to the specified path.
+     * `.mount()` allows you to mount applications built with other frameworks into your Hono application.
      *
-     * @param path - The path where the external application handler should be mounted.
-     * @param applicationHandler - The external application handler function that processes requests.
-     * @param optionHandler - Optional function to handle additional options, such as environment variables and execution context.
+     * @see {@link https://hono.dev/api/hono#mount}
      *
-     * @returns The current instance of Hono for chaining.
+     * @param {string} path - base Path
+     * @param {Function} applicationHandler - other Request Handler
+     * @param {MountOptions} [options] - options of `.mount()`
+     * @returns {Hono} mounted Hono instance
      *
      * @example
      * ```ts
+     * import { Router as IttyRouter } from 'itty-router'
+     * import { Hono } from 'hono'
+     * // Create itty-router application
+     * const ittyRouter = IttyRouter()
+     * // GET /itty-router/hello
+     * ittyRouter.get('/hello', () => new Response('Hello from itty-router'))
+     *
      * const app = new Hono()
-     * const externalAppHandler = () => new Response('External App')
-     * app.mount('/external', externalAppHandler)
+     * app.mount('/itty-router', ittyRouter.handle)
+     * ```
+     *
+     * @example
+     * ```ts
+     * const app = new Hono()
+     * // Send the request to another application without modification.
+     * app.mount('/app', anotherApp, {
+     *   replaceRequest: (req) => req,
+     * })
      * ```
-     * @see https://hono.dev/api/hono#mount
      */
-    mount(path: string, applicationHandler: (request: Request, ...args: any) => Response | Promise<Response>, optionHandler?: (c: Context) => unknown): Hono<E, S, BasePath>;
+    mount(path: string, applicationHandler: (request: Request, ...args: any) => Response | Promise<Response>, options?: MountOptions): Hono<E, S, BasePath>;
     private addRoute;
     private matchRoute;
     private handleError;
     private dispatch;
     /**
      * `.fetch()` will be entry point of your app.
-     * @see https://hono.dev/api/hono#fetch
+     *
+     * @see {@link https://hono.dev/api/hono#fetch}
+     *
+     * @param {Request} request - reuqest Object of request
+     * @param {Env} Env - env Object
+     * @param {ExecutionContext} - context of execution
+     * @returns {Response | Promise<Response>} response of request
+     *
      */
     fetch: (request: Request, Env?: E['Bindings'] | {}, executionCtx?: ExecutionContext) => Response | Promise<Response>;
     /**

package/dist/types/http-exception.d.ts

@@ -16,6 +16,15 @@ type HTTPExceptionOptions = {
 };
 /**
  * `HTTPException` must be used when a fatal error such as authentication failure occurs.
+ *
+ * @see {@link https://hono.dev/api/exception}
+ *
+ * @param {StatusCode} status - status code of HTTPException
+ * @param {HTTPExceptionOptions} options - options of HTTPException
+ * @param {HTTPExceptionOptions["res"]} options.res - response of options of HTTPException
+ * @param {HTTPExceptionOptions["message"]} options.message - message of options of HTTPException
+ * @param {HTTPExceptionOptions["cause"]} options.cause - cause of options of HTTPException
+ *
  * @example
  * ```ts
  * import { HTTPException } from 'hono/http-exception'
@@ -30,7 +39,6 @@ type HTTPExceptionOptions = {
  *   await next()
  * })
  * ```
- * @see https://hono.dev/api/exception
  */
 export declare class HTTPException extends Error {
     readonly res?: Response;

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

@@ -1,2 +1,8 @@
+/**
+ * Normalizes intrinsic element properties by converting JSX element properties
+ * to their corresponding HTML attributes.
+ *
+ * @param props - JSX element properties.
+ */
 export declare const normalizeIntrinsicElementProps: (props: Record<string, unknown>) => void;
 export declare const styleObjectForEach: (style: Record<string, string | number>, fn: (key: string, value: string | null) => void) => void;