h3 0.7.21 → 0.8.1

package/dist/index.d.ts

@@ -1,7 +1,29 @@
-import { IncomingMessage as IncomingMessage$1, ServerResponse as ServerResponse$1, OutgoingMessage } from 'http';
+import { IncomingMessage, ServerResponse, OutgoingMessage } from 'http';
+export { IncomingMessage as NodeIncomingMessage, ServerResponse as NodeServerResponse } from 'http';
 import { CookieSerializeOptions } from 'cookie-es';
 import * as ufo from 'ufo';
 
+declare type HTTPMethod = 'GET' | 'HEAD' | 'PATCH' | 'POST' | 'PUT' | 'DELETE' | 'CONNECT' | 'OPTIONS' | 'TRACE';
+declare type Encoding = false | 'ascii' | 'utf8' | 'utf-8' | 'utf16le' | 'ucs2' | 'ucs-2' | 'base64' | 'latin1' | 'binary' | 'hex';
+interface H3EventContext extends Record<string, any> {
+}
+declare type EventHandlerResponse<T = any> = T | Promise<T>;
+interface EventHandler<T = any> {
+    '__is_handler__'?: true;
+    (event: H3Event): EventHandlerResponse<T>;
+}
+declare type LazyEventHandler = () => EventHandler | Promise<EventHandler>;
+
+declare type NodeListener = (req: IncomingMessage, res: ServerResponse) => void;
+declare type NodePromisifiedHandler = (req: IncomingMessage, res: ServerResponse) => Promise<any>;
+declare type NodeMiddleware = (req: IncomingMessage, res: ServerResponse, next?: (err?: Error) => any) => any;
+declare const defineNodeListener: (handler: NodeListener) => NodeListener;
+declare const defineNodeMiddleware: (middleware: NodeMiddleware) => NodeMiddleware;
+declare function fromNodeMiddleware(handler: NodeListener | NodeMiddleware): EventHandler;
+declare function toNodeListener(app: App): NodeListener;
+declare function promisifyNodeListener(handler: NodeListener | NodeMiddleware): NodePromisifiedHandler;
+declare function callNodeListener(handler: NodeMiddleware, req: IncomingMessage, res: ServerResponse): Promise<unknown>;
+
 declare class H3Headers implements Headers {
     _headers: Record<string, string>;
     constructor(init?: HeadersInit);
@@ -24,7 +46,7 @@ declare class H3Response implements Response {
     readonly body: ReadableStream<Uint8Array> | null;
     readonly type: ResponseType;
     readonly bodyUsed = false;
-    constructor(body?: BodyInit | HandlerResponse | null, init?: ResponseInit);
+    constructor(body?: BodyInit | EventHandlerResponse | null, init?: ResponseInit);
     clone(): H3Response;
     arrayBuffer(): Promise<ArrayBuffer>;
     blob(): Promise<Blob>;
@@ -37,18 +59,17 @@ declare class H3Event implements Pick<FetchEvent, 'respondWith'> {
     '__is_event__': boolean;
     req: IncomingMessage;
     res: ServerResponse;
-    event: H3Event;
     context: H3EventContext;
-    constructor(req: IncomingMessage$1 | IncomingMessage, res: ServerResponse$1 | ServerResponse);
+    constructor(req: IncomingMessage, res: ServerResponse);
     respondWith(r: H3Response | PromiseLike<H3Response>): void;
 }
 declare function isEvent(input: any): input is H3Event;
-declare function createEvent(req: IncomingMessage$1, res: ServerResponse$1): H3Event;
+declare function createEvent(req: IncomingMessage, res: ServerResponse): H3Event;
 
 declare function defineEventHandler<T = any>(handler: EventHandler<T>): EventHandler<T>;
 declare const eventHandler: typeof defineEventHandler;
 declare function isEventHandler(input: any): input is EventHandler;
-declare function toEventHandler(handler: CompatibilityEventHandler): EventHandler;
+declare function toEventHandler(input: any, _?: any, _route?: string): EventHandler;
 interface DynamicEventHandler extends EventHandler {
     set: (handler: EventHandler) => void;
 }
@@ -56,38 +77,6 @@ declare function dynamicEventHandler(initial?: EventHandler): DynamicEventHandle
 declare function defineLazyEventHandler(factory: LazyEventHandler): EventHandler;
 declare const lazyEventHandler: typeof defineLazyEventHandler;
 
-interface CompatibilityRequestProps {
-    event: H3Event;
-    context: H3EventContext;
-    /** Only available with connect and press */
-    originalUrl?: string;
-}
-interface IncomingMessage extends IncomingMessage$1, CompatibilityRequestProps {
-    req: H3Event['req'];
-    res: H3Event['res'];
-}
-interface ServerResponse extends ServerResponse$1 {
-    event: H3Event;
-    res: H3Event['res'];
-    req: ServerResponse$1['req'] & CompatibilityRequestProps;
-}
-declare type Handler<T = any, ReqT = {}> = (req: IncomingMessage & ReqT, res: ServerResponse) => T;
-declare type PromisifiedHandler = Handler<Promise<any>>;
-declare type Middleware = (req: IncomingMessage, res: ServerResponse, next: (err?: Error) => any) => any;
-declare type LazyHandler = () => Handler | Promise<Handler>;
-declare type Encoding = false | 'ascii' | 'utf8' | 'utf-8' | 'utf16le' | 'ucs2' | 'ucs-2' | 'base64' | 'latin1' | 'binary' | 'hex';
-declare type HTTPMethod = 'GET' | 'HEAD' | 'PATCH' | 'POST' | 'PUT' | 'DELETE' | 'CONNECT' | 'OPTIONS' | 'TRACE';
-interface H3EventContext extends Record<string, any> {
-}
-declare type CompatibilityEvent = H3Event | IncomingMessage;
-declare type HandlerResponse<T = any> = T | Promise<T>;
-interface EventHandler<T = any> {
-    '__is_handler__'?: true;
-    (event: H3Event): HandlerResponse<T>;
-}
-declare type LazyEventHandler = () => EventHandler | Promise<EventHandler>;
-declare type CompatibilityEventHandler = EventHandler | Handler | Middleware;
-
 interface Layer {
     route: string;
     match?: Matcher;
@@ -97,33 +86,28 @@ declare type Stack = Layer[];
 interface InputLayer {
     route?: string;
     match?: Matcher;
-    handler: Handler | LazyHandler | EventHandler | LazyEventHandler;
+    handler: EventHandler;
     lazy?: boolean;
-    /** @deprecated */
-    handle?: Handler;
-    /** @deprecated */
-    promisify?: boolean;
 }
 declare type InputStack = InputLayer[];
-declare type Matcher = (url: string, event?: CompatibilityEvent) => boolean;
+declare type Matcher = (url: string, event?: H3Event) => boolean;
 interface AppUse {
-    (route: string | string[], handler: CompatibilityEventHandler | CompatibilityEventHandler[], options?: Partial<InputLayer>): App;
-    (handler: CompatibilityEventHandler | CompatibilityEventHandler[], options?: Partial<InputLayer>): App;
+    (route: string | string[], handler: EventHandler | EventHandler[], options?: Partial<InputLayer>): App;
+    (handler: EventHandler | EventHandler[], options?: Partial<InputLayer>): App;
     (options: InputLayer): App;
 }
-declare type NodeHandler = (req: IncomingMessage$1, res: ServerResponse$1) => Promise<void>;
-interface App extends NodeHandler {
+interface AppOptions {
+    debug?: boolean;
+    onError?: (error: Error, event: H3Event) => any;
+}
+interface App {
     stack: Stack;
     handler: EventHandler;
-    nodeHandler: NodeHandler;
+    options: AppOptions;
     use: AppUse;
 }
-interface AppOptions {
-    debug?: boolean;
-    onError?: (error: Error, event: CompatibilityEvent) => any;
-}
 declare function createApp(options?: AppOptions): App;
-declare function use(app: App, arg1: string | Handler | InputLayer | InputLayer[], arg2?: Handler | Partial<InputLayer> | Handler[] | Middleware | Middleware[], arg3?: Partial<InputLayer>): App;
+declare function use(app: App, arg1: string | EventHandler | InputLayer | InputLayer[], arg2?: Partial<InputLayer> | EventHandler | EventHandler[], arg3?: Partial<InputLayer>): App;
 declare function createAppEventHandler(stack: Stack, options: AppOptions): EventHandler<void>;
 
 /**
@@ -143,7 +127,7 @@ declare class H3Error extends Error {
     statusCode: number;
     fatal: boolean;
     unhandled: boolean;
-    statusMessage: string;
+    statusMessage?: string;
     data?: any;
 }
 /**
@@ -158,40 +142,29 @@ declare function createError(input: string | Partial<H3Error>): H3Error;
  *  H3 internally uses this function to handle unhandled errors.<br>
  *  Note that calling this function will close the connection and no other data will be sent to client afterwards.
  *
- @param event {CompatibilityEvent} H3 event or req passed by h3 handler
+ @param event {H3Event} H3 event or req passed by h3 handler
  * @param error {H3Error|Error} Raised error
  * @param debug {Boolean} Whether application is in debug mode.<br>
  *  In the debug mode the stack trace of errors will be return in response.
  */
-declare function sendError(event: CompatibilityEvent, error: Error | H3Error, debug?: boolean): void;
+declare function sendError(event: H3Event, error: Error | H3Error, debug?: boolean): void;
 declare function isError(input: any): input is H3Error;
 
-declare const defineHandler: <T>(handler: Handler<T, {}>) => Handler<T, {}>;
-/** @deprecated Use defineHandler */
-declare const defineHandle: <T>(handler: Handler<T, {}>) => Handler<T, {}>;
-declare const defineMiddleware: (middleware: Middleware) => Middleware;
-declare function promisifyHandler(handler: Handler | Middleware): PromisifiedHandler;
-/** @deprecated Use defineHandler */
-declare const promisifyHandle: typeof promisifyHandler;
-declare function callHandler(handler: Middleware, req: IncomingMessage, res: ServerResponse): Promise<unknown>;
-declare function defineLazyHandler(handler: LazyHandler, promisify?: boolean): Handler;
-/** @deprecated Use defineLazyHandler */
-declare const lazyHandle: typeof defineLazyHandler;
-declare function useBase(base: string, handler: Handler): Handler;
+declare function useBase(base: string, handler: EventHandler): EventHandler;
 
 /**
  * Reads body of the request and returns encoded raw string (default) or `Buffer` if encoding if falsy.
- * @param event {CompatibilityEvent} H3 event or req passed by h3 handler
+ * @param event {H3Event} H3 event or req passed by h3 handler
  * @param encoding {Encoding} encoding="utf-8" - The character encoding to use.
  *
  * @return {String|Buffer} Encoded raw string or raw Buffer of the body
  */
-declare function readRawBody(event: CompatibilityEvent, encoding?: Encoding): Encoding extends false ? Buffer : Promise<string | Buffer>;
+declare function readRawBody(event: H3Event, encoding?: Encoding): Encoding extends false ? Buffer : Promise<string | Buffer>;
 /** @deprecated Use `h3.readRawBody` */
 declare const useRawBody: typeof readRawBody;
 /**
  * Reads request body and try to safely parse using [destr](https://github.com/unjs/destr)
- * @param event {CompatibilityEvent} H3 event or req passed by h3 handler
+ * @param event {H3Event} H3 event or req passed by h3 handler
  * @param encoding {Encoding} encoding="utf-8" - The character encoding to use.
  *
  * @return {*} The `Object`, `Array`, `String`, `Number`, `Boolean`, or `null` value corresponding to the request JSON body
@@ -200,7 +173,7 @@ declare const useRawBody: typeof readRawBody;
  * const body = await useBody(req)
  * ```
  */
-declare function readBody<T = any>(event: CompatibilityEvent): Promise<T>;
+declare function readBody<T = any>(event: H3Event): Promise<T>;
 /** @deprecated Use `h3.readBody` */
 declare const useBody: typeof readBody;
 
@@ -215,7 +188,7 @@ interface CacheConditions {
  * Note: `public` cache control will be added by default
  * @returns `true` when cache headers are matching. When `true` is returned, no reponse should be sent anymore
  */
-declare function handleCacheHeaders(event: CompatibilityEvent, opts: CacheConditions): boolean;
+declare function handleCacheHeaders(event: H3Event, opts: CacheConditions): boolean;
 
 declare const MIMES: {
     html: string;
@@ -224,30 +197,30 @@ declare const MIMES: {
 
 /**
  * Parse the request to get HTTP Cookie header string and returning an object of all cookie name-value pairs.
- * @param event {CompatibilityEvent} H3 event or req passed by h3 handler
+ * @param event {H3Event} H3 event or req passed by h3 handler
  * @returns Object of cookie name-value pairs
  * ```ts
  * const cookies = parseCookies(event)
  * ```
  */
-declare function parseCookies(event: CompatibilityEvent): Record<string, string>;
+declare function parseCookies(event: H3Event): Record<string, string>;
 /** @deprecated Use `h3.parseCookies` */
 declare const useCookies: typeof parseCookies;
 /**
  * Get a cookie value by name.
- * @param event {CompatibilityEvent} H3 event or req passed by h3 handler
+ * @param event {H3Event} H3 event or req passed by h3 handler
  * @param name Name of the cookie to get
  * @returns {*} Value of the cookie (String or undefined)
  * ```ts
  * const authorization = useCookie(request, 'Authorization')
  * ```
  */
-declare function getCookie(event: CompatibilityEvent, name: string): string | undefined;
+declare function getCookie(event: H3Event, name: string): string | undefined;
 /** @deprecated Use `h3.getCookie` */
 declare const useCookie: typeof getCookie;
 /**
  * Set a cookie value by name.
- * @param event {CompatibilityEvent} H3 event or res passed by h3 handler
+ * @param event {H3Event} H3 event or res passed by h3 handler
  * @param name Name of the cookie to set
  * @param value Value of the cookie to set
  * @param serializeOptions {CookieSerializeOptions} Options for serializing the cookie
@@ -255,57 +228,61 @@ declare const useCookie: typeof getCookie;
  * setCookie(res, 'Authorization', '1234567')
  * ```
  */
-declare function setCookie(event: CompatibilityEvent, name: string, value: string, serializeOptions?: CookieSerializeOptions): void;
+declare function setCookie(event: H3Event, name: string, value: string, serializeOptions?: CookieSerializeOptions): void;
 /**
  * Set a cookie value by name.
- * @param event {CompatibilityEvent} H3 event or res passed by h3 handler
+ * @param event {H3Event} H3 event or res passed by h3 handler
  * @param name Name of the cookie to delete
  * @param serializeOptions {CookieSerializeOptions} Cookie options
  * ```ts
  * deleteCookie(res, 'SessionId')
  * ```
  */
-declare function deleteCookie(event: CompatibilityEvent, name: string, serializeOptions?: CookieSerializeOptions): void;
+declare function deleteCookie(event: H3Event, name: string, serializeOptions?: CookieSerializeOptions): void;
 
-declare function getQuery(event: CompatibilityEvent): ufo.QueryObject;
+declare function getQuery(event: H3Event): ufo.QueryObject;
 /** @deprecated Use `h3.getQuery` */
 declare const useQuery: typeof getQuery;
-declare function getRouterParams(event: CompatibilityEvent): CompatibilityEvent['context'];
-declare function getRouterParam(event: CompatibilityEvent, name: string): CompatibilityEvent['context'][string];
-declare function getMethod(event: CompatibilityEvent, defaultMethod?: HTTPMethod): HTTPMethod;
+declare function getRouterParams(event: H3Event): H3Event['context'];
+declare function getRouterParam(event: H3Event, name: string): H3Event['context'][string];
+declare function getMethod(event: H3Event, defaultMethod?: HTTPMethod): HTTPMethod;
 /** @deprecated Use `h3.getMethod` */
 declare const useMethod: typeof getMethod;
-declare function isMethod(event: CompatibilityEvent, expected: HTTPMethod | HTTPMethod[], allowHead?: boolean): boolean;
-declare function assertMethod(event: CompatibilityEvent, expected: HTTPMethod | HTTPMethod[], allowHead?: boolean): void;
-declare function getRequestHeaders(event: CompatibilityEvent): CompatibilityEvent['req']['headers'];
+declare function isMethod(event: H3Event, expected: HTTPMethod | HTTPMethod[], allowHead?: boolean): boolean;
+declare function assertMethod(event: H3Event, expected: HTTPMethod | HTTPMethod[], allowHead?: boolean): void;
+declare function getRequestHeaders(event: H3Event): H3Event['req']['headers'];
 declare const getHeaders: typeof getRequestHeaders;
-declare function getRequestHeader(event: CompatibilityEvent, name: string): CompatibilityEvent['req']['headers'][string];
+declare function getRequestHeader(event: H3Event, name: string): H3Event['req']['headers'][string];
 declare const getHeader: typeof getRequestHeader;
 
-declare function send(event: CompatibilityEvent, data?: any, type?: string): Promise<void>;
-declare function defaultContentType(event: CompatibilityEvent, type?: string): void;
-declare function sendRedirect(event: CompatibilityEvent, location: string, code?: number): Promise<void>;
-declare function getResponseHeaders(event: CompatibilityEvent): ReturnType<CompatibilityEvent['res']['getHeaders']>;
-declare function getResponseHeader(event: CompatibilityEvent, name: string): ReturnType<CompatibilityEvent['res']['getHeader']>;
-declare function setResponseHeaders(event: CompatibilityEvent, headers: Record<string, Parameters<OutgoingMessage['setHeader']>[1]>): void;
+declare function send(event: H3Event, data?: any, type?: string): Promise<void>;
+declare function defaultContentType(event: H3Event, type?: string): void;
+declare function sendRedirect(event: H3Event, location: string, code?: number): Promise<void>;
+declare function getResponseHeaders(event: H3Event): ReturnType<H3Event['res']['getHeaders']>;
+declare function getResponseHeader(event: H3Event, name: string): ReturnType<H3Event['res']['getHeader']>;
+declare function setResponseHeaders(event: H3Event, headers: Record<string, Parameters<OutgoingMessage['setHeader']>[1]>): void;
 declare const setHeaders: typeof setResponseHeaders;
-declare function setResponseHeader(event: CompatibilityEvent, name: string, value: Parameters<OutgoingMessage['setHeader']>[1]): void;
+declare function setResponseHeader(event: H3Event, name: string, value: Parameters<OutgoingMessage['setHeader']>[1]): void;
 declare const setHeader: typeof setResponseHeader;
-declare function appendResponseHeaders(event: CompatibilityEvent, headers: Record<string, string>): void;
+declare function appendResponseHeaders(event: H3Event, headers: Record<string, string>): void;
 declare const appendHeaders: typeof appendResponseHeaders;
-declare function appendResponseHeader(event: CompatibilityEvent, name: string, value: string): void;
+declare function appendResponseHeader(event: H3Event, name: string, value: string): void;
 declare const appendHeader: typeof appendResponseHeader;
 declare function isStream(data: any): any;
-declare function sendStream(event: CompatibilityEvent, data: any): Promise<void>;
+declare function sendStream(event: H3Event, data: any): Promise<void>;
+declare function writeEarlyHints(event: H3Event, links: string | string[], callback?: () => void): void;
 
 declare type RouterMethod = Lowercase<HTTPMethod>;
-declare type RouterUse = (path: string, handler: CompatibilityEventHandler, method?: RouterMethod | RouterMethod[]) => Router;
+declare type RouterUse = (path: string, handler: EventHandler, method?: RouterMethod | RouterMethod[]) => Router;
 declare type AddRouteShortcuts = Record<RouterMethod, RouterUse>;
 interface Router extends AddRouteShortcuts {
     add: RouterUse;
     use: RouterUse;
     handler: EventHandler;
 }
-declare function createRouter(): Router;
+interface CreateRouterOptions {
+    preemtive?: boolean;
+}
+declare function createRouter(opts?: CreateRouterOptions): Router;
 
-export { AddRouteShortcuts, App, AppOptions, AppUse, CacheConditions, CompatibilityEvent, CompatibilityEventHandler, DynamicEventHandler, Encoding, EventHandler, H3Error, H3Event, H3EventContext, H3Headers, H3Response, HTTPMethod, Handler, HandlerResponse, IncomingMessage, InputLayer, InputStack, Layer, LazyEventHandler, LazyHandler, MIMES, Matcher, Middleware, NodeHandler, PromisifiedHandler, Router, RouterMethod, RouterUse, ServerResponse, Stack, appendHeader, appendHeaders, appendResponseHeader, appendResponseHeaders, assertMethod, callHandler, createApp, createAppEventHandler, createError, createEvent, createRouter, defaultContentType, defineEventHandler, defineHandle, defineHandler, defineLazyEventHandler, defineLazyHandler, defineMiddleware, deleteCookie, dynamicEventHandler, eventHandler, getCookie, getHeader, getHeaders, getMethod, getQuery, getRequestHeader, getRequestHeaders, getResponseHeader, getResponseHeaders, getRouterParam, getRouterParams, handleCacheHeaders, isError, isEvent, isEventHandler, isMethod, isStream, lazyEventHandler, lazyHandle, parseCookies, promisifyHandle, promisifyHandler, readBody, readRawBody, send, sendError, sendRedirect, sendStream, setCookie, setHeader, setHeaders, setResponseHeader, setResponseHeaders, toEventHandler, use, useBase, useBody, useCookie, useCookies, useMethod, useQuery, useRawBody };
+export { AddRouteShortcuts, App, AppOptions, AppUse, CacheConditions, CreateRouterOptions, DynamicEventHandler, Encoding, EventHandler, EventHandlerResponse, H3Error, H3Event, H3EventContext, H3Headers, H3Response, HTTPMethod, InputLayer, InputStack, Layer, LazyEventHandler, MIMES, Matcher, NodeListener, NodeMiddleware, NodePromisifiedHandler, Router, RouterMethod, RouterUse, Stack, appendHeader, appendHeaders, appendResponseHeader, appendResponseHeaders, assertMethod, callNodeListener, createApp, createAppEventHandler, createError, createEvent, createRouter, defaultContentType, defineEventHandler, defineLazyEventHandler, defineNodeListener, defineNodeMiddleware, deleteCookie, dynamicEventHandler, eventHandler, fromNodeMiddleware, getCookie, getHeader, getHeaders, getMethod, getQuery, getRequestHeader, getRequestHeaders, getResponseHeader, getResponseHeaders, getRouterParam, getRouterParams, handleCacheHeaders, isError, isEvent, isEventHandler, isMethod, isStream, lazyEventHandler, parseCookies, promisifyNodeListener, readBody, readRawBody, send, sendError, sendRedirect, sendStream, setCookie, setHeader, setHeaders, setResponseHeader, setResponseHeaders, toEventHandler, toNodeListener, use, useBase, useBody, useCookie, useCookies, useMethod, useQuery, useRawBody, writeEarlyHints };