webhoster 0.3.3 → 0.3.5

package/types/lib/HttpResponse.d.ts

@@ -0,0 +1,117 @@
+/** @typedef {import('http').OutgoingHttpHeaders} OutgoingHttpHeaders */
+/** @typedef {import('stream').Stream} Stream */
+/** @typedef {import('../data/custom-types.js').Middleware} Middleware */
+/** @typedef {import('./HttpRequest.js').default} HttpRequest */
+/** @typedef {import('../data/custom-types.js').ResponseFinalizer} ResponseFinalizer */
+/**
+ * @typedef {Object} HttpResponseOptions
+ * @prop {HttpRequest} [request]
+ * @prop {OutgoingHttpHeaders} [headers]
+ * @prop {function():boolean} [onHeadersSent]
+ * @prop {(flush:boolean, end:boolean) => any} [onSendHeaders]
+ * @prop {number} [status]
+ * @prop {Writable} stream
+ * @prop {Stream[]} [pipes]
+ * @prop {ResponseFinalizer[]} [finalizers] inline middleware for message body
+ * @prop {any} [body]
+ */
+export default class HttpResponse {
+    /** @param {HttpResponseOptions} options */
+    constructor(options: HttpResponseOptions);
+    request: import("./HttpRequest.js").default;
+    /** @type {OutgoingHttpHeaders} */
+    headers: OutgoingHttpHeaders;
+    isStreaming: boolean;
+    stream: import("stream").Writable;
+    pipes: import("stream").Stream[];
+    /** @type {ResponseFinalizer[]} */
+    finalizers: ResponseFinalizer[];
+    status: number;
+    /** @type {any} */
+    body: any;
+    set statusCode(number: number);
+    get statusCode(): number;
+    /**
+     * A boolean indicating whether the response was successful (status in the range 200–299) or not.
+     * @return {boolean}
+     */
+    get ok(): boolean;
+    get headersSent(): boolean;
+    /**
+     * @param {boolean} [flush] Flush headers
+     * @param {boolean} [end] End stream
+     * @return {void}
+     */
+    sendHeaders(flush?: boolean, end?: boolean): void;
+    /**
+     * @param {number} [status]
+     * @return {Promise<0>} HttpHandler.END
+     */
+    sendStatusOnly(status?: number): Promise<0>;
+    /**
+     * Send message body to response stream without finalizers
+     * @param {any} [body]
+     * @return {Promise<0>}
+     */
+    sendRaw(body?: any): Promise<0>;
+    /** @return {boolean} */
+    hasPipeline(): boolean;
+    /**
+     * @param {import('stream').Transform} stream
+     * @return {this}
+     */
+    addUpstream(stream: import("stream").Transform): this;
+    /**
+     * @param {(err: NodeJS.ErrnoException | null) => void} [callback] pipeline completion
+     * @return {Writable}
+     */
+    getPipeline(callback?: (err: NodeJS.ErrnoException | null) => void): Writable;
+    /**
+     * Asynchronously sends message body
+     * Returns on completions
+     * @throws {Error}
+     * @param {any} [body]
+     * @return {Promise<0>} HttpHandler.END
+     */
+    send(body?: any): Promise<0>;
+    wasEndCalled(): boolean;
+    /**
+     * Synchronously ends stream with message body. Ignores errors
+     * @param {any} [body]
+     * @return {0} HttpHandler.END
+     */
+    end(body?: any): 0;
+    /**
+     * @param {number} status
+     * @return {this}
+     */
+    code(status: number): this;
+    /**
+     * @param {number} status
+     * @throws {Error<ERR_HEADER_SENT>}
+     * @return {this}
+     */
+    setStatus(status: number): this;
+    #private;
+}
+export type Writable = import("stream").Writable;
+export type OutgoingHttpHeaders = import("http").OutgoingHttpHeaders;
+export type Stream = import("stream").Stream;
+export type Middleware = import("../data/custom-types.js").Middleware;
+export type HttpRequest = import("./HttpRequest.js").default;
+export type ResponseFinalizer = import("../data/custom-types.js").ResponseFinalizer;
+export type HttpResponseOptions = {
+    request?: HttpRequest;
+    headers?: OutgoingHttpHeaders;
+    onHeadersSent?: () => boolean;
+    onSendHeaders?: (flush: boolean, end: boolean) => any;
+    status?: number;
+    stream: Writable;
+    pipes?: Stream[];
+    /**
+     * inline middleware for message body
+     */
+    finalizers?: ResponseFinalizer[];
+    body?: any;
+};
+//# sourceMappingURL=HttpResponse.d.ts.map

package/types/lib/HttpResponse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HttpResponse.d.ts","sourceRoot":"","sources":["../../lib/HttpResponse.js"],"names":[],"mappings":"AAWA,wEAAwE;AACxE,gDAAgD;AAChD,yEAAyE;AACzE,gEAAgE;AAChE,uFAAuF;AAEvF;;;;;;;;;;;GAWG;AAEH;IAmBE,2CAA2C;IAC3C,qBADY,mBAAmB,EAe9B;IAbC,4CAA8B;IAC9B,kCAAkC;IAClC,SADW,mBAAmB,CACM;IACpC,qBAAwB;IACxB,kCAA4B;IAC5B,iCAAgC;IAChC,kCAAkC;IAClC,YADW,iBAAiB,EAAE,CACY;IAC1C,eAA4B;IAC5B,kBAAkB;IAClB,MADW,GAAG,CACU;IAS1B,+BAEC;IAND,yBAEC;IAMD;;;OAGG;IACH,UAFY,OAAO,CAIlB;IAED,2BAIC;IAED;;;;OAIG;IACH,oBAJW,OAAO,QACP,OAAO,GACN,IAAI,CAWf;IAED;;;OAGG;IACH,wBAHW,MAAM,GACL,OAAO,CAAC,CAAC,CAAC,CAUrB;IAED;;;;OAIG;IACH,eAHW,GAAG,GACF,OAAO,CAAC,CAAC,CAAC,CASrB;IAED,wBAAwB;IACxB,eADa,OAAO,CAGnB;IAED;;;OAGG;IACH,oBAHW,OAAO,QAAQ,EAAE,SAAS,GACzB,IAAI,CAKf;IAED;;;OAGG;IACH,uBAHW,CAAC,GAAG,EAAE,MAAM,CAAC,cAAc,GAAG,IAAI,KAAK,IAAI,GAC1C,QAAQ,CAmDnB;IAED;;;;;;OAMG;IACH,YAHW,GAAG,GACF,OAAO,CAAC,CAAC,CAAC,CA6CrB;IAED,wBAEC;IAED;;;;OAIG;IACH,WAHW,GAAG,GACF,CAAC,CAmGZ;IAID;;;OAGG;IACH,aAHW,MAAM,GACL,IAAI,CAKf;IAED;;;;OAIG;IACH,kBAJW,MAAM,GAEL,IAAI,CAMf;;CACF;uBAzXa,OAAO,QAAQ,EAAE,QAAQ;kCAMzB,OAAO,MAAM,EAAE,mBAAmB;qBAClC,OAAO,QAAQ,EAAE,MAAM;yBACvB,OAAO,yBAAyB,EAAE,UAAU;0BAC5C,OAAO,kBAAkB,EAAE,OAAO;gCAClC,OAAO,yBAAyB,EAAE,iBAAiB;;cAIvD,WAAW;cACX,mBAAmB;oBACnB,MAAW,OAAO;oBAClB,CAAC,KAAK,EAAC,OAAO,EAAE,GAAG,EAAC,OAAO,KAAK,GAAG;aACnC,MAAM;YACN,QAAQ;YACR,MAAM,EAAE;;;;iBACR,iBAAiB,EAAE;WACnB,GAAG"}

package/types/lib/HttpTransaction.d.ts

@@ -0,0 +1,114 @@
+/** @typedef {import('./HttpRequest.js').default} HttpRequest */
+/** @typedef {import('./HttpResponse.js').default} HttpResponse */
+/** @typedef {import('stream').Stream} Stream */
+/** @typedef {import('../data/custom-types.js').MediaType} MediaType */
+/** @typedef {import('../data/custom-types.js').Middleware} Middleware */
+/** @typedef {import('stream').Writable} Writable */
+/** @typedef {Partial<MediaType> & {parse:(this:HttpRequest)=>any|PromiseLike<any>, test?:(this:HttpRequest, mediaType: MediaType)=>boolean}} ContentReaderRegistration */
+/**
+ * @typedef {Object} PathHistoryEntry
+ * @prop {string} base
+ * @prop {number[]} treeIndex
+ */
+/**
+ * @typedef {Object} PathState
+ * @prop {PathHistoryEntry[]} history
+ * @prop {string} currentPath
+ */
+/**
+ * @typedef {Object} HttpTransactionState
+ * @prop {number[]} treeIndex Middleware level
+ * @prop {PathState} path
+ */
+/**
+ * @template {Object<string,any>} T
+ * @typedef HttpTransactionOptions
+ * @prop {string} httpVersion
+ * @prop {HttpRequest} [request]
+ * @prop {HttpResponse} [response]
+ * @prop {import('net').Socket|import('tls').TLSSocket} socket
+ * @prop {boolean} [canPing]
+ * @prop {(function():Promise<any>)|(function():any)} [onPing]
+ * @prop {boolean|function():boolean} [canPushPath]
+ * @prop {(path:string) => Promise<any>} [onPushPath]
+ * @prop {function():boolean} [onHeadersSent]
+ * @prop {(flush:boolean, end:boolean) => boolean} [onSendHeaders]
+ * @prop {T} [locals]
+ * @prop {HttpTransactionState} [state]
+ * @prop {Error} [error]
+ */
+/**
+ * @template {Object<string,any>} [T=any]
+ */
+export default class HttpTransaction<T extends {
+    [x: string]: any;
+} = any> {
+    /** @param {HttpTransactionOptions<T>} options */
+    constructor(options: HttpTransactionOptions<T>);
+    request: import("./HttpRequest.js").default;
+    response: import("./HttpResponse.js").default;
+    /** @type {T} */
+    locals: T;
+    state: HttpTransactionState;
+    socket: import("net").Socket | import("tls").TLSSocket;
+    httpVersion: string;
+    error: Error;
+    setErrorHandlerState(): void;
+    isErrorHandlerState(): boolean;
+    get canPing(): boolean;
+    /**
+     * @return {Promise<any>}
+     */
+    ping(): Promise<any>;
+    get pushedPaths(): string[];
+    get canPushPath(): boolean;
+    /**
+     * @param {string} [path]
+     * @return {Promise<any>}
+     */
+    pushPath(path?: string): Promise<any>;
+    #private;
+}
+export type HttpRequest = import("./HttpRequest.js").default;
+export type HttpResponse = import("./HttpResponse.js").default;
+export type Stream = import("stream").Stream;
+export type MediaType = import("../data/custom-types.js").MediaType;
+export type Middleware = import("../data/custom-types.js").Middleware;
+export type Writable = import("stream").Writable;
+export type ContentReaderRegistration = Partial<MediaType> & {
+    parse: (this: HttpRequest) => any | PromiseLike<any>;
+    test?: (this: HttpRequest, mediaType: MediaType) => boolean;
+};
+export type PathHistoryEntry = {
+    base: string;
+    treeIndex: number[];
+};
+export type PathState = {
+    history: PathHistoryEntry[];
+    currentPath: string;
+};
+export type HttpTransactionState = {
+    /**
+     * Middleware level
+     */
+    treeIndex: number[];
+    path: PathState;
+};
+export type HttpTransactionOptions<T extends {
+    [x: string]: any;
+}> = {
+    httpVersion: string;
+    request?: HttpRequest;
+    response?: HttpResponse;
+    socket: import("net").Socket | import("tls").TLSSocket;
+    canPing?: boolean;
+    onPing?: (() => Promise<any>) | (() => any);
+    canPushPath?: boolean | (() => boolean);
+    onPushPath?: (path: string) => Promise<any>;
+    onHeadersSent?: () => boolean;
+    onSendHeaders?: (flush: boolean, end: boolean) => boolean;
+    locals?: T;
+    state?: HttpTransactionState;
+    error?: Error;
+};
+//# sourceMappingURL=HttpTransaction.d.ts.map

package/types/lib/HttpTransaction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HttpTransaction.d.ts","sourceRoot":"","sources":["../../lib/HttpTransaction.js"],"names":[],"mappings":"AAAA,gEAAgE;AAChE,kEAAkE;AAClE,gDAAgD;AAEhD,uEAAuE;AACvE,yEAAyE;AACzE,oDAAoD;AAEpD,0KAA0K;AAE1K;;;;GAIG;AAEH;;;;GAIG;AAEH;;;;GAIG;AAEH;;;;;;;;;;;;;;;;GAgBG;AAEH;;GAEG;AACH,qCAFmC,CAAC,SAAvB;QAAQ,MAAM,GAAC,GAAG;CAAE;IAoB/B,iDAAiD;IACjD,qBADY,sBAAsB,CAAC,CAAC,CAAC,EAsBpC;IApBC,4CAA8B;IAC9B,8CAAgC;IAEhC,gBAAgB;IAChB,QADW,CAAC,CACyC;IACrD,4BAGC;IAED,uDAA4B;IAC5B,oBAAsC;IAQtC,aAA0B;IAG5B,6BAEC;IAED,+BAEC;IAED,uBAIC;IAED;;OAEG;IACH,QAFY,OAAO,CAAC,GAAG,CAAC,CAUvB;IAED,4BAEC;IAED,2BAIC;IAED;;;OAGG;IACH,gBAHW,MAAM,GACL,OAAO,CAAC,GAAG,CAAC,CAcvB;;CACF;0BAjJa,OAAO,kBAAkB,EAAE,OAAO;2BAClC,OAAO,mBAAmB,EAAE,OAAO;qBACnC,OAAO,QAAQ,EAAE,MAAM;wBAEvB,OAAO,yBAAyB,EAAE,SAAS;yBAC3C,OAAO,yBAAyB,EAAE,UAAU;uBAC5C,OAAO,QAAQ,EAAE,QAAQ;wCAEzB,OAAO,CAAC,SAAS,CAAC,GAAG;IAAC,KAAK,EAAC,CAAC,IAAI,EAAC,WAAW,KAAG,GAAG,GAAC,WAAW,CAAC,GAAG,CAAC,CAAC;IAAC,IAAI,CAAC,EAAC,CAAC,IAAI,EAAC,WAAW,EAAE,SAAS,EAAE,SAAS,KAAG,OAAO,CAAA;CAAC;;UAIlI,MAAM;eACN,MAAM,EAAE;;;aAKR,gBAAgB,EAAE;iBAClB,MAAM;;;;;;eAKN,MAAM,EAAE;UACR,SAAS;;mCAIe,CAAC,SAAtB;QAAQ,MAAM,GAAC,GAAG;CAAE;iBAEvB,MAAM;cACN,WAAW;eACX,YAAY;YACZ,OAAO,KAAK,EAAE,MAAM,GAAC,OAAO,KAAK,EAAE,SAAS;cAC5C,OAAO;aACP,CAAC,MAAW,OAAO,CAAC,GAAG,CAAC,CAAC,GAAC,CAAC,MAAW,GAAG,CAAC;kBAC1C,OAAO,IAAC,MAAW,OAAO,CAAA;iBAC1B,CAAC,IAAI,EAAC,MAAM,KAAK,OAAO,CAAC,GAAG,CAAC;oBAC7B,MAAW,OAAO;oBAClB,CAAC,KAAK,EAAC,OAAO,EAAE,GAAG,EAAC,OAAO,KAAK,OAAO;aACvC,CAAC;YACD,oBAAoB;YACpB,KAAK"}

package/types/middleware/AutoHeadersMiddleware.d.ts

@@ -0,0 +1,27 @@
+/**
+ * @typedef {Object} AutoHeadersMiddlewareOptions
+ * @prop {boolean} [setStatus=true]
+ * Automatically set `200` or `204` status if not set
+ */
+export default class AutoHeadersMiddleware {
+    /** @param {AutoHeadersMiddlewareOptions} options */
+    constructor(options?: AutoHeadersMiddlewareOptions);
+    setStatus: boolean;
+    finalizeResponse(response: import("../data/custom-types.js").HttpResponse): void | null | boolean | Promise<void | null | boolean>;
+    /**
+     * @param {HttpResponse} response
+     * @return {void}
+     */
+    addTransformStream(response: HttpResponse): void;
+    execute(transaction: import("../lib/HttpTransaction.js").default<any>): import("../data/custom-types.js").MiddlewareFunctionResult;
+}
+export type HttpResponse = import("../lib/HttpResponse.js").default;
+export type ResponseFinalizer = import("../data/custom-types.js").ResponseFinalizer;
+export type MiddlewareFunction = import("../data/custom-types.js").MiddlewareFunction;
+export type AutoHeadersMiddlewareOptions = {
+    /**
+     * Automatically set `200` or `204` status if not set
+     */
+    setStatus?: boolean;
+};
+//# sourceMappingURL=AutoHeadersMiddleware.d.ts.map

package/types/middleware/AutoHeadersMiddleware.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AutoHeadersMiddleware.d.ts","sourceRoot":"","sources":["../../middleware/AutoHeadersMiddleware.js"],"names":[],"mappings":"AAMA;;;;GAIG;AAEH;IACE,oDAAoD;IACpD,sBADY,4BAA4B,EAIvC;IAFC,mBAA4C;;IAI9C;;;OAGG;IACH,6BAHW,YAAY,GACX,IAAI,CA+Bf;;CAoBF;2BAxEa,OAAO,wBAAwB,EAAE,OAAO;gCACxC,OAAO,yBAAyB,EAAE,iBAAiB;iCACnD,OAAO,yBAAyB,EAAE,kBAAkB;;;;;gBAMxD,OAAO"}

package/types/middleware/CORSMiddleware.d.ts

@@ -0,0 +1,65 @@
+/** @typedef {import('../data/custom-types.js').IMiddleware} IMiddleware */
+/** @typedef {import('../data/custom-types.js').MiddlewareFunction} MiddlewareFunction */
+/** @typedef {import('../data/custom-types.js').RequestMethod} RequestMethod */
+/**
+ * @typedef CORSMiddlewareOptions
+ * @prop {(string|RegExp)[]} [allowOrigin]
+ * Indicates whether the response can be shared, via returning the literal
+ * value of the `Origin` request header (which can be `null`) or `*` in a response.
+ * @prop {boolean} [allowCredentials]
+ * Indicates whether the response can be shared when request’s credentials mode is "include".
+ * @prop {RequestMethod[]} [allowMethods]
+ * Indicates which methods are supported by the response’s URL for the purposes of the CORS protocol.
+ * @prop {string[]} [allowHeaders]
+ * Indicates which headers are supported by the response’s URL for the purposes of the CORS protocol.
+ * @prop {number} [maxAge=5]
+ * Indicates the number of seconds (5 by default) the information provided by the
+ * `Access-Control-Allow-Methods` and `Access-Control-Allow-Headers` headers can be cached.
+ * @prop {string[]} [exposeHeaders]
+ * Indicates which headers can be exposed as part of the response by listing their names.
+ */
+export default class CORSMiddleware {
+    static OK_BUFFER: Buffer<ArrayBuffer>;
+    static ACCESS_CONTROL_ALLOW_HEADERS_ALL: string;
+    /** @param {CORSMiddlewareOptions} [options] */
+    constructor(options?: CORSMiddlewareOptions);
+    allowOrigin: (string | RegExp)[];
+    allowCredentials: boolean;
+    allowMethods: import("../data/custom-types.js").RequestMethod[];
+    allowHeaders: string[];
+    maxAge: number;
+    exposeHeaders: string[];
+    execute(transaction: import("../lib/HttpTransaction.js").default<any>): import("../data/custom-types.js").MiddlewareFunctionResult;
+}
+export type IMiddleware = import("../data/custom-types.js").IMiddleware;
+export type MiddlewareFunction = import("../data/custom-types.js").MiddlewareFunction;
+export type RequestMethod = import("../data/custom-types.js").RequestMethod;
+export type CORSMiddlewareOptions = {
+    /**
+     * Indicates whether the response can be shared, via returning the literal
+     * value of the `Origin` request header (which can be `null`) or `*` in a response.
+     */
+    allowOrigin?: (string | RegExp)[];
+    /**
+     * Indicates whether the response can be shared when request’s credentials mode is "include".
+     */
+    allowCredentials?: boolean;
+    /**
+     * Indicates which methods are supported by the response’s URL for the purposes of the CORS protocol.
+     */
+    allowMethods?: RequestMethod[];
+    /**
+     * Indicates which headers are supported by the response’s URL for the purposes of the CORS protocol.
+     */
+    allowHeaders?: string[];
+    /**
+     * Indicates the number of seconds (5 by default) the information provided by the
+     * `Access-Control-Allow-Methods` and `Access-Control-Allow-Headers` headers can be cached.
+     */
+    maxAge?: number;
+    /**
+     * Indicates which headers can be exposed as part of the response by listing their names.
+     */
+    exposeHeaders?: string[];
+};
+//# sourceMappingURL=CORSMiddleware.d.ts.map

package/types/middleware/CORSMiddleware.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CORSMiddleware.d.ts","sourceRoot":"","sources":["../../middleware/CORSMiddleware.js"],"names":[],"mappings":"AAAA,2EAA2E;AAC3E,yFAAyF;AACzF,+EAA+E;AAE/E;;;;;;;;;;;;;;;;GAgBG;AAEH;IAWE,sCAA8C;IAE9C,gDAEY;IAdZ,+CAA+C;IAC/C,sBADY,qBAAqB,EAQhC;IANC,iCAAsC;IACtC,0BAAyD;IACzD,gEAAwC;IACxC,uBAAwC;IACxC,eAAiC;IACjC,wBAA0C;;CAkE7C;0BAhGa,OAAO,yBAAyB,EAAE,WAAW;iCAC7C,OAAO,yBAAyB,EAAE,kBAAkB;4BACpD,OAAO,yBAAyB,EAAE,aAAa;;;;;;kBAInD,CAAC,MAAM,GAAC,MAAM,CAAC,EAAE;;;;uBAGjB,OAAO;;;;mBAEP,aAAa,EAAE;;;;mBAEf,MAAM,EAAE;;;;;aAER,MAAM;;;;oBAGN,MAAM,EAAE"}

package/types/middleware/CaseInsensitiveHeadersMiddleware.d.ts

@@ -0,0 +1,27 @@
+/** @typedef {import('../data/custom-types.js').IMiddleware} IMiddleware */
+/** @typedef {import('../data/custom-types.js').MiddlewareFunction} MiddlewareFunction */
+/**
+ * @typedef {Object} CaseInsensitiveHeadersMiddlewareOptions
+ * @prop {boolean} [request=false] Mutate request headers to be case-insensitive
+ * @prop {boolean} [response=false] Mutate response headers to be case-insensistive
+ */
+export default class CaseInsensitiveHeadersMiddleware {
+    /** @param {CaseInsensitiveHeadersMiddlewareOptions} options */
+    constructor(options: CaseInsensitiveHeadersMiddlewareOptions);
+    request: boolean;
+    response: boolean;
+    execute(transaction: import("../lib/HttpTransaction.js").default<any>): import("../data/custom-types.js").MiddlewareFunctionResult;
+}
+export type IMiddleware = import("../data/custom-types.js").IMiddleware;
+export type MiddlewareFunction = import("../data/custom-types.js").MiddlewareFunction;
+export type CaseInsensitiveHeadersMiddlewareOptions = {
+    /**
+     * Mutate request headers to be case-insensitive
+     */
+    request?: boolean;
+    /**
+     * Mutate response headers to be case-insensistive
+     */
+    response?: boolean;
+};
+//# sourceMappingURL=CaseInsensitiveHeadersMiddleware.d.ts.map

package/types/middleware/CaseInsensitiveHeadersMiddleware.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CaseInsensitiveHeadersMiddleware.d.ts","sourceRoot":"","sources":["../../middleware/CaseInsensitiveHeadersMiddleware.js"],"names":[],"mappings":"AAEA,2EAA2E;AAC3E,yFAAyF;AAEzF;;;;GAIG;AAEH;IACE,+DAA+D;IAC/D,qBADY,uCAAuC,EAIlD;IAFC,iBAAuC;IACvC,kBAAyC;;CAc5C;0BA3Ba,OAAO,yBAAyB,EAAE,WAAW;iCAC7C,OAAO,yBAAyB,EAAE,kBAAkB;;;;;cAIxD,OAAO;;;;eACP,OAAO"}

package/types/middleware/ContentDecoderMiddleware.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Implements `Accept-Encoding`
+ * https://tools.ietf.org/html/rfc7231#section-5.3.4
+ */
+export default class ContentDecoderMiddleware {
+    /** @param {ContentDecoderMiddlewareOptions} [options] */
+    constructor(options?: ContentDecoderMiddlewareOptions);
+    chunkSize: number;
+    respondNotAcceptable: boolean;
+    execute(transaction: import("../lib/HttpTransaction.js").default<any>): import("../data/custom-types.js").MiddlewareFunctionResult;
+}
+export type MiddlewareFunction = import("../data/custom-types.js").MiddlewareFunction;
+export type ContentDecoderMiddlewareOptions = {
+    chunkSize?: number;
+    respondNotAcceptable?: boolean;
+};
+//# sourceMappingURL=ContentDecoderMiddleware.d.ts.map

package/types/middleware/ContentDecoderMiddleware.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ContentDecoderMiddleware.d.ts","sourceRoot":"","sources":["../../middleware/ContentDecoderMiddleware.js"],"names":[],"mappings":"AAgBA;;;GAGG;AACH;IACE,yDAAyD;IACzD,sBADY,+BAA+B,EAI1C;IAFC,kBAAkC;IAClC,8BAAiE;;CAoHpE;iCAtIa,OAAO,yBAAyB,EAAE,kBAAkB;;gBAIxD,MAAM;2BACN,OAAO"}

package/types/middleware/ContentEncoderMiddleware.d.ts

@@ -0,0 +1,48 @@
+export default class ContentEncoderMiddleware {
+    static BrotliCompressAsync: typeof brotliCompress.__promisify__;
+    static GzipAsync: typeof gzip.__promisify__;
+    static DeflateAsync: typeof deflate.__promisify__;
+    /**
+     * @param {IncomingHttpHeaders} headers
+     * @throws {NotAcceptableException} Error with `NOT_ACCEPTIBLE` message
+     * @return {COMPATIBLE_ENCODING}
+     */
+    static chooseEncoding(headers: IncomingHttpHeaders): COMPATIBLE_ENCODING;
+    /** @param {ContentEncoderMiddlewareOptions} [options] */
+    constructor(options?: ContentEncoderMiddlewareOptions);
+    chunkSize: number;
+    respondNotAcceptable: boolean;
+    preferredEncoding: "deflate" | "gzip" | "br" | "identity";
+    minimumSize: number;
+    asyncThreshold: number;
+    finalizeResponse(response: import("../data/custom-types.js").HttpResponse): void | null | boolean | Promise<void | null | boolean>;
+    /**
+     * @param {HttpResponse} response
+     * @return {void}
+     */
+    addTransformStream(response: HttpResponse): void;
+    execute(transaction: import("../lib/HttpTransaction.js").default<any>): import("../data/custom-types.js").MiddlewareFunctionResult;
+}
+export type IncomingHttpHeaders = import("http").IncomingHttpHeaders;
+export type HttpRequest = import("../lib/HttpRequest.js").default;
+export type HttpResponse = import("../lib/HttpResponse.js").default;
+export type MiddlewareFunction = import("../data/custom-types.js").MiddlewareFunction;
+export type ResponseFinalizer = import("../data/custom-types.js").ResponseFinalizer;
+export type COMPATIBLE_ENCODING = "br" | "gzip" | "deflate" | "identity" | "*";
+export type ContentEncoderMiddlewareOptions = {
+    chunkSize?: number;
+    respondNotAcceptable?: boolean;
+    /**
+     * Minimum content size before using any compression
+     */
+    preferredEncoding?: "br" | "gzip" | "deflate" | "identity";
+    /**
+     * Minimum content size before using async compression
+     */
+    minimumSize?: number;
+    asyncThreshold?: number;
+};
+import { brotliCompress } from 'node:zlib';
+import { gzip } from 'node:zlib';
+import { deflate } from 'node:zlib';
+//# sourceMappingURL=ContentEncoderMiddleware.d.ts.map

package/types/middleware/ContentEncoderMiddleware.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ContentEncoderMiddleware.d.ts","sourceRoot":"","sources":["../../middleware/ContentEncoderMiddleware.js"],"names":[],"mappings":"AAwCA;IACE,gEAAuD;IAEvD,4CAAmC;IAEnC,kDAAyC;IAEzC;;;;OAIG;IACH,+BAJW,mBAAmB,GAElB,mBAAmB,CA8C9B;IAED,yDAAyD;IACzD,sBADY,+BAA+B,EAQ1C;IANC,kBAAkC;IAClC,8BAAiE;IACjE,0DAAgE;IAChE,oBAA8D;IAC9D,uBAAuE;;IAIzE;;;OAGG;IACH,6BAHW,YAAY,GACX,IAAI,CA4Ef;;CAwGF;kCApRa,OAAO,MAAM,EAAE,mBAAmB;0BAClC,OAAO,uBAAuB,EAAE,OAAO;2BACvC,OAAO,wBAAwB,EAAE,OAAO;iCACxC,OAAO,yBAAyB,EAAE,kBAAkB;gCACpD,OAAO,yBAAyB,EAAE,iBAAiB;kCAEnD,IAAI,GAAC,MAAM,GAAC,SAAS,GAAC,UAAU,GAAC,GAAG;;gBAQxC,MAAM;2BACN,OAAO;;;;wBACP,IAAI,GAAC,MAAM,GAAC,SAAS,GAAC,UAAU;;;;kBAEhC,MAAM;qBAEN,MAAM;;+BA1BT,WAAW;qBAAX,WAAW;wBAAX,WAAW"}

package/types/middleware/ContentLengthMiddleware.d.ts

@@ -0,0 +1,38 @@
+/**
+ * @typedef {Object} ContentLengthMiddlewareOptions
+ * @prop {number} [delayCycles=2]
+ * Delays writing to stream by setTimeout cycles when piping.
+ * If `.end()` is called on the same event loop as write, then the
+ * content length can be still calculated despite receiving data in chunks.
+ * @prop {boolean} [overrideHeader=false]
+ * Always replace `Content-Length` header
+ */
+export default class ContentLengthMiddleware {
+    /** @param {ContentLengthMiddlewareOptions} [options] */
+    constructor(options?: ContentLengthMiddlewareOptions);
+    delayCycles: number;
+    overrideHeader: boolean;
+    finalizeResponse(response: import("../data/custom-types.js").HttpResponse): void | null | boolean | Promise<void | null | boolean>;
+    /**
+     * @param {HttpResponse} response
+     * @return {void}
+     */
+    addTransformStream(response: HttpResponse): void;
+    execute(transaction: import("../lib/HttpTransaction.js").default<any>): import("../data/custom-types.js").MiddlewareFunctionResult;
+}
+export type HttpResponse = import("../lib/HttpResponse.js").default;
+export type MiddlewareFunction = import("../data/custom-types.js").MiddlewareFunction;
+export type ResponseFinalizer = import("../data/custom-types.js").ResponseFinalizer;
+export type ContentLengthMiddlewareOptions = {
+    /**
+     * Delays writing to stream by setTimeout cycles when piping.
+     * If `.end()` is called on the same event loop as write, then the
+     * content length can be still calculated despite receiving data in chunks.
+     */
+    delayCycles?: number;
+    /**
+     * Always replace `Content-Length` header
+     */
+    overrideHeader?: boolean;
+};
+//# sourceMappingURL=ContentLengthMiddleware.d.ts.map

package/types/middleware/ContentLengthMiddleware.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ContentLengthMiddleware.d.ts","sourceRoot":"","sources":["../../middleware/ContentLengthMiddleware.js"],"names":[],"mappings":"AAMA;;;;;;;;GAQG;AAEH;IACE,wDAAwD;IACxD,sBADY,8BAA8B,EAKzC;IAHC,oBAA2C;IAC3C,wBAAqD;;IAIvD;;;OAGG;IACH,6BAHW,YAAY,GACX,IAAI,CAwDf;;CA+BF;2BAjHa,OAAO,wBAAwB,EAAE,OAAO;iCACxC,OAAO,yBAAyB,EAAE,kBAAkB;gCACpD,OAAO,yBAAyB,EAAE,iBAAiB;;;;;;;kBAMvD,MAAM;;;;qBAIN,OAAO"}

package/types/middleware/HashMiddleware.d.ts

@@ -0,0 +1,28 @@
+/**
+ * @typedef {Object} HashMiddlewareOptions
+ * @prop {'md5'|'sha1'|'sha256'|'sha512'} [algorithm=DEFAULT_ALGORITHM]
+ * @prop {BinaryToTextEncoding} [digest=DEFAULT_DIGEST]
+ */
+export default class HashMiddleware {
+    /** @param {HashMiddlewareOptions} options */
+    constructor(options?: HashMiddlewareOptions);
+    algorithm: "sha1" | "md5" | "sha256" | "sha512";
+    digest: import("crypto").BinaryToTextEncoding;
+    finalizeResponse(response: import("../data/custom-types.js").HttpResponse): void | null | boolean | Promise<void | null | boolean>;
+    /**
+     * @param {HttpResponse} response
+     * @return {void}
+     */
+    addTransformStream(response: HttpResponse): void;
+    execute(transaction: import("../lib/HttpTransaction.js").default<any>): import("../data/custom-types.js").MiddlewareFunctionResult;
+}
+export type BinaryToTextEncoding = import("node:crypto").BinaryToTextEncoding;
+export type HttpRequest = import("../lib/HttpRequest.js").default;
+export type HttpResponse = import("../lib/HttpResponse.js").default;
+export type MiddlewareFunction = import("../data/custom-types.js").MiddlewareFunction;
+export type ResponseFinalizer = import("../data/custom-types.js").ResponseFinalizer;
+export type HashMiddlewareOptions = {
+    algorithm?: "md5" | "sha1" | "sha256" | "sha512";
+    digest?: BinaryToTextEncoding;
+};
+//# sourceMappingURL=HashMiddleware.d.ts.map

package/types/middleware/HashMiddleware.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HashMiddleware.d.ts","sourceRoot":"","sources":["../../middleware/HashMiddleware.js"],"names":[],"mappings":"AAaA;;;;GAIG;AAEH;IACE,6CAA6C;IAC7C,sBADY,qBAAqB,EAKhC;IAHC,gDAAuD;IACvD,8CAA8C;;IAIhD;;;OAGG;IACH,6BAHW,YAAY,GACX,IAAI,CAiDf;;CA8BF;mCAzGa,OAAO,aAAa,EAAE,oBAAoB;0BAC1C,OAAO,uBAAuB,EAAE,OAAO;2BACvC,OAAO,wBAAwB,EAAE,OAAO;iCACxC,OAAO,yBAAyB,EAAE,kBAAkB;gCACpD,OAAO,yBAAyB,EAAE,iBAAiB;;gBAQvD,KAAK,GAAC,MAAM,GAAC,QAAQ,GAAC,QAAQ;aAC9B,oBAAoB"}

package/types/middleware/HeadMethodMiddleware.d.ts

@@ -0,0 +1,12 @@
+export default class HeadMethodMiddleware {
+    /** @type {ConstructorParameters<typeof Transform>[0]} */
+    static DEFAULT_TRANSFORM_OPTIONS: ConstructorParameters<typeof Transform>[0];
+    static FinalizeResponse(response: import("../data/custom-types.js").HttpResponse): void | null | boolean | Promise<void | null | boolean>;
+    static Execute(transaction: import("../lib/HttpTransaction.js").default<any>): import("../data/custom-types.js").MiddlewareFunctionResult;
+    execute: any;
+}
+export type HttpTransaction = import("../data/custom-types.js").HttpTransaction;
+export type MiddlewareFunction = import("../data/custom-types.js").MiddlewareFunction;
+export type ResponseFinalizer = import("../data/custom-types.js").ResponseFinalizer;
+import { Transform } from 'node:stream';
+//# sourceMappingURL=HeadMethodMiddleware.d.ts.map

package/types/middleware/HeadMethodMiddleware.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HeadMethodMiddleware.d.ts","sourceRoot":"","sources":["../../middleware/HeadMethodMiddleware.js"],"names":[],"mappings":"AAMA;IAKE,yDAAyD;IACzD,kCADW,qBAAqB,CAAC,OAAO,SAAS,CAAC,CAAC,CAAC,CAAC,CAInD;;;IAPA,aAAsD;CAuBzD;8BA/Ba,OAAO,yBAAyB,EAAE,eAAe;iCACjD,OAAO,yBAAyB,EAAE,kBAAkB;gCACpD,OAAO,yBAAyB,EAAE,iBAAiB;0BAEvC,aAAa"}

package/types/middleware/MethodMiddleware.d.ts

@@ -0,0 +1,40 @@
+/** @typedef {import('../data/custom-types.js').HttpTransaction} HttpTransaction */
+/** @typedef {import('../data/custom-types.js').MiddlewareFunction} MiddlewareFunction */
+/** @typedef {import('../data/custom-types.js').RequestMethod} RequestMethod */
+/** @typedef {RegExp|RequestMethod} MethodEntry */
+/**
+ * @typedef {Object} MethodMiddlewareOptions
+ * @prop {MethodEntry|MethodEntry[]} method
+ */
+export default class MethodMiddleware {
+    /** @type {Map<MethodEntry, MethodMiddleware>} */
+    static cache: Map<MethodEntry, MethodMiddleware>;
+    /**
+     * @param {RequestMethod} method
+     * @param {RegExp | string} input
+     * @return {boolean}
+     */
+    static test(method: RequestMethod, input: RegExp | string): boolean;
+    static CONNECT(transaction: import("../lib/HttpTransaction.js").default<any>): import("../data/custom-types.js").MiddlewareFunctionResult;
+    static DELETE(transaction: import("../lib/HttpTransaction.js").default<any>): import("../data/custom-types.js").MiddlewareFunctionResult;
+    static HEADORGET(transaction: import("../lib/HttpTransaction.js").default<any>): import("../data/custom-types.js").MiddlewareFunctionResult;
+    static GET(transaction: import("../lib/HttpTransaction.js").default<any>): import("../data/custom-types.js").MiddlewareFunctionResult;
+    static OPTIONS(transaction: import("../lib/HttpTransaction.js").default<any>): import("../data/custom-types.js").MiddlewareFunctionResult;
+    static HEAD(transaction: import("../lib/HttpTransaction.js").default<any>): import("../data/custom-types.js").MiddlewareFunctionResult;
+    static PATCH(transaction: import("../lib/HttpTransaction.js").default<any>): import("../data/custom-types.js").MiddlewareFunctionResult;
+    static POST(transaction: import("../lib/HttpTransaction.js").default<any>): import("../data/custom-types.js").MiddlewareFunctionResult;
+    static PUT(transaction: import("../lib/HttpTransaction.js").default<any>): import("../data/custom-types.js").MiddlewareFunctionResult;
+    static TRACE(transaction: import("../lib/HttpTransaction.js").default<any>): import("../data/custom-types.js").MiddlewareFunctionResult;
+    /** @param {MethodMiddlewareOptions|MethodEntry|MethodEntry[]} options */
+    constructor(options: MethodMiddlewareOptions | MethodEntry | MethodEntry[]);
+    method: MethodEntry[];
+    execute(transaction: import("../lib/HttpTransaction.js").default<any>): import("../data/custom-types.js").MiddlewareFunctionResult;
+}
+export type HttpTransaction = import("../data/custom-types.js").HttpTransaction;
+export type MiddlewareFunction = import("../data/custom-types.js").MiddlewareFunction;
+export type RequestMethod = import("../data/custom-types.js").RequestMethod;
+export type MethodEntry = RegExp | RequestMethod;
+export type MethodMiddlewareOptions = {
+    method: MethodEntry | MethodEntry[];
+};
+//# sourceMappingURL=MethodMiddleware.d.ts.map

package/types/middleware/MethodMiddleware.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MethodMiddleware.d.ts","sourceRoot":"","sources":["../../middleware/MethodMiddleware.js"],"names":[],"mappings":"AAAA,mFAAmF;AACnF,yFAAyF;AACzF,+EAA+E;AAE/E,kDAAkD;AAElD;;;GAGG;AAEH;IAYE,iDAAiD;IACjD,cADW,GAAG,CAAC,WAAW,EAAE,gBAAgB,CAAC,CACpB;IAEzB;;;;OAIG;IACH,oBAJW,aAAa,SACb,MAAM,GAAG,MAAM,GACd,OAAO,CAOlB;;;;;;;;;;;IAxBD,yEAAyE;IACzE,qBADY,uBAAuB,GAAC,WAAW,GAAC,WAAW,EAAE,EAS5D;IANG,sBAAqB;;CA8D1B;8BA7Ea,OAAO,yBAAyB,EAAE,eAAe;iCACjD,OAAO,yBAAyB,EAAE,kBAAkB;4BACpD,OAAO,yBAAyB,EAAE,aAAa;0BAE/C,MAAM,GAAC,aAAa;;YAIxB,WAAW,GAAC,WAAW,EAAE"}