hono 4.2.8 → 4.3.0

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

@@ -1,20 +1,26 @@
-import type { UpgradedWebSocketResponseInputJSONType } from '../helper/websocket';
 import type { Hono } from '../hono';
-import type { Schema } from '../types';
+import type { Endpoint, ResponseFormat, Schema } from '../types';
+import type { StatusCode, SuccessStatusCode } from '../utils/http-status';
 import type { HasRequiredKeys } from '../utils/types';
 type HonoRequest = (typeof Hono.prototype)['request'];
-export type ClientRequestOptions<T = unknown> = keyof T extends never ? {
-    headers?: Record<string, string> | (() => Record<string, string> | Promise<Record<string, string>>);
+export type ClientRequestOptions<T = unknown> = {
     fetch?: typeof fetch | HonoRequest;
+    /**
+     * Standard `RequestInit`, caution that this take highest priority
+     * and could be used to overwrite things that Hono sets for you, like `body | method | headers`.
+     *
+     * If you want to add some headers, use in `headers` instead of `init`
+     */
+    init?: RequestInit;
+} & (keyof T extends never ? {
+    headers?: Record<string, string> | (() => Record<string, string> | Promise<Record<string, string>>);
 } : {
     headers: T | (() => T | Promise<T>);
-    fetch?: typeof fetch | HonoRequest;
-};
+});
 export type ClientRequest<S extends Schema> = {
-    [M in keyof S]: S[M] extends {
+    [M in keyof S]: S[M] extends Endpoint & {
         input: infer R;
-        output: infer O;
-    } ? R extends object ? HasRequiredKeys<R> extends true ? (args: R, options?: ClientRequestOptions) => Promise<ClientResponse<O>> : (args?: R, options?: ClientRequestOptions) => Promise<ClientResponse<O>> : never : never;
+    } ? R extends object ? HasRequiredKeys<R> extends true ? (args: R, options?: ClientRequestOptions) => Promise<ClientResponseOfEndpoint<S[M]>> : (args?: R, options?: ClientRequestOptions) => Promise<ClientResponseOfEndpoint<S[M]>> : never : never;
 } & {
     $url: (arg?: S[keyof S] extends {
         input: infer R;
@@ -24,35 +30,53 @@ export type ClientRequest<S extends Schema> = {
         param: P;
     } : {} : {}) => URL;
 } & (S['$get'] extends {
-    input: {
-        json: UpgradedWebSocketResponseInputJSONType;
-    };
+    outputFormat: 'ws';
 } ? S['$get'] extends {
     input: infer I;
 } ? {
-    $ws: (args?: Omit<I, 'json'>) => WebSocket;
+    $ws: (args?: I) => WebSocket;
 } : {} : {});
 type BlankRecordToNever<T> = T extends any ? T extends null ? null : keyof T extends never ? never : T : never;
-export interface ClientResponse<T> {
+type ClientResponseOfEndpoint<T extends Endpoint = Endpoint> = T extends {
+    output: infer O;
+    outputFormat: infer F;
+    status: infer S;
+} ? ClientResponse<O, S extends number ? S : never, F extends ResponseFormat ? F : never> : never;
+export interface ClientResponse<T, U extends number = StatusCode, F extends ResponseFormat = ResponseFormat> extends globalThis.Response {
     readonly body: ReadableStream | null;
     readonly bodyUsed: boolean;
-    ok: boolean;
-    status: number;
+    ok: U extends SuccessStatusCode ? true : U extends Exclude<StatusCode, SuccessStatusCode> ? false : boolean;
+    status: U;
     statusText: string;
     headers: Headers;
     url: string;
     redirect(url: string, status: number): Response;
     clone(): Response;
-    json(): Promise<BlankRecordToNever<T>>;
-    text(): Promise<string>;
+    json(): F extends 'text' ? Promise<never> : F extends 'json' ? Promise<BlankRecordToNever<T>> : Promise<unknown>;
+    text(): F extends 'text' ? (T extends string ? Promise<T> : Promise<never>) : Promise<string>;
     blob(): Promise<Blob>;
     formData(): Promise<FormData>;
     arrayBuffer(): Promise<ArrayBuffer>;
 }
 export interface Response extends ClientResponse<unknown> {
 }
-export type Fetch<T> = (args?: InferRequestType<T>, opt?: ClientRequestOptions) => Promise<ClientResponse<InferResponseType<T>>>;
-export type InferResponseType<T> = T extends (args: any | undefined, options: any | undefined) => Promise<ClientResponse<infer O>> ? O : never;
+export type Fetch<T> = (args?: InferRequestType<T>, opt?: ClientRequestOptions) => Promise<ClientResponseOfEndpoint<InferEndpointType<T>>>;
+type InferEndpointType<T> = T extends (args: infer R, options: any | undefined) => Promise<infer U> ? U extends ClientResponse<infer O, infer S, infer F> ? {
+    input: NonNullable<R>;
+    output: O;
+    outputFormat: F;
+    status: S;
+} extends Endpoint ? {
+    input: NonNullable<R>;
+    output: O;
+    outputFormat: F;
+    status: S;
+} : never : never : never;
+export type InferResponseType<T, U extends StatusCode = StatusCode> = InferResponseTypeFromEndpoint<InferEndpointType<T>, U>;
+type InferResponseTypeFromEndpoint<T extends Endpoint, U extends StatusCode> = T extends {
+    output: infer O;
+    status: infer S;
+} ? S extends U ? O : never : never;
 export type InferRequestType<T> = T extends (args: infer R, options: any | undefined) => Promise<ClientResponse<unknown>> ? NonNullable<R> : never;
 export type InferRequestOptionsType<T> = T extends (args: any, options: infer R) => Promise<ClientResponse<unknown>> ? NonNullable<R> : never;
 type PathToChain<Path extends string, E extends Schema, Original extends string = ''> = Path extends `/${infer P}` ? PathToChain<P, E, Path> : Path extends `${infer P}/${infer R}` ? {

package/dist/types/context.d.ts

@@ -1,9 +1,9 @@
 import type { HonoRequest } from './request';
 import type { Env, FetchEventLike, NotFoundHandler, Input, TypedResponse } from './types';
 import type { RedirectStatusCode, StatusCode } from './utils/http-status';
-import type { JSONValue, InterfaceToType, JSONParsed, IsAny } from './utils/types';
+import type { JSONValue, JSONParsed, IsAny, Simplify } from './utils/types';
 type HeaderRecord = Record<string, string | string[]>;
-type Data = string | ArrayBuffer | ReadableStream;
+export type Data = string | ArrayBuffer | ReadableStream;
 export interface ExecutionContext {
     waitUntil(promise: Promise<unknown>): void;
     passThroughOnException(): void;
@@ -33,12 +33,12 @@ interface NewResponse {
 interface BodyRespond extends NewResponse {
 }
 interface TextRespond {
-    (text: string, status?: StatusCode, headers?: HeaderRecord): Response;
-    (text: string, init?: ResponseInit): Response;
+    <T extends string, U extends StatusCode>(text: T, status?: U, headers?: HeaderRecord): Response & TypedResponse<T, U, 'text'>;
+    <T extends string, U extends StatusCode>(text: T, init?: ResponseInit): Response & TypedResponse<T, U, 'text'>;
 }
 interface JSONRespond {
-    <T>(object: InterfaceToType<T> extends JSONValue ? T : JSONValue, status?: StatusCode, headers?: HeaderRecord): Response & TypedResponse<InterfaceToType<T> extends JSONValue ? JSONValue extends InterfaceToType<T> ? never : JSONParsed<T> : never>;
-    <T>(object: InterfaceToType<T> extends JSONValue ? T : JSONValue, init?: ResponseInit): Response & TypedResponse<InterfaceToType<T> extends JSONValue ? JSONValue extends InterfaceToType<T> ? never : JSONParsed<T> : never>;
+    <T extends JSONValue | Simplify<any>, 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<any>, 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'>;
 }
 interface HTMLRespond {
     (html: string | Promise<string>, status?: StatusCode, headers?: HeaderRecord): Response | Promise<Response>;

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

@@ -14,5 +14,5 @@ export declare const getCookie: GetCookie;
 export declare const getSignedCookie: GetSignedCookie;
 export declare const setCookie: (c: Context, name: string, value: string, opt?: CookieOptions) => void;
 export declare const setSignedCookie: (c: Context, name: string, value: string, secret: string | BufferSource, opt?: CookieOptions) => Promise<void>;
-export declare const deleteCookie: (c: Context, name: string, opt?: CookieOptions) => void;
+export declare const deleteCookie: (c: Context, name: string, opt?: CookieOptions) => string | undefined;
 export {};

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

@@ -1,5 +1,16 @@
+import { Hono } from '../../hono';
 import type { Env, H, HandlerResponse, Input, MiddlewareHandler } from '../../types';
+type InitApp<E extends Env = Env> = (app: Hono<E>) => void;
 export declare class Factory<E extends Env = any, P extends string = any> {
+    private initApp?;
+    constructor(init?: {
+        initApp?: InitApp<E>;
+    });
+    /**
+     * @experimental
+     * `createApp` is an experimental feature.
+     */
+    createApp: () => Hono<E, import("../../types").BlankSchema, "/">;
     createMiddleware: <I extends Input = {}>(middleware: MiddlewareHandler<E, P, I>) => MiddlewareHandler<E, P, I>;
     createHandlers<I extends Input = {}, R extends HandlerResponse<any> = any>(handler1: H<E, P, I, R>): [H<E, P, I, R>];
     createHandlers<I extends Input = {}, I2 extends Input = I, R extends HandlerResponse<any> = any>(handler1: H<E, P, I, R>, handler2: H<E, P, I2, R>): [H<E, P, I, R>, H<E, P, I2, R>];
@@ -50,5 +61,8 @@ export declare class Factory<E extends Env = any, P extends string = any> {
         H<E, P, I10, R>
     ];
 }
-export declare const createFactory: <E extends Env = any, P extends string = any>() => Factory<E, P>;
+export declare const createFactory: <E extends Env = any, P extends string = any>(init?: {
+    initApp?: InitApp<E> | undefined;
+} | undefined) => Factory<E, P>;
 export declare const createMiddleware: <E extends Env = any, P extends string = any, I extends Input = {}>(middleware: MiddlewareHandler<E, P, I>) => MiddlewareHandler<E, P, I>;
+export {};

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

@@ -9,14 +9,11 @@ export interface WSEvents {
     onClose?: (evt: CloseEvent, ws: WSContext) => void;
     onError?: (evt: Event, ws: WSContext) => void;
 }
-export type UpgradedWebSocketResponseInputJSONType = '__websocket';
 /**
  * Upgrade WebSocket Type
  */
 export type UpgradeWebSocket = (createEvents: (c: Context) => WSEvents | Promise<WSEvents>) => MiddlewareHandler<any, string, {
-    in: {
-        json: UpgradedWebSocketResponseInputJSONType;
-    };
+    outputFormat: 'ws';
 }>;
 export type WSReadyState = 0 | 1 | 2 | 3;
 export type WSContext = {

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

@@ -2,7 +2,12 @@ import type { StringBuffer, HtmlEscaped, HtmlEscapedString } from '../utils/html
 import type { Context } from './context';
 import type { IntrinsicElements as IntrinsicElementsDefined } from './intrinsic-elements';
 export type Props = Record<string, any>;
-export type FC<T = Props> = (props: T) => HtmlEscapedString | Promise<HtmlEscapedString>;
+export type FC<P = Props> = {
+    (props: P): HtmlEscapedString | Promise<HtmlEscapedString>;
+    defaultProps?: Partial<P> | undefined;
+    displayName?: string | undefined;
+};
+export type DOMAttributes = Hono.HTMLAttributes;
 declare global {
     namespace JSX {
         type Element = HtmlEscapedString | Promise<HtmlEscapedString>;
@@ -24,14 +29,16 @@ export declare class JSXNode implements HtmlEscaped {
     isEscaped: true;
     localContexts?: LocalContexts;
     constructor(tag: string | Function, props: Props, children: Child[]);
+    get type(): string | Function;
+    get ref(): any;
     toString(): string | Promise<string>;
     toStringToBuffer(buffer: StringBuffer): void;
 }
 export declare class JSXFragmentNode extends JSXNode {
     toStringToBuffer(buffer: StringBuffer): void;
 }
-export declare const jsx: (tag: string | Function, props: Props, ...children: (string | HtmlEscapedString)[]) => JSXNode;
-export declare const jsxFn: (tag: string | Function, props: Props, children: (string | HtmlEscapedString)[]) => JSXNode;
+export declare const jsx: (tag: string | Function, props: Props | null, ...children: (string | number | HtmlEscapedString)[]) => JSXNode;
+export declare const jsxFn: (tag: string | Function, props: Props, children: (string | number | HtmlEscapedString)[]) => JSXNode;
 export declare const memo: <T>(component: FC<T>, propsAreEqual?: (prevProps: Readonly<T>, nextProps: Readonly<T>) => boolean) => FC<T>;
 export declare const Fragment: ({ children, }: {
     key?: string | undefined;

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

@@ -0,0 +1,9 @@
+import type { Child } from './base';
+export declare const toArray: (children: Child) => Child[];
+export declare const Children: {
+    map: (children: Child[], fn: (child: Child, index: number) => Child) => Child[];
+    forEach: (children: Child[], fn: (child: Child, index: number) => void) => void;
+    count: (children: Child[]) => number;
+    only: (_children: Child[]) => Child;
+    toArray: (children: Child) => Child[];
+};

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

@@ -1,3 +1,4 @@
 export declare const DOM_RENDERER: unique symbol;
 export declare const DOM_ERROR_HANDLER: unique symbol;
 export declare const DOM_STASH: unique symbol;
+export declare const DOM_INTERNAL_TAG: unique symbol;

package/dist/types/jsx/dom/context.d.ts

@@ -1,12 +1,3 @@
-import type { Child } from '../base';
 import type { Context } from '../context';
-export declare const createContextProviderFunction: <T>(values: T[]) => ({ value, children }: {
-    value: T;
-    children: Child[];
-}) => {
-    tag: string | Function;
-    props: import("../base").Props;
-    key: string | undefined;
-    children: any[];
-};
+export declare const createContextProviderFunction: <T>(values: T[]) => Function;
 export declare const createContext: <T>(defaultValue: T) => Context<T>;

package/dist/types/jsx/dom/index.d.ts

@@ -1,13 +1,16 @@
-import type { Props, Child, JSXNode } from '../base';
+import type { Props, Child, DOMAttributes, JSXNode } from '../base';
 import { memo, isValidElement } from '../base';
+import { Children } from '../children';
 import { useContext } from '../context';
-import { useState, useEffect, useRef, useCallback, use, startTransition, useTransition, useDeferredValue, startViewTransition, useViewTransition, useMemo, useLayoutEffect, useReducer, useId, useDebugValue } from '../hooks';
+import { useState, useEffect, useRef, useCallback, use, startTransition, useTransition, useDeferredValue, startViewTransition, useViewTransition, useMemo, useLayoutEffect, useReducer, useId, useDebugValue, createRef, forwardRef, useImperativeHandle, useSyncExternalStore } from '../hooks';
 import { Suspense, ErrorBoundary } from './components';
 import { createContext } from './context';
+import { Fragment } from './jsx-runtime';
+import { flushSync, createPortal } from './render';
 export { render } from './render';
-declare const createElement: (tag: string | ((props: Props) => JSXNode), props: Props, ...children: Child[]) => JSXNode;
+declare const createElement: (tag: string | ((props: Props) => JSXNode), props: Props | null, ...children: Child[]) => JSXNode;
 declare const cloneElement: <T extends JSXNode | JSX.Element>(element: T, props: Props, ...children: Child[]) => T;
-export { createElement as jsx, useState, useEffect, useRef, useCallback, use, startTransition, useTransition, useDeferredValue, startViewTransition, useViewTransition, useMemo, useLayoutEffect, useReducer, useId, useDebugValue, Suspense, ErrorBoundary, createContext, useContext, memo, isValidElement, createElement, cloneElement, };
+export { createElement as jsx, useState, useEffect, useRef, useCallback, use, startTransition, useTransition, useDeferredValue, startViewTransition, useViewTransition, useMemo, useLayoutEffect, useReducer, useId, useDebugValue, createRef, forwardRef, useImperativeHandle, useSyncExternalStore, Suspense, ErrorBoundary, createContext, useContext, memo, isValidElement, createElement, cloneElement, Children, Fragment, DOMAttributes, flushSync, createPortal, };
 declare const _default: {
     useState: {
         <T>(initialState: T | (() => T)): [T, (newState: T | ((currentState: T) => T)) => void];
@@ -27,20 +30,37 @@ declare const _default: {
     useReducer: <T_7, A>(reducer: (state: T_7, action: A) => T_7, initialArg: T_7, init?: ((initialState: T_7) => T_7) | undefined) => [T_7, (action: A) => void];
     useId: () => string;
     useDebugValue: (_value: unknown, _formatter?: ((value: unknown) => string) | undefined) => void;
-    Suspense: import("../base").FC<import("..").PropsWithChildren<{
+    createRef: <T_8>() => import("../hooks").RefObject<T_8>;
+    forwardRef: <T_9, P = {}>(Component: (props: P, ref: import("../hooks").RefObject<T_9>) => JSX.Element) => (props: P & {
+        ref: import("../hooks").RefObject<T_9>;
+    }) => JSX.Element;
+    useImperativeHandle: <T_10>(ref: import("../hooks").RefObject<T_10>, createHandle: () => T_10, deps: readonly unknown[]) => void;
+    useSyncExternalStore: <T_11>(subscribe: (callback: (value: T_11) => void) => () => void, getSnapshot: () => T_11, getServerSnapshot?: (() => T_11) | undefined) => T_11;
+    Suspense: import("../base").FC<import("../types").PropsWithChildren<{
         fallback: any;
     }>>;
-    ErrorBoundary: import("../base").FC<import("..").PropsWithChildren<{
+    ErrorBoundary: import("../base").FC<import("../types").PropsWithChildren<{
         fallback?: Child;
         fallbackRender?: import("../components").FallbackRender | undefined;
         onError?: import("../components").ErrorHandler | undefined;
     }>>;
-    createContext: <T_8>(defaultValue: T_8) => import("../context").Context<T_8>;
-    useContext: <T_9>(context: import("../context").Context<T_9>) => T_9;
-    memo: <T_10>(component: import("../base").FC<T_10>, propsAreEqual?: (prevProps: Readonly<T_10>, nextProps: Readonly<T_10>) => boolean) => import("../base").FC<T_10>;
+    createContext: <T_12>(defaultValue: T_12) => import("../context").Context<T_12>;
+    useContext: <T_13>(context: import("../context").Context<T_13>) => T_13;
+    memo: <T_14>(component: import("../base").FC<T_14>, propsAreEqual?: (prevProps: Readonly<T_14>, nextProps: Readonly<T_14>) => boolean) => import("../base").FC<T_14>;
     isValidElement: (element: unknown) => element is JSXNode;
-    createElement: (tag: string | ((props: Props) => JSXNode), props: Props, ...children: Child[]) => JSXNode;
-    cloneElement: <T_11 extends JSXNode | JSX.Element>(element: T_11, props: Props, ...children: Child[]) => T_11;
+    createElement: (tag: string | ((props: Props) => JSXNode), props: Props | null, ...children: Child[]) => JSXNode;
+    cloneElement: <T_15 extends JSXNode | JSX.Element>(element: T_15, props: Props, ...children: Child[]) => T_15;
+    Children: {
+        map: (children: Child[], fn: (child: Child, index: number) => Child) => Child[];
+        forEach: (children: Child[], fn: (child: Child, index: number) => void) => void;
+        count: (children: Child[]) => number;
+        only: (_children: Child[]) => Child;
+        toArray: (children: Child) => Child[];
+    };
+    Fragment: (props: Record<string, unknown>) => JSXNode;
+    flushSync: (callback: () => void) => void;
+    createPortal: (children: Child, container: HTMLElement, key?: string | undefined) => Child;
 };
 export default _default;
 export type { Context } from '../context';
+export * from '../types';

package/dist/types/jsx/dom/jsx-dev-runtime.d.ts

@@ -1,13 +1,3 @@
-import type { Props } from '../base';
-export declare const jsxDEV: (tag: string | Function, props: Props, key?: string) => {
-    tag: string | Function;
-    props: Props;
-    key: string | undefined;
-    children: any[];
-};
-export declare const Fragment: (props: Record<string, unknown>) => {
-    tag: string | Function;
-    props: Props;
-    key: string | undefined;
-    children: any[];
-};
+import type { Props, JSXNode } from '../base';
+export declare const jsxDEV: (tag: string | Function, props: Props, key?: string) => JSXNode;
+export declare const Fragment: (props: Record<string, unknown>) => JSXNode;

package/dist/types/jsx/dom/render.d.ts

@@ -27,10 +27,10 @@ export type NodeObject = {
         any[][]
     ];
 } & JSXNode;
-type NodeString = [
-    string,
-    boolean
-] & {
+type NodeString = {
+    t: string;
+    d: boolean;
+} & {
     e?: Text;
     vC: undefined;
     nN: undefined;
@@ -50,4 +50,6 @@ export declare const buildDataStack: [Context, Node][];
 export declare const build: (context: Context, node: NodeObject, topLevelErrorHandlerNode: NodeObject | undefined, children?: Child[]) => void;
 export declare const update: (context: Context, node: NodeObject) => Promise<NodeObject | undefined>;
 export declare const render: (jsxNode: unknown, container: Container) => void;
+export declare const flushSync: (callback: () => void) => void;
+export declare const createPortal: (children: Child, container: HTMLElement, key?: string) => Child;
 export {};

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

@@ -0,0 +1 @@
+export declare const setInternalTagFlag: (fn: Function) => Function;

package/dist/types/jsx/hooks/index.d.ts

@@ -31,4 +31,10 @@ export declare const use: <T>(promise: Promise<T>) => T;
 export declare const useMemo: <T>(factory: () => T, deps: readonly unknown[]) => T;
 export declare const useId: () => string;
 export declare const useDebugValue: (_value: unknown, _formatter?: ((value: unknown) => string) | undefined) => void;
+export declare const createRef: <T>() => RefObject<T>;
+export declare const forwardRef: <T, P = {}>(Component: (props: P, ref: RefObject<T>) => JSX.Element) => (props: P & {
+    ref: RefObject<T>;
+}) => JSX.Element;
+export declare const useImperativeHandle: <T>(ref: RefObject<T>, createHandle: () => T, deps: readonly unknown[]) => void;
+export declare const useSyncExternalStore: <T>(subscribe: (callback: (value: T) => void) => () => void, getSnapshot: () => T, getServerSnapshot?: (() => T) | undefined) => T;
 export {};

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

@@ -1,9 +1,11 @@
 import { jsx, memo, Fragment, isValidElement, cloneElement } from './base';
+import type { DOMAttributes } from './base';
+import { Children } from './children';
 import { ErrorBoundary } from './components';
 import { createContext, useContext } from './context';
-import { useState, useEffect, useRef, useCallback, use, startTransition, useTransition, useDeferredValue, startViewTransition, useViewTransition, useMemo, useLayoutEffect, useReducer, useId, useDebugValue } from './hooks';
+import { useState, useEffect, useRef, useCallback, use, startTransition, useTransition, useDeferredValue, startViewTransition, useViewTransition, useMemo, useLayoutEffect, useReducer, useId, useDebugValue, createRef, forwardRef, useImperativeHandle, useSyncExternalStore } from './hooks';
 import { Suspense } from './streaming';
-export { jsx, memo, Fragment, isValidElement, jsx as createElement, cloneElement, ErrorBoundary, createContext, useContext, useState, useEffect, useRef, useCallback, useReducer, useId, useDebugValue, use, startTransition, useTransition, useDeferredValue, startViewTransition, useViewTransition, useMemo, useLayoutEffect, Suspense, };
+export { jsx, memo, Fragment, isValidElement, jsx as createElement, cloneElement, ErrorBoundary, createContext, useContext, useState, useEffect, useRef, useCallback, useReducer, useId, useDebugValue, use, startTransition, useTransition, useDeferredValue, startViewTransition, useViewTransition, useMemo, useLayoutEffect, createRef, forwardRef, useImperativeHandle, useSyncExternalStore, Suspense, Children, DOMAttributes, };
 declare const _default: {
     memo: <T>(component: import("./base").FC<T>, propsAreEqual?: (prevProps: Readonly<T>, nextProps: Readonly<T>) => boolean) => import("./base").FC<T>;
     Fragment: ({ children, }: {
@@ -11,7 +13,7 @@ declare const _default: {
         children?: import("../utils/html").HtmlEscapedString | import("./base").Child;
     }) => import("../utils/html").HtmlEscapedString;
     isValidElement: (element: unknown) => element is import("./base").JSXNode;
-    createElement: (tag: string | Function, props: import("./base").Props, ...children: (string | import("../utils/html").HtmlEscapedString)[]) => import("./base").JSXNode;
+    createElement: (tag: string | Function, props: import("./base").Props | null, ...children: (string | number | import("../utils/html").HtmlEscapedString)[]) => import("./base").JSXNode;
     cloneElement: <T_1 extends import("./base").JSXNode | JSX.Element>(element: T_1, props: Partial<import("./base").Props>, ...children: import("./base").Child[]) => T_1;
     ErrorBoundary: import("./base").FC<import("./types").PropsWithChildren<{
         fallback?: import("./base").Child;
@@ -38,9 +40,22 @@ declare const _default: {
     useViewTransition: () => [boolean, (callback: () => void) => void];
     useMemo: <T_11>(factory: () => T_11, deps: readonly unknown[]) => T_11;
     useLayoutEffect: (effect: () => void | (() => void), deps?: readonly unknown[] | undefined) => void;
+    createRef: <T_12>() => import("./hooks").RefObject<T_12>;
+    forwardRef: <T_13, P = {}>(Component: (props: P, ref: import("./hooks").RefObject<T_13>) => JSX.Element) => (props: P & {
+        ref: import("./hooks").RefObject<T_13>;
+    }) => JSX.Element;
+    useImperativeHandle: <T_14>(ref: import("./hooks").RefObject<T_14>, createHandle: () => T_14, deps: readonly unknown[]) => void;
+    useSyncExternalStore: <T_15>(subscribe: (callback: (value: T_15) => void) => () => void, getSnapshot: () => T_15, getServerSnapshot?: (() => T_15) | undefined) => T_15;
     Suspense: import("./base").FC<import("./types").PropsWithChildren<{
         fallback: any;
     }>>;
+    Children: {
+        map: (children: import("./base").Child[], fn: (child: import("./base").Child, index: number) => import("./base").Child) => import("./base").Child[];
+        forEach: (children: import("./base").Child[], fn: (child: import("./base").Child, index: number) => void) => void;
+        count: (children: import("./base").Child[]) => number;
+        only: (_children: import("./base").Child[]) => import("./base").Child;
+        toArray: (children: import("./base").Child) => import("./base").Child[];
+    };
 };
 export default _default;
 export * from './types';

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

@@ -1,7 +1,7 @@
 /**
  * All types exported from "hono/jsx" are in this file.
  */
-import type { Child } from './base';
+import type { Child, JSXNode } from './base';
 export type { Child, JSXNode, FC } from './base';
 export type { RefObject } from './hooks';
 export type { Context } from './context';
@@ -9,3 +9,26 @@ export type PropsWithChildren<P = unknown> = P & {
     children?: Child | undefined;
 };
 export type CSSProperties = Hono.CSSProperties;
+/**
+ * React types
+ */
+type ReactElement<P = any, T = string | Function> = JSXNode & {
+    type: T;
+    props: P;
+    key: string | null;
+};
+type ReactNode = ReactElement | string | number | boolean | null | undefined;
+type ComponentClass<P = {}, S = {}> = unknown;
+export type { ReactElement, ReactNode, ComponentClass };
+export type Event = globalThis.Event;
+export type MouseEvent = globalThis.MouseEvent;
+export type KeyboardEvent = globalThis.KeyboardEvent;
+export type FocusEvent = globalThis.FocusEvent;
+export type ClipboardEvent = globalThis.ClipboardEvent;
+export type InputEvent = globalThis.InputEvent;
+export type PointerEvent = globalThis.PointerEvent;
+export type TouchEvent = globalThis.TouchEvent;
+export type WheelEvent = globalThis.WheelEvent;
+export type AnimationEvent = globalThis.AnimationEvent;
+export type TransitionEvent = globalThis.TransitionEvent;
+export type DragEvent = globalThis.DragEvent;

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

@@ -1 +1,2 @@
 export declare const normalizeIntrinsicElementProps: (props: Record<string, unknown>) => void;
+export declare const styleObjectForEach: (style: Record<string, string>, fn: (key: string, value: string | null) => void) => void;

package/dist/types/middleware/bearer-auth/index.d.ts

@@ -4,10 +4,12 @@ type BearerAuthOptions = {
     token: string | string[];
     realm?: string;
     prefix?: string;
+    headerName?: string;
     hashFunction?: Function;
 } | {
     realm?: string;
     prefix?: string;
+    headerName?: string;
     verifyToken: (token: string, c: Context) => boolean | Promise<boolean>;
     hashFunction?: Function;
 };

package/dist/types/middleware/secure-headers/index.d.ts

@@ -1,27 +1,35 @@
+import type { Context } from '../../context';
 import type { MiddlewareHandler } from '../../types';
+declare module '../../context' {
+    interface ContextVariableMap {
+        secureHeadersNonce?: string;
+    }
+}
+export type ContentSecurityPolicyOptionHandler = (ctx: Context, directive: string) => string;
+type ContentSecurityPolicyOptionValue = (string | ContentSecurityPolicyOptionHandler)[];
 interface ContentSecurityPolicyOptions {
-    defaultSrc?: string[];
-    baseUri?: string[];
-    childSrc?: string[];
-    connectSrc?: string[];
-    fontSrc?: string[];
-    formAction?: string[];
-    frameAncestors?: string[];
-    frameSrc?: string[];
-    imgSrc?: string[];
-    manifestSrc?: string[];
-    mediaSrc?: string[];
-    objectSrc?: string[];
+    defaultSrc?: ContentSecurityPolicyOptionValue;
+    baseUri?: ContentSecurityPolicyOptionValue;
+    childSrc?: ContentSecurityPolicyOptionValue;
+    connectSrc?: ContentSecurityPolicyOptionValue;
+    fontSrc?: ContentSecurityPolicyOptionValue;
+    formAction?: ContentSecurityPolicyOptionValue;
+    frameAncestors?: ContentSecurityPolicyOptionValue;
+    frameSrc?: ContentSecurityPolicyOptionValue;
+    imgSrc?: ContentSecurityPolicyOptionValue;
+    manifestSrc?: ContentSecurityPolicyOptionValue;
+    mediaSrc?: ContentSecurityPolicyOptionValue;
+    objectSrc?: ContentSecurityPolicyOptionValue;
     reportTo?: string;
-    sandbox?: string[];
-    scriptSrc?: string[];
-    scriptSrcAttr?: string[];
-    scriptSrcElem?: string[];
-    styleSrc?: string[];
-    styleSrcAttr?: string[];
-    styleSrcElem?: string[];
-    upgradeInsecureRequests?: string[];
-    workerSrc?: string[];
+    sandbox?: ContentSecurityPolicyOptionValue;
+    scriptSrc?: ContentSecurityPolicyOptionValue;
+    scriptSrcAttr?: ContentSecurityPolicyOptionValue;
+    scriptSrcElem?: ContentSecurityPolicyOptionValue;
+    styleSrc?: ContentSecurityPolicyOptionValue;
+    styleSrcAttr?: ContentSecurityPolicyOptionValue;
+    styleSrcElem?: ContentSecurityPolicyOptionValue;
+    upgradeInsecureRequests?: ContentSecurityPolicyOptionValue;
+    workerSrc?: ContentSecurityPolicyOptionValue;
 }
 interface ReportToOptions {
     group: string;
@@ -53,5 +61,6 @@ interface SecureHeadersOptions {
     xPermittedCrossDomainPolicies?: overridableHeader;
     xXssProtection?: overridableHeader;
 }
+export declare const NONCE: ContentSecurityPolicyOptionHandler;
 export declare const secureHeaders: (customOptions?: Partial<SecureHeadersOptions>) => MiddlewareHandler;
 export {};

package/dist/types/middleware/serve-static/index.d.ts

@@ -1,4 +1,4 @@
-import type { Context } from '../../context';
+import type { Context, Data } from '../../context';
 import type { Env, MiddlewareHandler } from '../../types';
 export type ServeStaticOptions<E extends Env = Env> = {
     root?: string;
@@ -11,6 +11,6 @@ export type ServeStaticOptions<E extends Env = Env> = {
  * This middleware is not directly used by the user. Create a wrapper specifying `getContent()` by the environment such as Deno or Bun.
  */
 export declare const serveStatic: <E extends Env = Env>(options: ServeStaticOptions<E> & {
-    getContent: (path: string) => any;
+    getContent: (path: string, c: Context<E, any, {}>) => Promise<Data | Response | null>;
     pathResolve?: ((path: string) => string) | undefined;
 }) => MiddlewareHandler;

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

@@ -18,7 +18,7 @@ interface TimingOptions {
     enabled: boolean | ((c: Context) => boolean);
     totalDescription: string;
     autoEnd: boolean;
-    crossOrigin: boolean | string;
+    crossOrigin: boolean | string | ((c: Context) => boolean | string);
 }
 export declare const timing: (config?: Partial<TimingOptions>) => MiddlewareHandler;
 interface SetMetric {

package/dist/types/request.d.ts

@@ -1,5 +1,5 @@
 import type { Result } from './router';
-import type { Input, InputToDataByTarget, ParamKeys, ParamKeyToRecord, RemoveQuestion, UndefinedIfHavingQuestion, ValidationTargets, RouterRoute } from './types';
+import type { Input, InputToDataByTarget, ParamKeys, ParamKeyToRecord, RemoveQuestion, ValidationTargets, RouterRoute } from './types';
 import type { BodyData, ParseBodyOptions } from './utils/body';
 import type { UnionToIntersection } from './utils/types';
 type Body = {
@@ -51,7 +51,8 @@ export declare class HonoRequest<P extends string = '/', I extends Input['out']
      * ```
      * @see https://hono.dev/api/routing#path-parameter
      */
-    param<P2 extends string = P>(key: RemoveQuestion<ParamKeys<P2>>): UndefinedIfHavingQuestion<ParamKeys<P2>>;
+    param<P2 extends ParamKeys<P> = ParamKeys<P>>(key: P2 extends `${infer _}?` ? never : P2): string;
+    param<P2 extends RemoveQuestion<ParamKeys<P>> = RemoveQuestion<ParamKeys<P>>>(key: P2): string | undefined;
     param<P2 extends string = P>(): UnionToIntersection<ParamKeyToRecord<ParamKeys<P2>>>;
     private getDecodedParam;
     private getAllDecodedParams;