hono 2.7.0 → 3.0.0-0

package/dist/request.js

@@ -2,11 +2,13 @@
 import { parseBody } from "./utils/body.js";
 import { parse } from "./utils/cookie.js";
 import { getQueryStringFromURL } from "./utils/url.js";
-function extendRequestPrototype() {
-  if (!!Request.prototype.param) {
-    return;
+var HonoRequest = class {
+  constructor(request, paramData) {
+    this.raw = request;
+    this.paramData = paramData;
+    this.data = {};
   }
-  Request.prototype.param = function(key) {
+  param(key) {
     if (this.paramData) {
       if (key) {
         const param = this.paramData[key];
@@ -14,7 +16,7 @@ function extendRequestPrototype() {
       } else {
         const decoded = {};
         for (const [key2, value] of Object.entries(this.paramData)) {
-          if (value) {
+          if (value && typeof value === "string") {
             decoded[key2] = decodeURIComponent(value);
           }
         }
@@ -22,21 +24,8 @@ function extendRequestPrototype() {
       }
     }
     return null;
-  };
-  Request.prototype.header = function(name) {
-    if (!this.headerData) {
-      this.headerData = {};
-      this.headers.forEach((value, key) => {
-        this.headerData[key] = value;
-      });
-    }
-    if (name) {
-      return this.headerData[name.toLowerCase()];
-    } else {
-      return this.headerData;
-    }
-  };
-  Request.prototype.query = function(key) {
+  }
+  query(key) {
     const queryString = getQueryStringFromURL(this.url);
     const searchParams = new URLSearchParams(queryString);
     if (!this.queryData) {
@@ -50,8 +39,8 @@ function extendRequestPrototype() {
     } else {
       return this.queryData;
     }
-  };
-  Request.prototype.queries = function(key) {
+  }
+  queries(key) {
     const queryString = getQueryStringFromURL(this.url);
     const searchParams = new URLSearchParams(queryString);
     if (key) {
@@ -63,9 +52,24 @@ function extendRequestPrototype() {
       }
       return result;
     }
-  };
-  Request.prototype.cookie = function(key) {
-    const cookie = this.headers.get("Cookie") || "";
+  }
+  header(name) {
+    if (!this.headerData) {
+      this.headerData = {};
+      this.raw.headers.forEach((value, key) => {
+        this.headerData[key] = value;
+      });
+    }
+    if (name) {
+      return this.headerData[name.toLowerCase()];
+    } else {
+      return this.headerData;
+    }
+  }
+  cookie(key) {
+    const cookie = this.raw.headers.get("Cookie");
+    if (!cookie)
+      return;
     const obj = parse(cookie);
     if (key) {
       const value = obj[key];
@@ -73,28 +77,40 @@ function extendRequestPrototype() {
     } else {
       return obj;
     }
-  };
-  Request.prototype.parseBody = async function() {
+  }
+  async parseBody() {
     let body;
     if (!this.bodyData) {
-      body = await parseBody(this);
+      body = await parseBody(this.raw);
       this.bodyData = body;
     } else {
       body = this.bodyData;
     }
     return body;
-  };
-  Request.prototype.json = async function() {
+  }
+  async json() {
     let jsonData;
     if (!this.jsonData) {
-      jsonData = JSON.parse(await this.text());
+      jsonData = this.raw.json();
       this.jsonData = jsonData;
     } else {
       jsonData = this.jsonData;
     }
     return jsonData;
-  };
-  Request.prototype.valid = function(data) {
+  }
+  async text() {
+    return this.raw.text();
+  }
+  async arrayBuffer() {
+    return this.raw.arrayBuffer();
+  }
+  async blob() {
+    return this.raw.blob();
+  }
+  async formData() {
+    return this.raw.formData();
+  }
+  valid(data) {
     if (!this.data) {
       this.data = {};
     }
@@ -102,8 +118,50 @@ function extendRequestPrototype() {
       this.data = data;
     }
     return this.data;
-  };
-}
+  }
+  get url() {
+    return this.raw.url;
+  }
+  get method() {
+    return this.raw.method;
+  }
+  get headers() {
+    return this.raw.headers;
+  }
+  get redirect() {
+    return this.raw.redirect;
+  }
+  get body() {
+    return this.raw.body;
+  }
+  get bodyUsed() {
+    return this.raw.bodyUsed;
+  }
+  get cache() {
+    return this.raw.cache;
+  }
+  get credentials() {
+    return this.raw.credentials;
+  }
+  get integrity() {
+    return this.raw.integrity;
+  }
+  get keepalive() {
+    return this.raw.keepalive;
+  }
+  get mode() {
+    return this.raw.mode;
+  }
+  get referrer() {
+    return this.raw.referrer;
+  }
+  get refererPolicy() {
+    return this.raw.referrerPolicy;
+  }
+  get signal() {
+    return this.raw.signal;
+  }
+};
 export {
-  extendRequestPrototype
+  HonoRequest
 };

package/dist/types/compose.d.ts

@@ -3,5 +3,5 @@ interface ComposeContext {
     finalized: boolean;
     res: unknown;
 }
-export declare const compose: <C extends ComposeContext, E extends Partial<Environment> = Environment>(middleware: Function[], onNotFound?: NotFoundHandler<E> | undefined, onError?: ErrorHandler<E> | undefined) => (context: C, next?: Function) => C | Promise<C>;
+export declare const compose: <C extends ComposeContext, E extends Partial<Environment> = Environment>(middleware: Function[], onNotFound?: NotFoundHandler<E, import("./types").Route> | undefined, onError?: ErrorHandler<E> | undefined) => (context: C, next?: Function) => C | Promise<C>;
 export {};

package/dist/types/context.d.ts

@@ -1,16 +1,28 @@
-import type { ExecutionContext } from './types';
-import type { Environment, NotFoundHandler, ContextVariableMap } from './types';
+import { HonoRequest } from './request';
+import type { TypeResponse, Route } from './types';
+import type { Environment, NotFoundHandler } from './types';
 import type { CookieOptions } from './utils/cookie';
 import type { StatusCode } from './utils/http-status';
-import type { Schema, SchemaToProp } from './validator/schema';
-declare type Headers = Record<string, string | string[]>;
 declare type Runtime = 'node' | 'deno' | 'bun' | 'cloudflare' | 'fastly' | 'vercel' | 'lagon' | 'other';
-export declare type Data = string | ArrayBuffer | ReadableStream;
-export declare class Context<P extends string = string, E extends Partial<Environment> = Environment, S = any> {
-    req: Request<unknown, P, S extends Schema ? SchemaToProp<S> : S>;
+declare type Headers = Record<string, string | string[]>;
+declare type Data = string | ArrayBuffer | ReadableStream;
+export interface ExecutionContext {
+    waitUntil(promise: Promise<void>): void;
+    passThroughOnException(): void;
+}
+export interface ContextVariableMap {
+}
+declare type ContextOptions<E extends Partial<Environment>, R extends Route> = {
+    env?: E['Bindings'];
+    executionCtx?: FetchEvent | ExecutionContext | undefined;
+    notFoundHandler?: NotFoundHandler<E, R>;
+    paramData?: Record<string, string>;
+};
+export declare class Context<E extends Partial<Environment> = Environment, R extends Route = Route, I = any> {
     env: E['Bindings'];
     finalized: boolean;
     error: Error | undefined;
+    private _req?;
     private _status;
     private _executionCtx;
     private _pretty;
@@ -18,8 +30,11 @@ export declare class Context<P extends string = string, E extends Partial<Enviro
     private _map;
     private _headers;
     private _res;
+    private _paramData;
+    private rawRequest;
     private notFoundHandler;
-    constructor(req: Request<unknown, P>, env?: E['Bindings'], executionCtx?: FetchEvent | ExecutionContext | undefined, notFoundHandler?: NotFoundHandler<E>);
+    constructor(req: Request, options?: ContextOptions<E, R>);
+    get req(): HonoRequest<R, I>;
     get event(): FetchEvent;
     get executionCtx(): ExecutionContext;
     get res(): Response;
@@ -31,8 +46,8 @@ export declare class Context<P extends string = string, E extends Partial<Enviro
     set<Key extends keyof ContextVariableMap>(key: Key, value: ContextVariableMap[Key]): void;
     set<Key extends keyof E['Variables']>(key: Key, value: E['Variables'][Key]): void;
     set(key: string, value: unknown): void;
-    get<Key extends keyof ContextVariableMap>(key: Key): ContextVariableMap[Key];
     get<Key extends keyof E['Variables']>(key: Key): E['Variables'][Key];
+    get<Key extends keyof ContextVariableMap>(key: Key): ContextVariableMap[Key];
     get<T>(key: string): T;
     pretty(prettyJSON: boolean, space?: number): void;
     newResponse(data: Data | null, status: StatusCode, headers?: Headers): Response;
@@ -40,6 +55,7 @@ export declare class Context<P extends string = string, E extends Partial<Enviro
     body(data: Data | null, status?: StatusCode, headers?: Headers): Response;
     text(text: string, status?: StatusCode, headers?: Headers): Response;
     json<T>(object: T, status?: StatusCode, headers?: Headers): Response;
+    jsonT<T>(object: T, status?: StatusCode, headers?: Headers): TypeResponse<T>;
     html(html: string, status?: StatusCode, headers?: Headers): Response;
     redirect(location: string, status?: StatusCode): Response;
     cookie(name: string, value: string, opt?: CookieOptions): void;

package/dist/types/hono.d.ts

@@ -1,41 +1,48 @@
+import type { ExecutionContext } from './context';
 import type { Router } from './router';
-import type { ExecutionContext } from './types';
-import type { Handler, Environment, ParamKeys, ErrorHandler, NotFoundHandler } from './types';
-interface HandlerInterface<P extends string, E extends Partial<Environment> = Environment, S = unknown, U = Hono<E, P, S>> {
-    <Path extends string, Data = S>(...handlers: Handler<ParamKeys<Path> extends never ? string : ParamKeys<Path>, E, Data>[]): Hono<E, Path, Data & S>;
-    (...handlers: Handler<P, E, S>[]): U;
-    <Path extends string, Data = S>(path: Path, ...handlers: Handler<ParamKeys<Path> extends never ? string : ParamKeys<Path>, E, Data>[]): Hono<E, Path, Data & S>;
-    <Path extends string, Data = S>(path: Path, ...handlers: Handler<string, E, Data>[]): Hono<E, string, Data & S>;
-    (path: string, ...handlers: Handler<P, E, S>[]): U;
-}
-interface Route<P extends string = string, E extends Partial<Environment> = Environment, S = unknown> {
+import type { HandlerInterface, ToAppType, Handler, ErrorHandler, NotFoundHandler, Environment, Route } from './types';
+interface RouterRoute {
     path: string;
     method: string;
-    handler: Handler<P, E, S>;
+    handler: Handler;
 }
-declare const Hono_base: new <E_1 extends Partial<Environment> = Environment, P_1 extends string = string, S_1 = unknown, U = Hono<E_1, P_1, S_1>>() => {
-    all: HandlerInterface<P_1, E_1, S_1, U>;
-    get: HandlerInterface<P_1, E_1, S_1, U>;
-    post: HandlerInterface<P_1, E_1, S_1, U>;
-    put: HandlerInterface<P_1, E_1, S_1, U>;
-    delete: HandlerInterface<P_1, E_1, S_1, U>;
-    head: HandlerInterface<P_1, E_1, S_1, U>;
-    options: HandlerInterface<P_1, E_1, S_1, U>;
-    patch: HandlerInterface<P_1, E_1, S_1, U>;
+declare const Hono_base: new <E_1 extends Partial<Environment> = Partial<Environment>, _M extends string = string, P extends string = string, I_1 = unknown, O_1 = unknown>() => {
+    all: HandlerInterface<E_1, "all", P, I_1, O_1>;
+    get: HandlerInterface<E_1, "get", P, I_1, O_1>;
+    post: HandlerInterface<E_1, "post", P, I_1, O_1>;
+    put: HandlerInterface<E_1, "put", P, I_1, O_1>;
+    delete: HandlerInterface<E_1, "delete", P, I_1, O_1>;
+    head: HandlerInterface<E_1, "head", P, I_1, O_1>;
+    options: HandlerInterface<E_1, "options", P, I_1, O_1>;
+    patch: HandlerInterface<E_1, "patch", P, I_1, O_1>;
 };
-export declare class Hono<E extends Partial<Environment> = Environment, P extends string = string, S = unknown> extends Hono_base<E, P, S, Hono<E, P, S>> {
-    readonly router: Router<Handler<P, E, S>>;
+export declare class Hono<E extends Partial<Environment> = Partial<Environment>, R extends Route = Route, I = any, // should be any
+O = unknown> extends Hono_base<E, R['method'], R['path'], I, O> {
+    readonly router: Router<Handler>;
     readonly strict: boolean;
     private _tempPath;
     private path;
-    routes: Route<P, E, S>[];
+    routes: RouterRoute[];
     constructor(init?: Partial<Pick<Hono, 'router' | 'strict'>>);
     private notFoundHandler;
     private errorHandler;
     route(path: string, app?: Hono<any>): this;
-    use<Path extends string = string, Data = unknown>(...middleware: Handler<Path, E, Data>[]): Hono<E, P, S>;
-    use<Path extends string = string, Data = unknown>(arg1: string, ...middleware: Handler<Path, E, Data>[]): Hono<E, P, S>;
-    on(method: string, path: string, ...handlers: Handler<P, E, S>[]): this;
+    use(...middleware: Handler<E>[]): Hono<E, {
+        method: 'all';
+        path: string;
+    }, I, O>;
+    use<Path extends string, E2 extends Partial<Environment> = E>(arg1: Path, ...middleware: Handler<E2>[]): Hono<E, {
+        method: 'all';
+        path: Path;
+    }, I, O>;
+    on<Method extends string, Path extends string>(method: Method, path: Path, ...handlers: Handler<E, {
+        method: Method;
+        path: Path;
+    }>[]): Hono<E, {
+        method: Method;
+        path: Path;
+    }, I, O>;
+    build: () => ToAppType<typeof this>;
     onError(handler: ErrorHandler<E>): this;
     notFound(handler: NotFoundHandler<E>): this;
     showRoutes(): void;

package/dist/types/index.d.ts

@@ -1,8 +1,6 @@
-/// <reference path="request.d.ts" />
 import { Hono } from './hono';
-export type { Next, ContextVariableMap, MiddlewareHandler, ErrorHandler, NotFoundHandler, } from './types';
-export type { Context } from './context';
-export type { Validator } from './validator/validator';
+export type { Next, MiddlewareHandler, ErrorHandler, NotFoundHandler } from './types';
+export type { Context, ContextVariableMap } from './context';
 import type { CustomHandler } from './types';
 export type { CustomHandler as Handler };
 declare module './hono' {

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

@@ -1,3 +1,3 @@
 import type { ServeStaticOptions } from './serve-static';
-declare const module: (options?: ServeStaticOptions) => import("../..").MiddlewareHandler<string, import("../../types").Environment, any>;
+declare const module: (options?: ServeStaticOptions) => import("../..").MiddlewareHandler<Partial<import("../../types").Environment>, import("../../types").Route, unknown>;
 export { module as serveStatic };

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

@@ -1,2 +1,8 @@
-import { validatorMiddleware } from './middleware';
-export { validatorMiddleware as validator };
+import type { Context } from '../../context';
+import type { Environment, Next, Route, ValidationTypes } from '../../types';
+declare type ValidatorHandler<E extends Partial<Environment>, R extends Route = Route, I = unknown> = (c: Context<E, R, I>, next: Next) => Promise<Response | undefined | void> | Response;
+export declare const validator: <T, U extends ValidationTypes, V extends {
+    type: U;
+    data: T;
+}, V2 = {}, E extends Partial<Environment> = Environment>(type: U, validationFunc: (value: unknown, c: Context<E, Route, any>) => Response | Promise<Response> | T) => ValidatorHandler<E, Route, V | V2>;
+export {};

package/dist/types/request.d.ts

@@ -1,39 +1,44 @@
+import type { GetParamKeys, InputToData, Route } from './types';
 import type { BodyData } from './utils/body';
 import type { Cookie } from './utils/cookie';
-declare global {
-    interface Request<CfHostMetadata = unknown, ParamKeyType extends string = string, Data = any> {
-        paramData?: Record<ParamKeyType, string>;
-        param: {
-            (key: ParamKeyType): string;
-            (): Record<ParamKeyType, string>;
-        };
-        queryData?: Record<string, string>;
-        query: {
-            (key: string): string;
-            (): Record<string, string>;
-        };
-        queries: {
-            (key: string): string[];
-            (): Record<string, string[]>;
-        };
-        headerData?: Record<string, string>;
-        header: {
-            (name: string): string;
-            (): Record<string, string>;
-        };
-        cookie: {
-            (name: string): string | undefined;
-            (): Cookie;
-        };
-        bodyData?: BodyData;
-        parseBody<BodyType extends BodyData>(): Promise<BodyType>;
-        jsonData?: any;
-        json<T>(): Promise<T>;
-        data: Data;
-        valid: {
-            (data: Data): Data;
-            (): Data;
-        };
-    }
+export declare class HonoRequest<R extends Route = Route, I = any> {
+    raw: Request;
+    private paramData;
+    private headerData;
+    private queryData;
+    private bodyData;
+    private jsonData;
+    private data;
+    constructor(request: Request, paramData?: Record<string, string> | undefined);
+    param(key: GetParamKeys<R['path']>): string;
+    param(): Record<GetParamKeys<R['path']>, string>;
+    query(key: string): string;
+    query(): Record<string, string>;
+    queries(key: string): string[];
+    queries(): Record<string, string[]>;
+    header(name: string): string;
+    header(): Record<string, string>;
+    cookie(key: string): string | undefined;
+    cookie(): Cookie;
+    parseBody<BodyType extends BodyData>(): Promise<BodyType>;
+    json<JSONData = unknown>(): Promise<Partial<JSONData>>;
+    text(): Promise<string>;
+    arrayBuffer(): Promise<ArrayBuffer>;
+    blob(): Promise<Blob>;
+    formData(): Promise<FormData>;
+    valid(data?: unknown): InputToData<I>;
+    get url(): string;
+    get method(): string;
+    get headers(): Headers;
+    get redirect(): RequestRedirect;
+    get body(): ReadableStream<Uint8Array> | null;
+    get bodyUsed(): boolean;
+    get cache(): RequestCache;
+    get credentials(): RequestCredentials;
+    get integrity(): string;
+    get keepalive(): boolean;
+    get mode(): RequestMode;
+    get referrer(): string;
+    get refererPolicy(): ReferrerPolicy;
+    get signal(): AbortSignal;
 }
-export declare function extendRequestPrototype(): void;

package/dist/types/types.d.ts

@@ -1,25 +1,98 @@
 import type { Context } from './context';
-export interface ContextVariableMap {
-}
+import type { Hono } from './hono';
+import type { UnionToIntersection } from './utils/types';
 export declare type Bindings = Record<string, any>;
 export declare type Variables = Record<string, any>;
 export declare type Environment = {
     Bindings: Bindings;
     Variables: Variables;
 };
-export declare type Handler<P extends string = string, E extends Partial<Environment> = Environment, S = any> = (c: Context<P, E, S>, next: Next) => Response | Promise<Response | undefined | void>;
-export declare type MiddlewareHandler<P extends string = string, E extends Partial<Environment> = Environment, S = any> = (c: Context<P, E, S>, next: Next) => Promise<Response | undefined | void>;
-export declare type NotFoundHandler<E extends Partial<Environment> = Environment> = (c: Context<string, E>) => Response | Promise<Response>;
-export declare type ErrorHandler<E extends Partial<Environment> = Environment> = (err: Error, c: Context<string, E>) => Response;
-export declare type Next = () => Promise<void>;
+declare type Env = Partial<Environment>;
+export declare type Route = {
+    path: string;
+    method: string;
+};
+export declare type Handler<E extends Env = Environment, R extends Route = Route, I = any, // should be any
+O = unknown> = (c: Context<E, R, I>, next: Next) => Response | Promise<Response | undefined | void> | TypeResponse<O> | Promise<TypeResponse<O>>;
+export interface HandlerInterface<E extends Env = Env, M extends string = string, P extends string = string, _I = any, _O = unknown> {
+    <I2, O2>(...handlers: Handler<E, {
+        method: M;
+        path: string;
+    }, I2, O2>[]): Hono<E, {
+        method: M;
+        path: string;
+    }, I2, O2>;
+    (...handlers: Handler<any, any>[]): Hono;
+    <I2, O2, Path extends string = P>(path: Path, ...handlers: Handler<E, {
+        method: M;
+        path: Path;
+    }, I2, O2>[]): Hono<E, {
+        method: M;
+        path: Path;
+    }, I2, O2>;
+    <I2, O2, Path extends string>(path: Path, ...handlers: Handler<any, any, I2, O2>[]): Hono<E, {
+        method: M;
+        path: Path;
+    }, I2, O2>;
+}
+export declare type ExtractType<T> = T extends TypeResponse<infer R> ? R : T extends Promise<TypeResponse<infer R>> ? R : never;
 declare type ParamKeyName<NameWithPattern> = NameWithPattern extends `${infer Name}{${infer _Pattern}` ? Name : NameWithPattern;
 declare type ParamKey<Component> = Component extends `:${infer NameWithPattern}` ? ParamKeyName<NameWithPattern> : never;
-export declare type ParamKeys<Path> = Path extends `${infer Component}/${infer Rest}` ? ParamKey<Component> | ParamKeys<Rest> : ParamKey<Path>;
-export interface CustomHandler<P = string, E = Partial<Environment>, S = any> {
-    (c: Context<P extends string ? P : string, P extends Partial<Environment> ? P : E extends Partial<Environment> ? E : never, P extends string ? E extends Partial<Environment> ? S : P extends Partial<Environment> ? E : never : P extends Partial<Environment> ? E extends Partial<Environment> ? S : E : P>, next: Next): Response | Promise<Response | undefined | void>;
-}
-export interface ExecutionContext {
-    waitUntil(promise: Promise<void>): void;
-    passThroughOnException(): void;
+declare type ParamKeys<Path> = Path extends `${infer Component}/${infer Rest}` ? ParamKey<Component> | ParamKeys<Rest> : ParamKey<Path>;
+export declare type GetParamKeys<Path> = ParamKeys<Path> extends never ? Path : ParamKeys<Path>;
+export declare type MiddlewareHandler<E extends Env = Env, R extends Route = Route, S = unknown> = (c: Context<E, R, S>, next: Next) => Promise<Response | undefined | void>;
+export declare type NotFoundHandler<E extends Env = Environment, R extends Route = Route> = (c: Context<E, R>) => Response | Promise<Response>;
+export declare type ErrorHandler<E extends Env = Environment> = (err: Error, c: Context<E>) => Response;
+export declare type Next = () => Promise<void>;
+export declare type TypeResponse<T = unknown> = {
+    response: Response | Promise<Response>;
+    data: T;
+    format: 'json';
+};
+export interface CustomHandler<E = Env, R = Route, I = any> {
+    (c: Context<E extends Env ? E : Env, E extends Route ? E : R extends Route ? R : R extends string ? {
+        path: R;
+        method: string;
+    } : never, E extends Env ? R extends Route | string ? I : E extends Env ? E : never : E extends Route | string ? R extends Env ? E : R : E>, next: Next): Response | Promise<Response | undefined | void>;
 }
+export declare type ValidationTypes = 'json' | 'form' | 'query' | 'queries';
+export declare type ToAppType<T> = T extends Hono<infer _, infer R, infer I, infer O> ? ToAppTypeInner<R, I, O> : never;
+declare type RemoveBlank<T> = {
+    [K in keyof T]: T extends {
+        type: ValidationTypes;
+    } ? T : never;
+};
+declare type ToAppTypeInner<R extends Route, I, O> = RemoveBlank<I> extends {
+    [K in string]: {
+        type: ValidationTypes;
+        data: unknown;
+    };
+} ? {
+    [K in R['method']]: {
+        [K2 in R['path']]: {
+            input: I extends {
+                type: ValidationTypes;
+                data: unknown;
+            } ? I extends {
+                type: infer R;
+            } ? R extends string ? {
+                [K in R]: I['data'];
+            } : never : never : never;
+            output: {
+                json: O;
+            };
+        };
+    };
+} : {
+    output: {
+        json: O;
+    };
+};
+export declare type InputToData<T> = ExtractData<T> extends never ? any : UnionToIntersection<ExtractData<T>>;
+declare type ExtractData<T> = T extends {
+    type: ValidationTypes;
+} ? T extends {
+    type: ValidationTypes;
+    data?: infer R;
+} ? R : any : T;
 export {};

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

@@ -1,3 +1,4 @@
 export declare type Expect<T extends true> = T;
 export declare type Equal<X, Y> = (<T>() => T extends X ? 1 : 2) extends <T>() => T extends Y ? 1 : 2 ? true : false;
 export declare type NotEqual<X, Y> = true extends Equal<X, Y> ? false : true;
+export declare type UnionToIntersection<U> = (U extends unknown ? (k: U) => void : never) extends (k: infer I) => void ? I : never;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hono",
-  "version": "2.7.0",
+  "version": "3.0.0-0",
   "description": "Ultrafast web framework for Cloudflare Workers, Deno, and Bun.",
   "main": "dist/cjs/index.js",
   "type": "module",
@@ -13,7 +13,7 @@
     "test": "jest",
     "test:deno": "deno test --allow-read deno_test",
     "test:bun": "bun wiptest --jsx-import-source ../src/middleware/jsx/jsx-dev-runtime bun_test/index.test.tsx",
-    "test:lagon": "npx start-server-and-test \"lagon dev lagon_test/index.ts\" http://127.0.0.1:1234 \"yarn jest lagon_test/index.test.ts --testMatch '**/*.test.ts'\"",
+    "test:lagon": "start-server-and-test \"lagon dev lagon_test/index.ts\" http://127.0.0.1:1234 \"yarn jest lagon_test/index.test.ts --testMatch '**/*.test.ts'\"",
     "test:all": "yarn test && yarn test:deno && yarn test:bun && yarn test:lagon",
     "lint": "eslint --ext js,ts src .eslintrc.cjs",
     "lint:fix": "eslint --ext js,ts src .eslintrc.cjs --fix",
@@ -276,9 +276,11 @@
     "np": "^7.6.2",
     "prettier": "^2.6.2",
     "rimraf": "^3.0.2",
+    "start-server-and-test": "^1.15.2",
     "ts-jest": "^29.0.1",
     "tsx": "^3.11.0",
-    "typescript": "^4.8.3"
+    "typescript": "^4.8.3",
+    "zod": "^3.20.2"
   },
   "engines": {
     "node": ">=16.0.0"