@blueprint-ts/core 4.1.0-beta.6 → 5.0.0

package/dist/requests/BaseRequest.js

@@ -1,12 +1,3 @@
-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';
@@ -16,17 +7,23 @@ import { RequestConcurrencyMode } from './RequestConcurrencyMode.enum';
 import { mergeDeep } from '../support/helpers';
 import { v4 as uuidv4 } from 'uuid';
 export class BaseRequest {
+    requestId = uuidv4();
+    params = undefined;
+    requestBody = undefined;
+    requestLoader = undefined;
+    abortSignal = undefined;
+    concurrencyOptions = undefined;
+    additionalHeaders = {};
+    instanceRequestDriver = undefined;
+    /* @ts-expect-error Ignore generics */
+    events = {};
+    static defaultBaseUrl;
+    static requestDriver;
+    static requestLoaderFactory;
+    static concurrencySequenceByKey = new Map();
+    static concurrencyAbortControllerByKey = new Map();
+    static concurrencyInFlightByKey = new Map();
     constructor() {
-        this.requestId = uuidv4();
-        this.params = undefined;
-        this.requestBody = undefined;
-        this.requestLoader = undefined;
-        this.abortSignal = undefined;
-        this.concurrencyOptions = undefined;
-        this.additionalHeaders = {};
-        this.instanceRequestDriver = undefined;
-        /* @ts-expect-error Ignore generics */
-        this.events = {};
         if (BaseRequest.requestLoaderFactory !== undefined) {
             this.requestLoader = BaseRequest.requestLoaderFactory.make();
         }
@@ -71,7 +68,10 @@ export class BaseRequest {
         return this;
     }
     setHeaders(headers) {
-        this.additionalHeaders = Object.assign(Object.assign({}, this.additionalHeaders), headers);
+        this.additionalHeaders = {
+            ...this.additionalHeaders,
+            ...headers
+        };
         return this;
     }
     getBody() {
@@ -81,10 +81,9 @@ export class BaseRequest {
         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);
+        return new URL(url, this.baseUrl() ?? BaseRequest.defaultBaseUrl);
     }
     on(event, handler) {
         if (!this.events[event]) {
@@ -99,72 +98,71 @@ export class BaseRequest {
         }
         this.events[event].forEach((handler) => handler(value));
     }
-    send() {
-        return __awaiter(this, arguments, void 0, function* (options = {}) {
-            var _a, _b, _c, _d, _e, _f;
-            const responseSkeleton = this.getResponse();
-            const acceptHeader = responseSkeleton.getAcceptHeader();
-            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);
+    async send(options = {}) {
+        const responseSkeleton = this.getResponse();
+        const acceptHeader = responseSkeleton.getAcceptHeader();
+        const concurrencyMode = this.concurrencyOptions?.mode ?? RequestConcurrencyMode.ALLOW;
+        const concurrencyKey = this.concurrencyOptions?.key ?? 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();
             }
-            this.dispatch(RequestEvents.LOADING, true);
-            (_e = this.requestLoader) === null || _e === void 0 ? void 0 : _e.setLoading(true);
-            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);
-            const responseHandler = yield this.resolveRequestDriver()
-                .send(this.buildUrl(), this.method(), Object.assign(Object.assign({ Accept: acceptHeader }, this.requestHeaders()), this.additionalHeaders), requestBody, requestConfig)
-                .then((driverResponseHandler) => __awaiter(this, void 0, void 0, function* () {
-                var _a;
-                if (useLatest && !this.isLatestSequence(concurrencyKey, sequence)) {
-                    throw new StaleResponseException();
-                }
-                if (((_a = driverResponseHandler.getStatusCode()) !== null && _a !== void 0 ? _a : 0) >= 400) {
-                    const handler = new ErrorHandler(driverResponseHandler);
-                    yield handler.handle();
-                }
-                return driverResponseHandler;
-            }))
-                .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);
+            const controller = new AbortController();
+            BaseRequest.concurrencyAbortControllerByKey.set(concurrencyKey, controller);
+            this.setAbortSignal(controller.signal);
+        }
+        this.dispatch(RequestEvents.LOADING, true);
+        this.requestLoader?.setLoading(true);
+        const requestBody = this.requestBody === undefined ? undefined : this.getRequestBodyFactory()?.make(this.requestBody);
+        const requestConfig = this.buildRequestConfig(requestBody, concurrencyKey, sequence, useLatest);
+        const responseHandler = await this.resolveRequestDriver()
+            .send(this.buildUrl(), this.method(), {
+            Accept: acceptHeader,
+            ...this.requestHeaders(),
+            ...this.additionalHeaders
+        }, requestBody, requestConfig)
+            .then(async (driverResponseHandler) => {
+            if (useLatest && !this.isLatestSequence(concurrencyKey, sequence)) {
+                throw new StaleResponseException();
+            }
+            if ((driverResponseHandler.getStatusCode() ?? 0) >= 400) {
+                const handler = new ErrorHandler(driverResponseHandler);
+                await handler.handle();
+            }
+            return driverResponseHandler;
+        })
+            .catch(async (error) => {
+            if (useLatest && !this.isLatestSequence(concurrencyKey, sequence)) {
+                throw new StaleResponseException('Stale response ignored', error);
+            }
+            if (error instanceof StaleResponseException) {
                 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);
-            });
-            if (options.resolveBody === false) {
-                return responseHandler;
             }
-            yield responseSkeleton.setResponse(responseHandler);
-            return responseSkeleton;
+            if (error instanceof ResponseException) {
+                const handler = new ErrorHandler(error.getResponse());
+                await handler.handle();
+            }
+            console.error('@blueprint-ts/core: Unknown error received.', error);
+            throw error;
+        })
+            .finally(() => {
+            const isStale = useLatest && !this.isLatestSequence(concurrencyKey, sequence);
+            if (!isStale) {
+                this.dispatch(RequestEvents.LOADING, false);
+                this.requestLoader?.setLoading(false);
+            }
+            this.decrementConcurrencyInFlight(concurrencyKey);
         });
+        if (options.resolveBody === false) {
+            return responseHandler;
+        }
+        await responseSkeleton.setResponse(responseHandler);
+        return responseSkeleton;
     }
     isLoading() {
         if (!this.requestLoader) {
@@ -180,18 +178,15 @@ export class BaseRequest {
         return this;
     }
     bumpConcurrencySequence(key) {
-        var _a;
-        const next = ((_a = BaseRequest.concurrencySequenceByKey.get(key)) !== null && _a !== void 0 ? _a : 0) + 1;
+        const next = (BaseRequest.concurrencySequenceByKey.get(key) ?? 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;
+        return (BaseRequest.concurrencySequenceByKey.get(key) ?? 0) === sequence;
     }
     incrementConcurrencyInFlight(key) {
-        var _a;
-        const next = ((_a = BaseRequest.concurrencyInFlightByKey.get(key)) !== null && _a !== void 0 ? _a : 0) + 1;
+        const next = (BaseRequest.concurrencyInFlightByKey.get(key) ?? 0) + 1;
         BaseRequest.concurrencyInFlightByKey.set(key, next);
     }
     decrementConcurrencyInFlight(key) {
@@ -212,19 +207,21 @@ export class BaseRequest {
         return undefined;
     }
     buildRequestConfig(requestBody, concurrencyKey, sequence, useLatest) {
-        var _a;
-        const config = (_a = this.getConfig()) !== null && _a !== void 0 ? _a : {};
+        const config = this.getConfig() ?? {};
         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);
+        return {
+            ...config,
+            onUploadProgress: (progress) => {
+                onUploadProgress?.(progress);
                 if (useLatest && !this.isLatestSequence(concurrencyKey, sequence)) {
                     return;
                 }
                 this.dispatch(RequestEvents.UPLOAD_PROGRESS, progress);
-            } });
+            }
+        };
     }
     getConfig() {
         return {
@@ -232,13 +229,9 @@ export class BaseRequest {
         };
     }
     resolveRequestDriver() {
-        var _a, _b;
-        return (_b = (_a = this.instanceRequestDriver) !== null && _a !== void 0 ? _a : this.getRequestDriver()) !== null && _b !== void 0 ? _b : BaseRequest.requestDriver;
+        return this.instanceRequestDriver ?? this.getRequestDriver() ?? BaseRequest.requestDriver;
     }
     getRequestDriver() {
         return undefined;
     }
 }
-BaseRequest.concurrencySequenceByKey = new Map();
-BaseRequest.concurrencyAbortControllerByKey = new Map();
-BaseRequest.concurrencyInFlightByKey = new Map();

package/dist/requests/ErrorHandler.js

@@ -1,12 +1,3 @@
-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';
@@ -31,31 +22,31 @@ import { GatewayTimeoutException } from './exceptions/GatewayTimeoutException';
 import { BadRequestException } from './exceptions/BadRequestException';
 import { InvalidJsonException } from './exceptions/InvalidJsonException';
 export class ErrorHandler {
+    response;
+    body = undefined;
+    static handler = undefined;
     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;
-                }
+    async handle() {
+        // 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);
-        });
+        }
+        try {
+            this.body = await 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;
@@ -124,4 +115,3 @@ export class ErrorHandler {
         throw new ResponseException(response);
     }
 }
-ErrorHandler.handler = undefined;

package/dist/requests/RequestErrorRouter.js

@@ -1,17 +1,6 @@
-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;
-    }
+    handlers = [];
+    defaultHandler = undefined;
     on(ctor, handler) {
         this.handlers.push({ ctor, handler: handler });
         return this;
@@ -20,19 +9,17 @@ export class RequestErrorRouter {
         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);
+    async handle(error) {
+        for (const entry of this.handlers) {
+            if (error instanceof entry.ctor) {
+                await entry.handler(error);
                 return true;
             }
-            return false;
-        });
+        }
+        if (this.defaultHandler !== undefined) {
+            await this.defaultHandler(error);
+            return true;
+        }
+        return false;
     }
 }

package/dist/requests/bodies/BinaryBody.js

@@ -1,4 +1,6 @@
 export class BinaryBody {
+    data;
+    contentType;
     constructor(data, contentType) {
         this.data = data;
         this.contentType = contentType;

package/dist/requests/bodies/FormDataBody.js

@@ -1,5 +1,6 @@
 import { isObject } from '../../support/helpers';
 export class FormDataBody {
+    data;
     constructor(data) {
         this.data = this.toFormData(data);
     }

package/dist/requests/bodies/JsonBody.js

@@ -1,4 +1,5 @@
 export class JsonBody {
+    data;
     constructor(data) {
         this.data = data;
     }

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

@@ -1,12 +1,3 @@
-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';
@@ -16,32 +7,41 @@ var FetchDriverCredentialConfigEnum;
     FetchDriverCredentialConfigEnum["INCLUDE"] = "include";
 })(FetchDriverCredentialConfigEnum || (FetchDriverCredentialConfigEnum = {}));
 export class FetchDriver {
+    config;
     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;
-        });
+    async send(url, method, headers, body, requestConfig) {
+        const mergedConfig = {
+            // Global config
+            ...this.config,
+            // Request specific overrides
+            ...(requestConfig ?? {})
+        };
+        const mergedHeaders = {
+            // Set global headers
+            ...this.config?.headers,
+            // Set headers from the request
+            ...headers,
+            // Set Content-Type header
+            ...body?.getHeaders()
+        };
+        const resolvedHeaders = this.resolveHeaders(mergedHeaders);
+        const fetchConfig = this.buildRequestConfig(mergedConfig, method, resolvedHeaders, body);
+        const response = await 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()
+            signal: config.abortSignal ?? undefined,
+            body: [RequestMethodEnum.GET, RequestMethodEnum.HEAD].includes(method) ? undefined : body?.getContent()
         };
     }
     getCorsWithCredentials(corsWithCredentials) {

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

@@ -1,13 +1,5 @@
-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 {
+    response;
     constructor(response) {
         this.response = response;
     }
@@ -20,19 +12,13 @@ export class FetchResponse {
     getRawResponse() {
         return this.response;
     }
-    json() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return yield this.response.json();
-        });
+    async json() {
+        return await this.response.json();
     }
-    text() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return yield this.response.text();
-        });
+    async text() {
+        return await this.response.text();
     }
-    blob() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return yield this.response.blob();
-        });
+    async blob() {
+        return await this.response.blob();
     }
 }