@blueprint-ts/core 4.1.0-beta.2 → 4.1.0-beta.4

package/dist/requests/bodies/FormDataBody.js

@@ -0,0 +1,60 @@
+import { isObject } from '../../support/helpers';
+export class FormDataBody {
+    constructor(data) {
+        this.data = this.toFormData(data);
+    }
+    getContent() {
+        return this.data;
+    }
+    getHeaders() {
+        return {};
+    }
+    toFormData(data, form = new FormData(), namespace = null) {
+        for (const property in data) {
+            if (Object.prototype.hasOwnProperty.call(data, property)) {
+                const formKey = namespace ? namespace + '[' + property + ']' : property;
+                const value = data[property];
+                // Null is a valid "explicitly empty" value in many APIs.
+                // In multipart FormData we encode it as an empty string so the key is still present.
+                if (value === null) {
+                    form.append(formKey, '');
+                    continue;
+                }
+                // Undefined values should not reach the request layer (BaseForm omits them).
+                // Reject explicitly to avoid silently dropping keys.
+                if (value === undefined) {
+                    throw new Error('Unexpected value');
+                }
+                if (value instanceof Date) {
+                    form.append(formKey, value.toISOString());
+                    continue;
+                }
+                // Support arrays via bracket notation: key[0], key[1], ...
+                if (Array.isArray(value)) {
+                    for (let i = 0; i < value.length; i++) {
+                        const indexed = { [String(i)]: value[i] };
+                        this.toFormData(indexed, form, formKey);
+                    }
+                    continue;
+                }
+                // Files/Blobs should be appended directly (File extends Blob)
+                if (typeof Blob !== 'undefined' && value instanceof Blob) {
+                    form.append(formKey, value);
+                    continue;
+                }
+                // if the property is an object, use recursivity.
+                if (isObject(value)) {
+                    this.toFormData(value, form, formKey);
+                    continue;
+                }
+                // Primitives: append as strings
+                if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
+                    form.append(formKey, String(value));
+                    continue;
+                }
+                throw new Error('Unexpected value');
+            }
+        }
+        return form;
+    }
+}

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

@@ -0,0 +1,8 @@
+import { type BodyContract } from '../contracts/BodyContract';
+import { type HeadersContract } from '../contracts/HeadersContract';
+export declare class JsonBody<RequestBody> implements BodyContract {
+    protected data: RequestBody;
+    constructor(data: RequestBody);
+    getHeaders(): HeadersContract;
+    getContent(): string;
+}

package/dist/requests/bodies/JsonBody.js

@@ -0,0 +1,13 @@
+export class JsonBody {
+    constructor(data) {
+        this.data = data;
+    }
+    getHeaders() {
+        return {
+            'Content-Type': 'application/json'
+        };
+    }
+    getContent() {
+        return JSON.stringify(this.data);
+    }
+}

package/{src/requests/contracts/AbortableRequestContract.ts → dist/requests/contracts/AbortableRequestContract.d.ts}

@@ -1,3 +1,3 @@
 export interface AbortableRequestContract {
-  setSignal(): void
+    setSignal(): void;
 }

package/dist/requests/contracts/AbortableRequestContract.js

@@ -0,0 +1 @@
+export {};

package/dist/requests/contracts/BaseRequestContract.d.ts

@@ -0,0 +1,33 @@
+import { RequestMethodEnum } from '../RequestMethod.enum';
+import { RequestEvents } from '../RequestEvents.enum';
+import { type BodyFactoryContract } from './BodyFactoryContract';
+import { type HeadersContract } from './HeadersContract';
+import { type RequestConcurrencyOptions } from '../types/RequestConcurrencyOptions';
+import { type ResponseHandlerContract } from '../drivers/contracts/ResponseHandlerContract';
+export type EventHandlerCallback<T> = (value: T) => void;
+export interface SendRequestOptions {
+    resolveBody?: boolean;
+}
+export interface BaseRequestContract<RequestLoaderLoadingType, RequestBodyInterface, ResponseClass, RequestParamsInterface extends object> {
+    method(): RequestMethodEnum;
+    url(): URL | string;
+    setParams(params?: RequestParamsInterface): this;
+    withParams(params?: RequestParamsInterface): this;
+    getParams(): RequestParamsInterface | undefined;
+    setBody(requestBody: RequestBodyInterface | undefined): this;
+    requestHeaders(): HeadersContract;
+    buildUrl(): URL;
+    on<T>(event: RequestEvents, handler: EventHandlerCallback<T>): this;
+    send(): Promise<ResponseClass>;
+    send(options: {
+        resolveBody?: true;
+    }): Promise<ResponseClass>;
+    send(options: {
+        resolveBody: false;
+    }): Promise<ResponseHandlerContract>;
+    isLoading(): RequestLoaderLoadingType;
+    getRequestBodyFactory(): BodyFactoryContract<RequestBodyInterface> | undefined;
+    getResponse(): ResponseClass;
+    setAbortSignal(signal: AbortSignal): this;
+    setConcurrency(options?: RequestConcurrencyOptions): this;
+}

package/dist/requests/contracts/BaseRequestContract.js

@@ -0,0 +1 @@
+export {};

package/dist/requests/contracts/BodyContract.d.ts

@@ -0,0 +1,6 @@
+import { type HeadersContract } from './HeadersContract';
+export type BodyContent = string | FormData | Blob | BufferSource;
+export interface BodyContract {
+    getContent(): BodyContent;
+    getHeaders(): HeadersContract;
+}

package/dist/requests/contracts/BodyContract.js

@@ -0,0 +1 @@
+export {};

package/dist/requests/contracts/BodyFactoryContract.d.ts

@@ -0,0 +1,4 @@
+import { type BodyContract } from './BodyContract';
+export interface BodyFactoryContract<RequestBodyInterface> {
+    make(body: RequestBodyInterface): BodyContract;
+}

package/dist/requests/contracts/BodyFactoryContract.js

@@ -0,0 +1 @@
+export {};

package/dist/requests/contracts/DriverConfigContract.d.ts

@@ -0,0 +1,8 @@
+import { type HeadersContract } from './HeadersContract';
+import { type RequestUploadProgress } from '../types/RequestUploadProgress';
+export interface DriverConfigContract {
+    corsWithCredentials?: boolean | undefined;
+    abortSignal?: AbortSignal | undefined;
+    headers?: HeadersContract | undefined;
+    onUploadProgress?: ((progress: RequestUploadProgress) => void) | undefined;
+}

package/dist/requests/contracts/DriverConfigContract.js

@@ -0,0 +1 @@
+export {};

package/dist/requests/contracts/HeadersContract.d.ts

@@ -0,0 +1,7 @@
+export type HeaderValue = string | (() => string);
+export interface HeadersContract {
+    [key: string]: HeaderValue;
+}
+export interface ResolvedHeadersContract {
+    [key: string]: string;
+}

package/dist/requests/contracts/HeadersContract.js

@@ -0,0 +1 @@
+export {};

package/dist/requests/contracts/RequestDriverContract.d.ts

@@ -0,0 +1,8 @@
+import { RequestMethodEnum } from '../RequestMethod.enum';
+import { type HeadersContract } from './HeadersContract';
+import { type BodyContract } from './BodyContract';
+import { type ResponseHandlerContract } from '../drivers/contracts/ResponseHandlerContract';
+import { type DriverConfigContract } from './DriverConfigContract';
+export interface RequestDriverContract {
+    send(url: URL | string, method: RequestMethodEnum, headers: HeadersContract, body?: BodyContract, requestConfig?: DriverConfigContract): Promise<ResponseHandlerContract>;
+}

package/dist/requests/contracts/RequestDriverContract.js

@@ -0,0 +1 @@
+export {};

package/dist/requests/contracts/RequestLoaderContract.d.ts

@@ -0,0 +1,4 @@
+export interface RequestLoaderContract<T> {
+    isLoading(): T;
+    setLoading(value: boolean): void;
+}

package/dist/requests/contracts/RequestLoaderContract.js

@@ -0,0 +1 @@
+export {};

package/{src/requests/contracts/RequestLoaderFactoryContract.ts → dist/requests/contracts/RequestLoaderFactoryContract.d.ts}

@@ -1,5 +1,4 @@
-import { type RequestLoaderContract } from './RequestLoaderContract'
-
+import { type RequestLoaderContract } from './RequestLoaderContract';
 export interface RequestLoaderFactoryContract<T> {
-  make(): RequestLoaderContract<T>
+    make(): RequestLoaderContract<T>;
 }

package/dist/requests/contracts/RequestLoaderFactoryContract.js

@@ -0,0 +1 @@
+export {};

package/dist/requests/contracts/ResponseContract.d.ts

@@ -0,0 +1,5 @@
+import type { ResponseHandlerContract } from '../drivers/contracts/ResponseHandlerContract';
+export interface ResponseContract<ResponseBodyInterface> {
+    getAcceptHeader(): string;
+    setResponse(response: ResponseHandlerContract): Promise<ResponseBodyInterface>;
+}

package/dist/requests/contracts/ResponseContract.js

@@ -0,0 +1 @@
+export {};

package/dist/requests/drivers/contracts/ResponseHandlerContract.d.ts

@@ -0,0 +1,9 @@
+import { type ResolvedHeadersContract } from '../../contracts/HeadersContract';
+export interface ResponseHandlerContract {
+    getStatusCode(): number | undefined;
+    getHeaders(): ResolvedHeadersContract;
+    getRawResponse(): Response;
+    json<ResponseBodyInterface>(): Promise<ResponseBodyInterface>;
+    text(): Promise<string>;
+    blob(): Promise<Blob>;
+}

package/dist/requests/drivers/contracts/ResponseHandlerContract.js

@@ -0,0 +1 @@
+export {};

package/dist/requests/drivers/fetch/FetchDriver.d.ts

@@ -0,0 +1,26 @@
+import { RequestMethodEnum } from '../../RequestMethod.enum';
+import { type HeadersContract } from '../../contracts/HeadersContract';
+import { type BodyContent, type BodyContract } from '../../contracts/BodyContract';
+import { type RequestDriverContract } from '../../contracts/RequestDriverContract';
+import { type DriverConfigContract } from '../../contracts/DriverConfigContract';
+import { type ResponseHandlerContract } from '../contracts/ResponseHandlerContract';
+declare enum FetchDriverCredentialConfigEnum {
+    OMIT = "omit",
+    INCLUDE = "include"
+}
+interface FetchDriverConfig {
+    method: RequestMethodEnum;
+    headers: HeadersContract;
+    credentials?: FetchDriverCredentialConfigEnum | undefined;
+    signal?: AbortSignal | undefined;
+    body?: BodyContent | URLSearchParams | undefined;
+}
+export declare class FetchDriver implements RequestDriverContract {
+    protected config?: DriverConfigContract | undefined;
+    constructor(config?: DriverConfigContract | undefined);
+    send(url: URL | string, method: RequestMethodEnum, headers: HeadersContract, body?: BodyContract, requestConfig?: DriverConfigContract): Promise<ResponseHandlerContract>;
+    protected buildRequestConfig(config: DriverConfigContract, method: RequestMethodEnum, headers: HeadersContract, body?: BodyContract): FetchDriverConfig;
+    protected getCorsWithCredentials(corsWithCredentials: boolean | undefined): FetchDriverCredentialConfigEnum;
+    protected resolveHeaders(headers: HeadersContract): HeadersContract;
+}
+export {};

package/dist/requests/drivers/fetch/FetchDriver.js

@@ -0,0 +1,73 @@
+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 { ResponseException } from '../../exceptions/ResponseException';
+import { FetchResponse } from './FetchResponse';
+import { RequestMethodEnum } from '../../RequestMethod.enum';
+var FetchDriverCredentialConfigEnum;
+(function (FetchDriverCredentialConfigEnum) {
+    FetchDriverCredentialConfigEnum["OMIT"] = "omit";
+    FetchDriverCredentialConfigEnum["INCLUDE"] = "include";
+})(FetchDriverCredentialConfigEnum || (FetchDriverCredentialConfigEnum = {}));
+export class FetchDriver {
+    constructor(config) {
+        this.config = config;
+    }
+    send(url, method, headers, body, requestConfig) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const mergedConfig = Object.assign(Object.assign({}, this.config), (requestConfig !== null && requestConfig !== void 0 ? requestConfig : {}));
+            const mergedHeaders = Object.assign(Object.assign(Object.assign({}, (_a = this.config) === null || _a === void 0 ? void 0 : _a.headers), headers), body === null || body === void 0 ? void 0 : body.getHeaders());
+            const resolvedHeaders = this.resolveHeaders(mergedHeaders);
+            const fetchConfig = this.buildRequestConfig(mergedConfig, method, resolvedHeaders, body);
+            const response = yield fetch(url, fetchConfig);
+            const fetchResponse = new FetchResponse(response);
+            if (!response.ok) {
+                throw new ResponseException(fetchResponse);
+            }
+            return fetchResponse;
+        });
+    }
+    buildRequestConfig(config, method, headers, body) {
+        var _a;
+        return {
+            method: method,
+            headers: headers,
+            credentials: this.getCorsWithCredentials(config.corsWithCredentials),
+            signal: (_a = config.abortSignal) !== null && _a !== void 0 ? _a : undefined,
+            body: [RequestMethodEnum.GET, RequestMethodEnum.HEAD].includes(method) ? undefined : body === null || body === void 0 ? void 0 : body.getContent()
+        };
+    }
+    getCorsWithCredentials(corsWithCredentials) {
+        // Request takes precedence
+        if (corsWithCredentials === true) {
+            return FetchDriverCredentialConfigEnum.INCLUDE;
+        }
+        if (corsWithCredentials === false) {
+            return FetchDriverCredentialConfigEnum.OMIT;
+        }
+        // Fallback to default config
+        if (this.config) {
+            return this.config.corsWithCredentials ? FetchDriverCredentialConfigEnum.INCLUDE : FetchDriverCredentialConfigEnum.OMIT;
+        }
+        // Fallback to safe option if no default set
+        return FetchDriverCredentialConfigEnum.OMIT;
+    }
+    resolveHeaders(headers) {
+        const resolved = {};
+        for (const key in headers) {
+            const value = headers[key];
+            if (value === undefined) {
+                continue;
+            }
+            resolved[key] = typeof value === 'function' ? value() : value;
+        }
+        return resolved;
+    }
+}

package/dist/requests/drivers/fetch/FetchResponse.d.ts

@@ -0,0 +1,12 @@
+import { type ResolvedHeadersContract } from '../../contracts/HeadersContract';
+import { type ResponseHandlerContract } from '../contracts/ResponseHandlerContract';
+export declare class FetchResponse implements ResponseHandlerContract {
+    protected response: Response;
+    constructor(response: Response);
+    getStatusCode(): number | undefined;
+    getHeaders(): ResolvedHeadersContract;
+    getRawResponse(): Response;
+    json<ResponseBodyInterface>(): Promise<ResponseBodyInterface>;
+    text(): Promise<string>;
+    blob(): Promise<Blob>;
+}

package/dist/requests/drivers/fetch/FetchResponse.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 FetchResponse {
+    constructor(response) {
+        this.response = response;
+    }
+    getStatusCode() {
+        return this.response.status;
+    }
+    getHeaders() {
+        return Object.fromEntries(this.response.headers);
+    }
+    getRawResponse() {
+        return this.response;
+    }
+    json() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.response.json();
+        });
+    }
+    text() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.response.text();
+        });
+    }
+    blob() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.response.blob();
+        });
+    }
+}

package/dist/requests/drivers/xhr/XMLHttpRequestDriver.d.ts

@@ -0,0 +1,13 @@
+import { RequestMethodEnum } from '../../RequestMethod.enum';
+import { type HeadersContract } from '../../contracts/HeadersContract';
+import { type BodyContract } from '../../contracts/BodyContract';
+import { type RequestDriverContract } from '../../contracts/RequestDriverContract';
+import { type DriverConfigContract } from '../../contracts/DriverConfigContract';
+import { type ResponseHandlerContract } from '../contracts/ResponseHandlerContract';
+export declare class XMLHttpRequestDriver implements RequestDriverContract {
+    protected config?: DriverConfigContract | undefined;
+    constructor(config?: DriverConfigContract | undefined);
+    send(url: URL | string, method: RequestMethodEnum, headers: HeadersContract, body?: BodyContract, requestConfig?: DriverConfigContract): Promise<ResponseHandlerContract>;
+    protected getCorsWithCredentials(corsWithCredentials: boolean | undefined): boolean;
+    protected resolveHeaders(headers: HeadersContract): HeadersContract;
+}

package/dist/requests/drivers/xhr/XMLHttpRequestDriver.js

@@ -0,0 +1,107 @@
+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 { ResponseException } from '../../exceptions/ResponseException';
+import { RequestMethodEnum } from '../../RequestMethod.enum';
+import { XMLHttpRequestResponse } from './XMLHttpRequestResponse';
+export class XMLHttpRequestDriver {
+    constructor(config) {
+        this.config = config;
+    }
+    send(url, method, headers, body, requestConfig) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const mergedConfig = Object.assign(Object.assign({}, this.config), (requestConfig !== null && requestConfig !== void 0 ? requestConfig : {}));
+            const mergedHeaders = Object.assign(Object.assign(Object.assign({}, (_a = this.config) === null || _a === void 0 ? void 0 : _a.headers), headers), body === null || body === void 0 ? void 0 : body.getHeaders());
+            const resolvedHeaders = this.resolveHeaders(mergedHeaders);
+            return yield new Promise((resolve, reject) => {
+                const request = new XMLHttpRequest();
+                const requestUrl = url instanceof URL ? url.toString() : url;
+                const requestBody = [RequestMethodEnum.GET, RequestMethodEnum.HEAD].includes(method) ? undefined : body === null || body === void 0 ? void 0 : body.getContent();
+                const abortSignal = mergedConfig.abortSignal;
+                const handleAbortSignal = () => request.abort();
+                const cleanup = () => {
+                    request.onload = null;
+                    request.onerror = null;
+                    request.onabort = null;
+                    if (request.upload) {
+                        request.upload.onprogress = null;
+                    }
+                    abortSignal === null || abortSignal === void 0 ? void 0 : abortSignal.removeEventListener('abort', handleAbortSignal);
+                };
+                request.open(method, requestUrl, true);
+                request.responseType = 'blob';
+                request.withCredentials = this.getCorsWithCredentials(mergedConfig.corsWithCredentials);
+                for (const key in resolvedHeaders) {
+                    request.setRequestHeader(key, resolvedHeaders[key]);
+                }
+                request.onload = () => {
+                    cleanup();
+                    if (request.status === 0) {
+                        reject(new Error('No response received.'));
+                        return;
+                    }
+                    const response = new XMLHttpRequestResponse(request);
+                    if (request.status < 200 || request.status >= 300) {
+                        reject(new ResponseException(response));
+                        return;
+                    }
+                    resolve(response);
+                };
+                request.onerror = () => {
+                    cleanup();
+                    reject(new Error('Network request failed.'));
+                };
+                request.onabort = () => {
+                    cleanup();
+                    reject(new DOMException('The operation was aborted.', 'AbortError'));
+                };
+                if (request.upload) {
+                    request.upload.onprogress = (event) => {
+                        var _a;
+                        const total = event.lengthComputable ? event.total : undefined;
+                        (_a = mergedConfig.onUploadProgress) === null || _a === void 0 ? void 0 : _a.call(mergedConfig, {
+                            loaded: event.loaded,
+                            total: total,
+                            lengthComputable: event.lengthComputable,
+                            progress: total === undefined || total === 0 ? undefined : event.loaded / total
+                        });
+                    };
+                }
+                if (abortSignal === null || abortSignal === void 0 ? void 0 : abortSignal.aborted) {
+                    handleAbortSignal();
+                    return;
+                }
+                abortSignal === null || abortSignal === void 0 ? void 0 : abortSignal.addEventListener('abort', handleAbortSignal, { once: true });
+                request.send(requestBody);
+            });
+        });
+    }
+    getCorsWithCredentials(corsWithCredentials) {
+        var _a, _b;
+        if (corsWithCredentials === true) {
+            return true;
+        }
+        if (corsWithCredentials === false) {
+            return false;
+        }
+        return (_b = (_a = this.config) === null || _a === void 0 ? void 0 : _a.corsWithCredentials) !== null && _b !== void 0 ? _b : false;
+    }
+    resolveHeaders(headers) {
+        const resolved = {};
+        for (const key in headers) {
+            const value = headers[key];
+            if (value === undefined) {
+                continue;
+            }
+            resolved[key] = typeof value === 'function' ? value() : value;
+        }
+        return resolved;
+    }
+}

package/dist/requests/drivers/xhr/XMLHttpRequestResponse.d.ts

@@ -0,0 +1,17 @@
+import { type ResolvedHeadersContract } from '../../contracts/HeadersContract';
+import { type ResponseHandlerContract } from '../contracts/ResponseHandlerContract';
+export declare class XMLHttpRequestResponse implements ResponseHandlerContract {
+    protected request: XMLHttpRequest;
+    protected response: Response;
+    protected headers: ResolvedHeadersContract;
+    constructor(request: XMLHttpRequest);
+    getStatusCode(): number | undefined;
+    getHeaders(): ResolvedHeadersContract;
+    getRawResponse(): Response;
+    json<ResponseBodyInterface>(): Promise<ResponseBodyInterface>;
+    text(): Promise<string>;
+    blob(): Promise<Blob>;
+    protected getResponseBody(): Blob | string | null;
+    protected isBlobLike(value: unknown): value is Blob;
+    protected parseHeaders(rawHeaders: string): ResolvedHeadersContract;
+}

package/dist/requests/drivers/xhr/XMLHttpRequestResponse.js

@@ -0,0 +1,84 @@
+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 XMLHttpRequestResponse {
+    constructor(request) {
+        this.request = request;
+        this.headers = this.parseHeaders(request.getAllResponseHeaders());
+        this.response = new Response(this.getResponseBody(), {
+            status: request.status,
+            statusText: request.statusText,
+            headers: this.headers
+        });
+    }
+    getStatusCode() {
+        return this.request.status;
+    }
+    getHeaders() {
+        return this.headers;
+    }
+    getRawResponse() {
+        return this.response;
+    }
+    json() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.response.json();
+        });
+    }
+    text() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.response.text();
+        });
+    }
+    blob() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.response.blob();
+        });
+    }
+    getResponseBody() {
+        if ([204, 205, 304].includes(this.request.status)) {
+            return null;
+        }
+        if (this.request.response === null || this.request.response === undefined) {
+            return null;
+        }
+        if (this.isBlobLike(this.request.response) || typeof this.request.response === 'string') {
+            return this.request.response;
+        }
+        return new Blob([this.request.response]);
+    }
+    isBlobLike(value) {
+        return (value instanceof Blob ||
+            (typeof value === 'object' &&
+                value !== null &&
+                typeof value.arrayBuffer === 'function' &&
+                typeof value.stream === 'function' &&
+                typeof value.text === 'function'));
+    }
+    parseHeaders(rawHeaders) {
+        const headers = {};
+        const lines = rawHeaders.trim();
+        if (lines.length === 0) {
+            return headers;
+        }
+        for (const line of lines.split(/\r?\n/)) {
+            const separatorIndex = line.indexOf(':');
+            if (separatorIndex === -1) {
+                continue;
+            }
+            const key = line.slice(0, separatorIndex).trim();
+            const value = line.slice(separatorIndex + 1).trim();
+            if (key.length === 0) {
+                continue;
+            }
+            headers[key] = key in headers ? `${String(headers[key])}, ${value}` : value;
+        }
+        return headers;
+    }
+}

package/dist/requests/exceptions/BadGatewayException.d.ts

@@ -0,0 +1,3 @@
+import { ResponseBodyException } from './ResponseBodyException';
+export declare class BadGatewayException<ResponseErrorBody> extends ResponseBodyException<ResponseErrorBody> {
+}

package/dist/requests/exceptions/BadGatewayException.js

@@ -0,0 +1,3 @@
+import { ResponseBodyException } from './ResponseBodyException';
+export class BadGatewayException extends ResponseBodyException {
+}

package/dist/requests/exceptions/BadRequestException.d.ts

@@ -0,0 +1,3 @@
+import { ResponseBodyException } from './ResponseBodyException';
+export declare class BadRequestException<ResponseErrorBody> extends ResponseBodyException<ResponseErrorBody> {
+}

package/dist/requests/exceptions/BadRequestException.js

@@ -0,0 +1,3 @@
+import { ResponseBodyException } from './ResponseBodyException';
+export class BadRequestException extends ResponseBodyException {
+}

package/dist/requests/exceptions/ConflictException.d.ts

@@ -0,0 +1,3 @@
+import { ResponseBodyException } from './ResponseBodyException';
+export declare class ConflictException<ResponseErrorBody> extends ResponseBodyException<ResponseErrorBody> {
+}

package/dist/requests/exceptions/ConflictException.js

@@ -0,0 +1,3 @@
+import { ResponseBodyException } from './ResponseBodyException';
+export class ConflictException extends ResponseBodyException {
+}