@blueprint-ts/core 4.1.0-beta.1 → 4.1.0-beta.3

package/dist/requests/BaseRequest.d.ts

@@ -0,0 +1,62 @@
+import { RequestEvents } from './RequestEvents.enum';
+import { RequestMethodEnum } from './RequestMethod.enum';
+import { BaseResponse } from './responses/BaseResponse';
+import { type DriverConfigContract } from './contracts/DriverConfigContract';
+import { type BodyFactoryContract } from './contracts/BodyFactoryContract';
+import { type BodyContract } from './contracts/BodyContract';
+import { type RequestLoaderContract } from './contracts/RequestLoaderContract';
+import { type RequestDriverContract } from './contracts/RequestDriverContract';
+import { type RequestLoaderFactoryContract } from './contracts/RequestLoaderFactoryContract';
+import { type BaseRequestContract, type EventHandlerCallback } from './contracts/BaseRequestContract';
+import { type HeadersContract } from './contracts/HeadersContract';
+import { type ResponseContract } from './contracts/ResponseContract';
+import { type RequestConcurrencyOptions } from './types/RequestConcurrencyOptions';
+export declare abstract class BaseRequest<RequestLoaderLoadingType, ResponseErrorBody, ResponseBodyInterface = undefined, ResponseClass extends ResponseContract<ResponseBodyInterface> = BaseResponse<ResponseBodyInterface>, RequestBodyInterface = undefined, RequestParamsInterface extends object = object> implements BaseRequestContract<RequestLoaderLoadingType, RequestBodyInterface, ResponseClass, RequestParamsInterface> {
+    protected requestId: string;
+    protected params: RequestParamsInterface | undefined;
+    protected requestBody: RequestBodyInterface | undefined;
+    protected requestLoader: RequestLoaderContract<RequestLoaderLoadingType> | undefined;
+    protected abortSignal: AbortSignal | undefined;
+    protected concurrencyOptions: RequestConcurrencyOptions | undefined;
+    protected events: {
+        [key in RequestEvents]?: EventHandlerCallback[];
+    };
+    protected static defaultBaseUrl: string;
+    protected static requestDriver: RequestDriverContract;
+    protected static requestLoaderFactory: RequestLoaderFactoryContract<unknown>;
+    protected static concurrencySequenceByKey: Map<string, number>;
+    protected static concurrencyAbortControllerByKey: Map<string, AbortController>;
+    protected static concurrencyInFlightByKey: Map<string, number>;
+    constructor();
+    static setRequestDriver(driver: RequestDriverContract): void;
+    static setRequestLoaderFactory<T>(factory: RequestLoaderFactoryContract<T>): void;
+    static setDefaultBaseUrl(url: string): void;
+    setRequestLoader(loader: RequestLoaderContract<RequestLoaderLoadingType>): this;
+    setConcurrency(options?: RequestConcurrencyOptions): this;
+    getRequestId(): string;
+    abstract method(): RequestMethodEnum;
+    abstract url(): URL | string;
+    setParams(params?: RequestParamsInterface): this;
+    withParams(params: RequestParamsInterface): this;
+    getParams(): RequestParamsInterface | undefined;
+    setBody(requestBody: RequestBodyInterface): this;
+    getBody(): RequestBodyInterface | undefined;
+    requestHeaders(): HeadersContract;
+    buildUrl(): URL;
+    on<T>(event: RequestEvents, handler: EventHandlerCallback<T>): this;
+    protected dispatch<T>(event: RequestEvents, value: T): void;
+    send(): Promise<ResponseClass>;
+    isLoading(): RequestLoaderLoadingType;
+    abstract getResponse(): ResponseClass;
+    getRequestBodyFactory(): BodyFactoryContract<RequestBodyInterface | undefined> | undefined;
+    setAbortSignal(signal: AbortSignal): this;
+    protected bumpConcurrencySequence(key: string): number;
+    protected isLatestSequence(key: string, sequence: number): boolean;
+    protected incrementConcurrencyInFlight(key: string): void;
+    protected decrementConcurrencyInFlight(key: string): void;
+    protected baseUrl(): undefined;
+    protected buildRequestConfig(requestBody: BodyContract | undefined, concurrencyKey: string, sequence: number, useLatest: boolean): DriverConfigContract;
+    protected getConfig(): DriverConfigContract | undefined;
+    protected resolveRequestDriver(): RequestDriverContract;
+    protected getRequestDriver(): RequestDriverContract | undefined;
+}

package/dist/requests/BaseRequest.js

@@ -0,0 +1,224 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import qs from 'qs';
+import { ErrorHandler } from './ErrorHandler';
+import { RequestEvents } from './RequestEvents.enum';
+import { ResponseException } from './exceptions/ResponseException';
+import { StaleResponseException } from './exceptions/StaleResponseException';
+import { RequestConcurrencyMode } from './RequestConcurrencyMode.enum';
+import { mergeDeep } from '../support/helpers';
+import { v4 as uuidv4 } from 'uuid';
+export class BaseRequest {
+    constructor() {
+        this.requestId = uuidv4();
+        this.params = undefined;
+        this.requestBody = undefined;
+        this.requestLoader = undefined;
+        this.abortSignal = undefined;
+        this.concurrencyOptions = undefined;
+        /* @ts-expect-error Ignore generics */
+        this.events = {};
+        if (BaseRequest.requestLoaderFactory !== undefined) {
+            this.requestLoader = BaseRequest.requestLoaderFactory.make();
+        }
+    }
+    static setRequestDriver(driver) {
+        this.requestDriver = driver;
+    }
+    static setRequestLoaderFactory(factory) {
+        this.requestLoaderFactory = factory;
+    }
+    static setDefaultBaseUrl(url) {
+        this.defaultBaseUrl = url;
+    }
+    setRequestLoader(loader) {
+        this.requestLoader = loader;
+        return this;
+    }
+    setConcurrency(options) {
+        this.concurrencyOptions = options;
+        return this;
+    }
+    getRequestId() {
+        return this.requestId;
+    }
+    setParams(params) {
+        this.params = params;
+        return this;
+    }
+    withParams(params) {
+        this.params = this.params === undefined ? params : mergeDeep({}, this.params, params);
+        return this;
+    }
+    getParams() {
+        return this.params;
+    }
+    setBody(requestBody) {
+        this.requestBody = requestBody;
+        return this;
+    }
+    getBody() {
+        return this.requestBody;
+    }
+    requestHeaders() {
+        return {};
+    }
+    buildUrl() {
+        var _a;
+        const hasParams = this.params !== undefined && Object.keys(this.params).length > 0;
+        const url = hasParams ? this.url() + '?' + qs.stringify(this.params) : this.url();
+        return new URL(url, (_a = this.baseUrl()) !== null && _a !== void 0 ? _a : BaseRequest.defaultBaseUrl);
+    }
+    on(event, handler) {
+        if (!this.events[event]) {
+            this.events[event] = [];
+        }
+        this.events[event].push(handler);
+        return this;
+    }
+    dispatch(event, value) {
+        if (!this.events[event]) {
+            return;
+        }
+        this.events[event].forEach((handler) => handler(value));
+    }
+    send() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c, _d, _e, _f;
+            const concurrencyMode = (_b = (_a = this.concurrencyOptions) === null || _a === void 0 ? void 0 : _a.mode) !== null && _b !== void 0 ? _b : RequestConcurrencyMode.ALLOW;
+            const concurrencyKey = (_d = (_c = this.concurrencyOptions) === null || _c === void 0 ? void 0 : _c.key) !== null && _d !== void 0 ? _d : this.requestId;
+            const useReplace = concurrencyMode === RequestConcurrencyMode.REPLACE || concurrencyMode === RequestConcurrencyMode.REPLACE_LATEST;
+            const useLatest = concurrencyMode === RequestConcurrencyMode.LATEST || concurrencyMode === RequestConcurrencyMode.REPLACE_LATEST;
+            const sequence = this.bumpConcurrencySequence(concurrencyKey);
+            this.incrementConcurrencyInFlight(concurrencyKey);
+            if (useReplace) {
+                const previousController = BaseRequest.concurrencyAbortControllerByKey.get(concurrencyKey);
+                if (previousController) {
+                    previousController.abort();
+                }
+                const controller = new AbortController();
+                BaseRequest.concurrencyAbortControllerByKey.set(concurrencyKey, controller);
+                this.setAbortSignal(controller.signal);
+            }
+            this.dispatch(RequestEvents.LOADING, true);
+            (_e = this.requestLoader) === null || _e === void 0 ? void 0 : _e.setLoading(true);
+            const responseSkeleton = this.getResponse();
+            const requestBody = this.requestBody === undefined ? undefined : (_f = this.getRequestBodyFactory()) === null || _f === void 0 ? void 0 : _f.make(this.requestBody);
+            const requestConfig = this.buildRequestConfig(requestBody, concurrencyKey, sequence, useLatest);
+            return this.resolveRequestDriver()
+                .send(this.buildUrl(), this.method(), Object.assign({ Accept: responseSkeleton.getAcceptHeader() }, this.requestHeaders()), requestBody, requestConfig)
+                .then((responseHandler) => __awaiter(this, void 0, void 0, function* () {
+                if (useLatest && !this.isLatestSequence(concurrencyKey, sequence)) {
+                    throw new StaleResponseException();
+                }
+                yield responseSkeleton.setResponse(responseHandler);
+                return responseSkeleton;
+            }))
+                .catch((error) => __awaiter(this, void 0, void 0, function* () {
+                if (useLatest && !this.isLatestSequence(concurrencyKey, sequence)) {
+                    throw new StaleResponseException('Stale response ignored', error);
+                }
+                if (error instanceof StaleResponseException) {
+                    throw error;
+                }
+                if (error instanceof ResponseException) {
+                    const handler = new ErrorHandler(error.getResponse());
+                    yield handler.handle();
+                }
+                console.error('@blueprint-ts/core: Unknown error received.', error);
+                throw error;
+            }))
+                .finally(() => {
+                var _a;
+                const isStale = useLatest && !this.isLatestSequence(concurrencyKey, sequence);
+                if (!isStale) {
+                    this.dispatch(RequestEvents.LOADING, false);
+                    (_a = this.requestLoader) === null || _a === void 0 ? void 0 : _a.setLoading(false);
+                }
+                this.decrementConcurrencyInFlight(concurrencyKey);
+            });
+        });
+    }
+    isLoading() {
+        if (!this.requestLoader) {
+            throw new Error('Request loader is not set.');
+        }
+        return this.requestLoader.isLoading();
+    }
+    getRequestBodyFactory() {
+        return undefined;
+    }
+    setAbortSignal(signal) {
+        this.abortSignal = signal;
+        return this;
+    }
+    bumpConcurrencySequence(key) {
+        var _a;
+        const next = ((_a = BaseRequest.concurrencySequenceByKey.get(key)) !== null && _a !== void 0 ? _a : 0) + 1;
+        BaseRequest.concurrencySequenceByKey.set(key, next);
+        return next;
+    }
+    isLatestSequence(key, sequence) {
+        var _a;
+        return ((_a = BaseRequest.concurrencySequenceByKey.get(key)) !== null && _a !== void 0 ? _a : 0) === sequence;
+    }
+    incrementConcurrencyInFlight(key) {
+        var _a;
+        const next = ((_a = BaseRequest.concurrencyInFlightByKey.get(key)) !== null && _a !== void 0 ? _a : 0) + 1;
+        BaseRequest.concurrencyInFlightByKey.set(key, next);
+    }
+    decrementConcurrencyInFlight(key) {
+        const current = BaseRequest.concurrencyInFlightByKey.get(key);
+        if (current === undefined) {
+            return;
+        }
+        const next = current - 1;
+        if (next <= 0) {
+            BaseRequest.concurrencyInFlightByKey.delete(key);
+            BaseRequest.concurrencySequenceByKey.delete(key);
+            BaseRequest.concurrencyAbortControllerByKey.delete(key);
+            return;
+        }
+        BaseRequest.concurrencyInFlightByKey.set(key, next);
+    }
+    baseUrl() {
+        return undefined;
+    }
+    buildRequestConfig(requestBody, concurrencyKey, sequence, useLatest) {
+        var _a;
+        const config = (_a = this.getConfig()) !== null && _a !== void 0 ? _a : {};
+        const onUploadProgress = config.onUploadProgress;
+        if (requestBody === undefined) {
+            return config;
+        }
+        return Object.assign(Object.assign({}, config), { onUploadProgress: (progress) => {
+                onUploadProgress === null || onUploadProgress === void 0 ? void 0 : onUploadProgress(progress);
+                if (useLatest && !this.isLatestSequence(concurrencyKey, sequence)) {
+                    return;
+                }
+                this.dispatch(RequestEvents.UPLOAD_PROGRESS, progress);
+            } });
+    }
+    getConfig() {
+        return {
+            abortSignal: this.abortSignal
+        };
+    }
+    resolveRequestDriver() {
+        var _a;
+        return (_a = this.getRequestDriver()) !== null && _a !== void 0 ? _a : BaseRequest.requestDriver;
+    }
+    getRequestDriver() {
+        return undefined;
+    }
+}
+BaseRequest.concurrencySequenceByKey = new Map();
+BaseRequest.concurrencyAbortControllerByKey = new Map();
+BaseRequest.concurrencyInFlightByKey = new Map();

package/dist/requests/ErrorHandler.d.ts

@@ -0,0 +1,11 @@
+import { type ResponseHandlerContract } from './drivers/contracts/ResponseHandlerContract';
+export type ErrorHandlerCallback = ((response: ResponseHandlerContract) => boolean | void) | undefined;
+export declare class ErrorHandler<ResponseErrorBody> {
+    protected response: ResponseHandlerContract;
+    protected body: ResponseErrorBody | undefined;
+    protected static handler: ErrorHandlerCallback;
+    constructor(response: ResponseHandlerContract);
+    handle(): Promise<void>;
+    static registerHandler(callback: ErrorHandlerCallback): void;
+    protected handleResponseError(response: ResponseHandlerContract, body: ResponseErrorBody): void;
+}

package/dist/requests/ErrorHandler.js

@@ -0,0 +1,127 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { PageExpiredException } from './exceptions/PageExpiredException';
+import { NotFoundException } from './exceptions/NotFoundException';
+import { UnauthorizedException } from './exceptions/UnauthorizedException';
+import { ValidationException } from './exceptions/ValidationException';
+import { ResponseException } from './exceptions/ResponseException';
+import { NoResponseReceivedException } from './exceptions/NoResponseReceivedException';
+import { ServerErrorException } from './exceptions/ServerErrorException';
+import { ForbiddenException } from './exceptions/ForbiddenException';
+import { TooManyRequestsException } from './exceptions/TooManyRequestsException';
+import { LockedException } from './exceptions/LockedException';
+import { NotImplementedException } from './exceptions/NotImplementedException';
+import { ServiceUnavailableException } from './exceptions/ServiceUnavailableException';
+import { MethodNotAllowedException } from './exceptions/MethodNotAllowedException';
+import { RequestTimeoutException } from './exceptions/RequestTimeoutException';
+import { ConflictException } from './exceptions/ConflictException';
+import { GoneException } from './exceptions/GoneException';
+import { PreconditionFailedException } from './exceptions/PreconditionFailedException';
+import { PayloadTooLargeException } from './exceptions/PayloadTooLargeException';
+import { UnsupportedMediaTypeException } from './exceptions/UnsupportedMediaTypeException';
+import { BadGatewayException } from './exceptions/BadGatewayException';
+import { GatewayTimeoutException } from './exceptions/GatewayTimeoutException';
+import { BadRequestException } from './exceptions/BadRequestException';
+import { InvalidJsonException } from './exceptions/InvalidJsonException';
+export class ErrorHandler {
+    constructor(response) {
+        this.response = response;
+        this.body = undefined;
+    }
+    handle() {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Check if there is a global error handler set
+            if (ErrorHandler.handler !== undefined) {
+                // If handler returns false, we don't process the error further
+                if (ErrorHandler.handler(this.response) === false) {
+                    console.debug('Skipping further error handling due to global handler returning false.');
+                    return;
+                }
+            }
+            try {
+                this.body = yield this.response.json();
+            }
+            catch (error) {
+                throw new InvalidJsonException(this.response, error);
+            }
+            if (this.body === undefined) {
+                throw new NoResponseReceivedException(this.response);
+            }
+            this.handleResponseError(this.response, this.body);
+        });
+    }
+    static registerHandler(callback) {
+        ErrorHandler.handler = callback;
+    }
+    handleResponseError(response, body) {
+        if (response.getStatusCode() === 400) {
+            throw new BadRequestException(response, body);
+        }
+        if (response.getStatusCode() === 401) {
+            throw new UnauthorizedException(response, body);
+        }
+        if (response.getStatusCode() === 403) {
+            throw new ForbiddenException(response, body);
+        }
+        if (response.getStatusCode() === 404) {
+            throw new NotFoundException(response, body);
+        }
+        if (response.getStatusCode() === 405) {
+            throw new MethodNotAllowedException(response, body);
+        }
+        if (response.getStatusCode() === 408) {
+            throw new RequestTimeoutException(response, body);
+        }
+        if (response.getStatusCode() === 409) {
+            throw new ConflictException(response, body);
+        }
+        if (response.getStatusCode() === 410) {
+            throw new GoneException(response, body);
+        }
+        if (response.getStatusCode() === 412) {
+            throw new PreconditionFailedException(response, body);
+        }
+        if (response.getStatusCode() === 413) {
+            throw new PayloadTooLargeException(response, body);
+        }
+        if (response.getStatusCode() === 415) {
+            throw new UnsupportedMediaTypeException(response, body);
+        }
+        if (response.getStatusCode() === 419) {
+            throw new PageExpiredException(response, body);
+        }
+        if (response.getStatusCode() === 422) {
+            throw new ValidationException(response, body);
+        }
+        if (response.getStatusCode() === 423) {
+            throw new LockedException(response, body);
+        }
+        if (response.getStatusCode() === 429) {
+            throw new TooManyRequestsException(response, body);
+        }
+        if (response.getStatusCode() === 500) {
+            throw new ServerErrorException(response, body);
+        }
+        if (response.getStatusCode() === 501) {
+            throw new NotImplementedException(response, body);
+        }
+        if (response.getStatusCode() === 502) {
+            throw new BadGatewayException(response, body);
+        }
+        if (response.getStatusCode() === 503) {
+            throw new ServiceUnavailableException(response, body);
+        }
+        if (response.getStatusCode() === 504) {
+            throw new GatewayTimeoutException(response, body);
+        }
+        throw new ResponseException(response);
+    }
+}
+ErrorHandler.handler = undefined;

package/dist/requests/RequestConcurrencyMode.enum.d.ts

@@ -0,0 +1,6 @@
+export declare enum RequestConcurrencyMode {
+    ALLOW = "allow",
+    REPLACE = "replace",
+    LATEST = "latest",
+    REPLACE_LATEST = "replace-latest"
+}

package/dist/requests/RequestConcurrencyMode.enum.js

@@ -0,0 +1,7 @@
+export var RequestConcurrencyMode;
+(function (RequestConcurrencyMode) {
+    RequestConcurrencyMode["ALLOW"] = "allow";
+    RequestConcurrencyMode["REPLACE"] = "replace";
+    RequestConcurrencyMode["LATEST"] = "latest";
+    RequestConcurrencyMode["REPLACE_LATEST"] = "replace-latest";
+})(RequestConcurrencyMode || (RequestConcurrencyMode = {}));

package/dist/requests/RequestErrorRouter.d.ts

@@ -0,0 +1,38 @@
+import { BadRequestException } from './exceptions/BadRequestException';
+import { MethodNotAllowedException } from './exceptions/MethodNotAllowedException';
+import { RequestTimeoutException } from './exceptions/RequestTimeoutException';
+import { ConflictException } from './exceptions/ConflictException';
+import { GoneException } from './exceptions/GoneException';
+import { PreconditionFailedException } from './exceptions/PreconditionFailedException';
+import { PayloadTooLargeException } from './exceptions/PayloadTooLargeException';
+import { UnsupportedMediaTypeException } from './exceptions/UnsupportedMediaTypeException';
+import { ForbiddenException } from './exceptions/ForbiddenException';
+import { LockedException } from './exceptions/LockedException';
+import { NoResponseReceivedException } from './exceptions/NoResponseReceivedException';
+import { NotFoundException } from './exceptions/NotFoundException';
+import { NotImplementedException } from './exceptions/NotImplementedException';
+import { BadGatewayException } from './exceptions/BadGatewayException';
+import { PageExpiredException } from './exceptions/PageExpiredException';
+import { ResponseBodyException } from './exceptions/ResponseBodyException';
+import { ResponseException } from './exceptions/ResponseException';
+import { ServerErrorException } from './exceptions/ServerErrorException';
+import { ServiceUnavailableException } from './exceptions/ServiceUnavailableException';
+import { GatewayTimeoutException } from './exceptions/GatewayTimeoutException';
+import { TooManyRequestsException } from './exceptions/TooManyRequestsException';
+import { UnauthorizedException } from './exceptions/UnauthorizedException';
+import { ValidationException } from './exceptions/ValidationException';
+import { InvalidJsonException } from './exceptions/InvalidJsonException';
+type RequestExceptionConstructor = typeof BadRequestException | typeof MethodNotAllowedException | typeof RequestTimeoutException | typeof ConflictException | typeof GoneException | typeof PreconditionFailedException | typeof PayloadTooLargeException | typeof UnsupportedMediaTypeException | typeof UnauthorizedException | typeof ForbiddenException | typeof NotFoundException | typeof PageExpiredException | typeof ValidationException | typeof LockedException | typeof TooManyRequestsException | typeof ServerErrorException | typeof NotImplementedException | typeof BadGatewayException | typeof ServiceUnavailableException | typeof GatewayTimeoutException | typeof NoResponseReceivedException | typeof InvalidJsonException | typeof ResponseBodyException | typeof ResponseException;
+type ErrorHandlerCallback<T extends Error> = (error: T) => void | Promise<void>;
+type UnknownErrorHandlerCallback = (error: unknown) => void | Promise<void>;
+export declare class RequestErrorRouter {
+    protected handlers: Array<{
+        ctor: RequestExceptionConstructor;
+        handler: ErrorHandlerCallback<Error>;
+    }>;
+    protected defaultHandler: UnknownErrorHandlerCallback | undefined;
+    on<C extends RequestExceptionConstructor>(ctor: C, handler: ErrorHandlerCallback<InstanceType<C>>): this;
+    otherwise(handler: UnknownErrorHandlerCallback): this;
+    handle(error: unknown): Promise<boolean>;
+}
+export {};

package/dist/requests/RequestErrorRouter.js

@@ -0,0 +1,38 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+export class RequestErrorRouter {
+    constructor() {
+        this.handlers = [];
+        this.defaultHandler = undefined;
+    }
+    on(ctor, handler) {
+        this.handlers.push({ ctor, handler: handler });
+        return this;
+    }
+    otherwise(handler) {
+        this.defaultHandler = handler;
+        return this;
+    }
+    handle(error) {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (const entry of this.handlers) {
+                if (error instanceof entry.ctor) {
+                    yield entry.handler(error);
+                    return true;
+                }
+            }
+            if (this.defaultHandler !== undefined) {
+                yield this.defaultHandler(error);
+                return true;
+            }
+            return false;
+        });
+    }
+}

package/dist/requests/RequestEvents.enum.d.ts

@@ -0,0 +1,4 @@
+export declare enum RequestEvents {
+    LOADING = "loading",
+    UPLOAD_PROGRESS = "upload-progress"
+}

package/dist/requests/RequestEvents.enum.js

@@ -0,0 +1,5 @@
+export var RequestEvents;
+(function (RequestEvents) {
+    RequestEvents["LOADING"] = "loading";
+    RequestEvents["UPLOAD_PROGRESS"] = "upload-progress";
+})(RequestEvents || (RequestEvents = {}));

package/dist/requests/RequestMethod.enum.d.ts

@@ -0,0 +1,8 @@
+export declare enum RequestMethodEnum {
+    GET = "GET",
+    HEAD = "HEAD",
+    PATCH = "PATCH",
+    POST = "POST",
+    PUT = "PUT",
+    DELETE = "DELETE"
+}

package/dist/requests/RequestMethod.enum.js

@@ -0,0 +1,9 @@
+export var RequestMethodEnum;
+(function (RequestMethodEnum) {
+    RequestMethodEnum["GET"] = "GET";
+    RequestMethodEnum["HEAD"] = "HEAD";
+    RequestMethodEnum["PATCH"] = "PATCH";
+    RequestMethodEnum["POST"] = "POST";
+    RequestMethodEnum["PUT"] = "PUT";
+    RequestMethodEnum["DELETE"] = "DELETE";
+})(RequestMethodEnum || (RequestMethodEnum = {}));

package/dist/requests/bodies/BinaryBody.d.ts

@@ -0,0 +1,10 @@
+import { type BodyContent, type BodyContract } from '../contracts/BodyContract';
+import { type HeadersContract } from '../contracts/HeadersContract';
+export declare class BinaryBody<RequestBody extends Exclude<BodyContent, string | FormData>> implements BodyContract {
+    protected data: RequestBody;
+    protected contentType?: string | undefined;
+    constructor(data: RequestBody, contentType?: string | undefined);
+    getHeaders(): HeadersContract;
+    getContent(): RequestBody;
+    protected resolveContentType(): string | undefined;
+}

package/dist/requests/bodies/BinaryBody.js

@@ -0,0 +1,22 @@
+export class BinaryBody {
+    constructor(data, contentType) {
+        this.data = data;
+        this.contentType = contentType;
+    }
+    getHeaders() {
+        const contentType = this.resolveContentType();
+        return contentType === undefined ? {} : { 'Content-Type': contentType };
+    }
+    getContent() {
+        return this.data;
+    }
+    resolveContentType() {
+        if (this.contentType !== undefined) {
+            return this.contentType;
+        }
+        if (typeof Blob !== 'undefined' && this.data instanceof Blob && this.data.type !== '') {
+            return this.data.type;
+        }
+        return undefined;
+    }
+}

package/dist/requests/bodies/FormDataBody.d.ts

@@ -0,0 +1,14 @@
+import { type BodyContract } from '../contracts/BodyContract';
+import { type HeadersContract } from '../contracts/HeadersContract';
+type FormDataPrimitive = string | number | boolean | null | Date | Blob;
+type FormDataValue = FormDataPrimitive | FormDataValue[] | {
+    [key: string]: FormDataValue;
+};
+export declare class FormDataBody<RequestBody extends Record<string, FormDataValue | undefined>> implements BodyContract {
+    protected data: FormData;
+    constructor(data: RequestBody);
+    getContent(): FormData;
+    getHeaders(): HeadersContract;
+    protected toFormData(data: Record<string, FormDataValue | undefined>, form?: FormData, namespace?: string | null): FormData;
+}
+export {};