angular-toolbox 0.10.2 → 0.11.1

package/README.md

@@ -2,7 +2,7 @@
 
 A library that provides useful tools for Angular apps development.
 
-[![Angular Toolbox version](https://img.shields.io/badge/Angular%20Toolbox-beta:.0.10.2-%231E90FF.svg)]()
+[![Angular Toolbox version](https://img.shields.io/badge/Angular%20Toolbox-beta:.0.11.1-%231E90FF.svg)]()
 
 ## License
 

package/esm2022/lib/framework/mock/http/config/route-mock-config.mjs

@@ -6,4 +6,4 @@
  * the LICENSE file at https://pascalechemann.com/angular-toolbox/resources/license
  */
 export {};
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicm91dGUtbW9jay1jb25maWcuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9hbmd1bGFyLXRvb2xib3gvc3JjL2xpYi9mcmFtZXdvcmsvbW9jay9odHRwL2NvbmZpZy9yb3V0ZS1tb2NrLWNvbmZpZy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7O0dBTUciLCJzb3VyY2VzQ29udGVudCI6WyIvKipcclxuICogQGxpY2Vuc2VcclxuICogQ29weXJpZ2h0IFBhc2NhbCBFQ0hFTUFOTi4gQWxsIFJpZ2h0cyBSZXNlcnZlZC5cclxuICpcclxuICogVXNlIG9mIHRoaXMgc291cmNlIGNvZGUgaXMgZ292ZXJuZWQgYnkgYW4gTUlULXN0eWxlIGxpY2Vuc2UgdGhhdCBjYW4gYmUgZm91bmQgaW5cclxuICogdGhlIExJQ0VOU0UgZmlsZSBhdCBodHRwczovL3Bhc2NhbGVjaGVtYW5uLmNvbS9hbmd1bGFyLXRvb2xib3gvcmVzb3VyY2VzL2xpY2Vuc2VcclxuICovXHJcblxyXG5pbXBvcnQgeyBIdHRwTWV0aG9kTW9jayB9IGZyb20gXCIuLi8uLi8uLi8uLi9tb2RlbFwiO1xyXG5pbXBvcnQgeyBIdHRwTW9ja1BhcmFtZXRlcnMgfSBmcm9tIFwiLi9odHRwLW1vY2stcGFyYW1ldGVyc1wiO1xyXG5cclxuLyoqXHJcbiAqIEBwcml2YXRlXHJcbiAqIFxyXG4gKiBUaGUgbWFya3VwIGludGVyZmFjZSBmb3IgRFRPcyB0aGF0IGFyZSB1c2VkIHRvIHNlbmQgYSBtb2NrIGNvbmZpZyB0byB0aGUgZGVsZWdhdGVcclxuICogYFhoclByb3h5YCBpbnN0YW5jZS5cclxuICogVGhpcyBpbnRlcmZhY2UgaXMgbm90IGV4cG9zZWQuXHJcbiAqL1xyXG5leHBvcnQgaW50ZXJmYWNlIFJvdXRlTW9ja0NvbmZpZyB7XHJcblxyXG4gICAgLyoqXHJcbiAgICAgKiBAcHJpdmF0ZVxyXG4gICAgICogXHJcbiAgICAgKiBUaGUgYEh0dHBNZXRob2RNb2NrYG9iamVjdCB0byBiZSBjb25zdW1lZCBieSB0aGUgdGhlIGRlbGVnYXRlIGBYaHJQcm94eWAgaW5zdGFuY2UuXHJcbiAgICAgKi9cclxuICAgIG1ldGhvZENvbmZpZzogSHR0cE1ldGhvZE1vY2s7XHJcbiAgICBcclxuICAgIC8qKlxyXG4gICAgICogQHByaXZhdGVcclxuICAgICAqIFxyXG4gICAgICogVGhlIGxpc3Qgb2YgVVJJIHBhcmFtZXRlcnMgYXNzb2NpYXRlZCB3aXRoIHRoZSBjdXJyZW50IEhUVFAgY2FsbC5cclxuICAgICAqL1xyXG4gICAgcGFyYW1ldGVyczogSHR0cE1vY2tQYXJhbWV0ZXJzIHwgbnVsbDtcclxufSJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicm91dGUtbW9jay1jb25maWcuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9hbmd1bGFyLXRvb2xib3gvc3JjL2xpYi9mcmFtZXdvcmsvbW9jay9odHRwL2NvbmZpZy9yb3V0ZS1tb2NrLWNvbmZpZy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7O0dBTUciLCJzb3VyY2VzQ29udGVudCI6WyIvKipcclxuICogQGxpY2Vuc2VcclxuICogQ29weXJpZ2h0IFBhc2NhbCBFQ0hFTUFOTi4gQWxsIFJpZ2h0cyBSZXNlcnZlZC5cclxuICpcclxuICogVXNlIG9mIHRoaXMgc291cmNlIGNvZGUgaXMgZ292ZXJuZWQgYnkgYW4gTUlULXN0eWxlIGxpY2Vuc2UgdGhhdCBjYW4gYmUgZm91bmQgaW5cclxuICogdGhlIExJQ0VOU0UgZmlsZSBhdCBodHRwczovL3Bhc2NhbGVjaGVtYW5uLmNvbS9hbmd1bGFyLXRvb2xib3gvcmVzb3VyY2VzL2xpY2Vuc2VcclxuICovXHJcblxyXG5pbXBvcnQgeyBIdHRwTWV0aG9kTW9jayB9IGZyb20gXCIuLi8uLi8uLi8uLi9tb2RlbFwiO1xyXG5pbXBvcnQgeyBIdHRwTW9ja1BhcmFtZXRlcnMgfSBmcm9tIFwiLi9odHRwLW1vY2stcGFyYW1ldGVyc1wiO1xyXG5cclxuLyoqXHJcbiAqIEBwcml2YXRlXHJcbiAqIFxyXG4gKiBUaGUgbWFya3VwIGludGVyZmFjZSBmb3IgRFRPcyB0aGF0IGFyZSB1c2VkIHRvIHNlbmQgYSBtb2NrIGNvbmZpZyB0byB0aGUgZGVsZWdhdGVcclxuICogYFhoclByb3h5YCBpbnN0YW5jZS5cclxuICogVGhpcyBpbnRlcmZhY2UgaXMgbm90IGV4cG9zZWQuXHJcbiAqL1xyXG5leHBvcnQgaW50ZXJmYWNlIFJvdXRlTW9ja0NvbmZpZyB7XHJcblxyXG4gICAgLyoqXHJcbiAgICAgKiBAcHJpdmF0ZVxyXG4gICAgICogXHJcbiAgICAgKiBUaGUgYEh0dHBNZXRob2RNb2NrYG9iamVjdCB0byBiZSBjb25zdW1lZCBieSB0aGUgdGhlIGRlbGVnYXRlIGBYaHJQcm94eWAgaW5zdGFuY2UuXHJcbiAgICAgKi9cclxuICAgIG1ldGhvZENvbmZpZzogSHR0cE1ldGhvZE1vY2s7XHJcbiAgICBcclxuICAgIC8qKlxyXG4gICAgICogQHByaXZhdGVcclxuICAgICAqIFxyXG4gICAgICogVGhlIGxpc3Qgb2YgVVJJIHBhcmFtZXRlcnMgYXNzb2NpYXRlZCB3aXRoIHRoZSBjdXJyZW50IEhUVFAgY2FsbC5cclxuICAgICAqL1xyXG4gICAgcGFyYW1ldGVyczogSHR0cE1vY2tQYXJhbWV0ZXJzIHwgbnVsbDtcclxuICAgICAgICBcclxuICAgIC8qKlxyXG4gICAgICogQHByaXZhdGVcclxuICAgICAqIFxyXG4gICAgICogVGhlIGxpc3Qgb2YgVVJJIHNlYXJjaCBwYXJhbWV0ZXJzIGFzc29jaWF0ZWQgd2l0aCB0aGUgY3VycmVudCBIVFRQIGNhbGwuXHJcbiAgICAgKi9cclxuICAgIHNlYXJjaFBhcmFtczogVVJMU2VhcmNoUGFyYW1zO1xyXG59Il19

package/esm2022/lib/framework/mock/http/util/data-storage.builder.mjs

@@ -18,7 +18,7 @@ export class DataStorageBuilder {
      * @param httpResponse The `HttpResponseMock` to be stored by the framework.
      * @param data The data of the HTTP response to be stored by the framework.
      *
-     * @returns A new `DataStorage` objects.
+     * @returns A new `DataStorage` object.
      */
     static buildDataStorage(httpResponse, data) {
         // TODO: add support for different data types (string, Blob, etc.)
@@ -32,4 +32,4 @@ export class DataStorageBuilder {
         };
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/framework/mock/http/util/fetch-client-response-type.enum.mjs

@@ -0,0 +1,36 @@
+/**
+ * @license
+ * Copyright Pascal ECHEMANN. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be found in
+ * the LICENSE file at https://pascalechemann.com/angular-toolbox/resources/license
+ */
+/**
+ * Defines the possible values for the `responseType` property of the
+ * `FetchClientBuilder.buildFetchClient()` method.
+ */
+export var FetchClientResponseType;
+(function (FetchClientResponseType) {
+    /**
+     * Allows to return the response as a promise that resolves with an `ArrayBuffer`.
+     */
+    FetchClientResponseType["ARRAY_BUFFER"] = "arrayBuffer";
+    /**
+     * Allows to return the response as a promise that resolves with a `Blob`.
+     */
+    FetchClientResponseType["BLOB"] = "blob";
+    /**
+     * Allows to return the response as a promise that resolves with a `FormData` object.
+     */
+    FetchClientResponseType["FORM_DATA"] = "formData";
+    /**
+     * Allows to return the response as a promise which resolves with the result of parsing the body text as JSON.
+     */
+    FetchClientResponseType["JSON"] = "json";
+    /**
+     * Allows to return the response as a promise that resolves with a `String`.
+     * The response is always decoded using UTF-8.
+     */
+    FetchClientResponseType["TEXT"] = "text";
+})(FetchClientResponseType || (FetchClientResponseType = {}));
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/framework/mock/http/util/fetch-client.builder.mjs

@@ -0,0 +1,51 @@
+/**
+ * @license
+ * Copyright Pascal ECHEMANN. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be found in
+ * the LICENSE file at https://pascalechemann.com/angular-toolbox/resources/license
+ */
+import { HttpErrorResponse } from "@angular/common/http";
+import { from } from "rxjs";
+import { FetchClientResponseType } from "./fetch-client-response-type.enum";
+/**
+ * A static utility class for building `FetchClient` objects.
+ */
+export class FetchClientBuilder {
+    /**
+     * Builds and returns a new `FetchClient` object.
+     *
+     * @param input The definition of the resource to fetch.
+     * @param init The object containing options to configure the request.
+     * @param responseType Specifies the type of response for the resource to fetch.
+     *
+     * @returns A new `FetchClient` object.
+     */
+    static buildFetchClient(input, init = null, responseType = FetchClientResponseType.JSON) {
+        return from(fetch(input, init || undefined).then((response) => {
+            if (response.ok)
+                return FetchClientBuilder.buildResponseStrategy(response, responseType);
+            throw new HttpErrorResponse({
+                status: response.status,
+                statusText: response.statusText
+            });
+        }));
+    }
+    /**
+     * @private
+     */
+    static buildResponseStrategy(response, responseType) {
+        if (responseType === FetchClientResponseType.JSON)
+            return response.json();
+        if (responseType === FetchClientResponseType.BLOB)
+            return response.blob();
+        if (responseType === FetchClientResponseType.FORM_DATA)
+            return response.formData();
+        if (responseType === FetchClientResponseType.ARRAY_BUFFER)
+            return response.arrayBuffer();
+        if (responseType === FetchClientResponseType.TEXT)
+            return response.text();
+        return response.json();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/framework/mock/http/util/index.mjs

@@ -1,3 +1,5 @@
 export * from './http-mock-response.builder';
 export * from './http-headers-mock.builder';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9hbmd1bGFyLXRvb2xib3gvc3JjL2xpYi9mcmFtZXdvcmsvbW9jay9odHRwL3V0aWwvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyw4QkFBOEIsQ0FBQztBQUM3QyxjQUFjLDZCQUE2QixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9odHRwLW1vY2stcmVzcG9uc2UuYnVpbGRlcic7XHJcbmV4cG9ydCAqIGZyb20gJy4vaHR0cC1oZWFkZXJzLW1vY2suYnVpbGRlcic7Il19
+export * from './fetch-client.builder';
+export * from './fetch-client-response-type.enum';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9hbmd1bGFyLXRvb2xib3gvc3JjL2xpYi9mcmFtZXdvcmsvbW9jay9odHRwL3V0aWwvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyw4QkFBOEIsQ0FBQztBQUM3QyxjQUFjLDZCQUE2QixDQUFDO0FBQzVDLGNBQWMsd0JBQXdCLENBQUM7QUFDdkMsY0FBYyxtQ0FBbUMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vaHR0cC1tb2NrLXJlc3BvbnNlLmJ1aWxkZXInO1xyXG5leHBvcnQgKiBmcm9tICcuL2h0dHAtaGVhZGVycy1tb2NrLmJ1aWxkZXInO1xyXG5leHBvcnQgKiBmcm9tICcuL2ZldGNoLWNsaWVudC5idWlsZGVyJztcclxuZXhwb3J0ICogZnJvbSAnLi9mZXRjaC1jbGllbnQtcmVzcG9uc2UtdHlwZS5lbnVtJzsiXX0=

package/esm2022/lib/framework/mock/http/xhr/delegate-xhr.mjs

@@ -5,7 +5,7 @@
  * Use of this source code is governed by an MIT-style license that can be found in
  * the LICENSE file at https://pascalechemann.com/angular-toolbox/resources/license
  */
-import { HttpHeaders, HttpRequest, HttpStatusCode } from "@angular/common/http";
+import { HttpHeaders, HttpParams, HttpRequest, HttpStatusCode } from "@angular/common/http";
 import { ProgressEventMock } from "../event/progress-event-mock";
 import { EMPTY_STRING } from "../../../../util";
 import { XhrBase } from "./xhr-base";
@@ -123,35 +123,41 @@ export class DelegateXhr extends XhrBase {
      * @param body A body of data to be sent in the XHR request.
      */
     send(body) {
-        const request = new HttpRequest(this._method, this._url, body);
+        const request = this.buildHttpRequest(body);
         const rc = this._routeConfig;
         const httpResponseMock = rc.methodConfig.data(request, rc.parameters);
         let timer = httpResponseMock.delay || 0;
         if (timer > MAX_TIMER)
             timer = MAX_TIMER;
-        this._loadSubscription = this.loadData(httpResponseMock).subscribe((data) => {
-            this._dataStorage = DataStorageBuilder.buildDataStorage(httpResponseMock, data);
-            const error = this._dataStorage.httpResponse.error;
-            setTimeout(() => {
-                this.setReadyState(this.HEADERS_RECEIVED);
-                if (error)
-                    return this.onError(error);
-                this.setReadyState(this.LOADING);
-                const response = this._dataStorage.httpResponse;
-                let headers = response.headers;
-                if (headers) {
-                    this._headers.keys().forEach((key) => {
-                        headers = headers.set(key, this._headers.get(key));
-                    });
-                    this._headers = headers;
-                }
-                if (!this._progressiveDownload) {
-                    this._statusText = response.statusText || EMPTY_STRING;
-                    this._status = response.status || 0;
-                    return this.onLoadComplete();
-                }
-                this.doProgressiveDownload();
-            }, timer);
+        this._loadSubscription = this.loadData(httpResponseMock).subscribe({
+            next: (data) => {
+                this.setDataStorage(httpResponseMock, data);
+                const error = this._dataStorage.httpResponse.error;
+                setTimeout(() => {
+                    this.setReadyState(this.HEADERS_RECEIVED);
+                    if (error)
+                        return this.onError(error);
+                    this.setReadyState(this.LOADING);
+                    const response = this._dataStorage.httpResponse;
+                    let headers = response.headers;
+                    if (headers) {
+                        this._headers.keys().forEach((key) => {
+                            headers = headers.set(key, this._headers.get(key));
+                        });
+                        this._headers = headers;
+                    }
+                    if (!this._progressiveDownload) {
+                        this._statusText = response.statusText || EMPTY_STRING;
+                        this._status = response.status || 0;
+                        return this.onLoadComplete();
+                    }
+                    this.doProgressiveDownload();
+                }, timer);
+            },
+            error: (err) => {
+                this.setDataStorage(httpResponseMock);
+                this.onError(err);
+            }
         });
     }
     /**
@@ -216,7 +222,7 @@ export class DelegateXhr extends XhrBase {
         const methodConfig = routeConfig.methodConfig;
         this._routeConfig = routeConfig;
         this._progressiveDownload = methodConfig.progressive || false;
-        this.responseType = methodConfig.responseType || "";
+        this.responseType = methodConfig.responseType || EMPTY_STRING;
         this._headers = new HttpHeaders();
     }
     /**
@@ -312,5 +318,21 @@ export class DelegateXhr extends XhrBase {
         const responseBody = httpResponseMock.body;
         return (responseBody instanceof Observable) ? responseBody : of(responseBody);
     }
+    /**
+     * @private
+     */
+    setDataStorage(responseMock, data = null) {
+        this._dataStorage = DataStorageBuilder.buildDataStorage(responseMock, data);
+    }
+    /**
+     * @private
+     */
+    buildHttpRequest(body) {
+        let params = new HttpParams();
+        const it = this._routeConfig.searchParams.entries();
+        for (const pair of it)
+            params = params.set(pair[0], pair[1]);
+        return new HttpRequest(this._method, this._url, body, { params: params });
+    }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"delegate-xhr.js","sourceRoot":"","sources":["../../../../../../../../projects/angular-toolbox/src/lib/framework/mock/http/xhr/delegate-xhr.ts"],"names":[],"mappings":"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","sourcesContent":["/**\r\n * @license\r\n * Copyright Pascal ECHEMANN. All Rights Reserved.\r\n *\r\n * Use of this source code is governed by an MIT-style license that can be found in\r\n * the LICENSE file at https://pascalechemann.com/angular-toolbox/resources/license\r\n */\r\n\r\nimport { HttpHeaders, HttpRequest, HttpStatusCode } from \"@angular/common/http\";\r\nimport { XhrProxy, HttpResponseMock, HttpMethodMock, HttpMockError } from \"../../../../model\";\r\nimport { ProgressEventMock } from \"../event/progress-event-mock\";\r\nimport { EMPTY_STRING } from \"../../../../util\";\r\nimport { XhrBase } from \"./xhr-base\";\r\nimport { HttpHeadersUtil } from \"../util/http-headers.util\";\r\nimport { RouteMockConfig } from \"../config/route-mock-config\";\r\nimport { Observable, Subscription, of } from \"rxjs\";\r\nimport { DataStorage } from \"../core/data-storage\";\r\nimport { DataStorageBuilder } from \"../util/data-storage.builder\";\r\n\r\n/**\r\n * @private\r\n * The maximum value for a delayed HTTP response.\r\n */\r\nconst MAX_TIMER: number = 10000;\r\n\r\n/**\r\n * @private\r\n * Intenal \"onreadystatechange\" event.\r\n */\r\nconst READY_STATE_CHANGE_EVENT: Event = new Event(\"onreadystatechange\");\r\n\r\n/**\r\n * @private\r\n */\r\nconst EVT_PROPS_CONFIG: any =  { writable: false, value: this };\r\n\r\n/**\r\n * @private\r\n * A utility class used as delegate of `XMLHttpRequest` functionalities when\r\n * a HTTP request is intercepted by the Mocking Framework .\r\n */\r\nexport class DelegateXhr extends XhrBase implements XhrProxy {\r\n    \r\n    /**\r\n     * @private\r\n     * Indicates whether the progressive download is activated, or not.\r\n     */\r\n    private _progressiveDownload: boolean = false;\r\n\r\n    /**\r\n     * @private\r\n     * The config for the intercepted route.\r\n     */\r\n    private _routeConfig: RouteMockConfig;\r\n\r\n    /**\r\n     * @private\r\n     * \r\n     * Internal storage for HTTP response `data`.\r\n     */\r\n    private _dataStorage: DataStorage = null as any; \r\n\r\n    /**\r\n     * @private\r\n     * \r\n     * Internal storage for the HTTP request `method`.\r\n     */\r\n    private _method: unknown; \r\n\r\n    /**\r\n     * @private\r\n     * \r\n     * Internal storage for the HTTP request URL.\r\n     */\r\n    private _url: unknown; \r\n\r\n    /**\r\n     * @private\r\n     * \r\n     * Internal storage for the HTTP request `readyState`.\r\n     */\r\n    private _readyState: number = this.UNSENT;\r\n\r\n    /**\r\n     * @private\r\n     * \r\n     * Internal storage for the HTTP request `headers`.\r\n     */\r\n    private _headers: HttpHeaders = null as any;\r\n\r\n    /**\r\n     * @private\r\n     * \r\n     * Internal storage for the HTTP request `status`.\r\n     */\r\n    private _status: number = 0;\r\n\r\n    /**\r\n     * @private\r\n     * \r\n     * Internal storage for the HTTP request `statusText`.\r\n     */\r\n    private _statusText: string = EMPTY_STRING;\r\n\r\n    /**\r\n     * @private\r\n     */\r\n    private _loadSubscription: Subscription | null = null;\r\n\r\n    /**\r\n     * Returns the response body content.\r\n     *\r\n     * @see https://developer.mozilla.org/docs/Web/API/XMLHttpRequest/response\r\n     */\r\n    get response(): any {\r\n        return this._dataStorage?.data || null;\r\n    }\r\n\r\n    /**\r\n     * Returns the numerical HTTP status code of the `XMLHttpRequest` response.\r\n     *\r\n     * @see https://developer.mozilla.org/docs/Web/API/XMLHttpRequest/status\r\n     */\r\n    get status(): number {\r\n        return this._status;\r\n    }\r\n\r\n    /**\r\n     * Returns a string containing the response status message as returned by the HTTP server.\r\n     *\r\n     * @see https://developer.mozilla.org/docs/Web/API/XMLHttpRequest/statusText\r\n     */\r\n    get statusText(): string {\r\n        return this._statusText;\r\n    }\r\n\r\n    /**\r\n     * Returns the state the `XMLHttpRequest` client is in.\r\n     *\r\n     * @see https://developer.mozilla.org/docs/Web/API/XMLHttpRequest/readyState\r\n     */\r\n    get readyState(): number {\r\n        return this._readyState;\r\n    }\r\n\r\n    /**\r\n     * Returns the serialized URL of the response or the empty string if the URL is `null`. \r\n     *\r\n     * @see https://developer.mozilla.org/docs/Web/API/XMLHttpRequest/responseURL\r\n     */\r\n    get responseURL(): string {\r\n        return this._url as string;\r\n    }\r\n\r\n    /**\r\n     * Returns the text received from a server following a request being sent.\r\n     *\r\n     * Throws an `InvalidStateError` DOMException if responseType is not the empty string or \"text\".\r\n     *\r\n     * @see https://developer.mozilla.org/docs/Web/API/XMLHttpRequest/responseText\r\n     */\r\n    get responseText(): string {\r\n        return this._dataStorage?.stringifiedData || EMPTY_STRING;\r\n    }\r\n\r\n    /**\r\n     *  Returns an `XMLHttpRequestUpload` object that can be observed to monitor an upload progress. \r\n     *\r\n     * @see https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest/upload\r\n     */\r\n    get upload(): XMLHttpRequestUpload {\r\n        return null as any;\r\n    }\r\n    \r\n    /**\r\n     *  Returns an an enumerated string value specifying the type of data contained in the response. \r\n     *\r\n     * @see https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest/responseType\r\n     */\r\n    responseType: XMLHttpRequestResponseType = \"\";\r\n\r\n    /**\r\n     * Initializes a newly-created request, or re-initializes an existing one.\r\n     * \r\n     * @param method The HTTP request method to use, such as `\"GET\"`, `\"POST\"`, `\"PUT\"`, `\"DELETE\"`,\r\n     *               etc. Ignored for non-HTTP(S) URLs.\r\n     * @param url A string or any other object with a stringifier — including a URL object —\r\n     *            that provides the URL of the resource to send the request to.\r\n     */\r\n    open(method: string, url: string | URL): void;\r\n    /**\r\n     * @private\r\n     */\r\n    open(method: string, url: string | URL, async: boolean, username?: string | null | undefined, password?: string | null | undefined): void;\r\n    /**\r\n     * @private\r\n     */\r\n    open(method: unknown, url: unknown, async?: unknown, username?: unknown, password?: unknown): void {\r\n        this._method = method;\r\n        this._url = url;\r\n        this.setReadyState(this.OPENED);\r\n    }\r\n\r\n    /**\r\n     * Aborts the request if it has already been sent. When a request is aborted, its `readyState`\r\n     * is changed to `XMLHttpRequest.UNSENT` and the request status code is set to `0`.\r\n     */\r\n    abort(): void {\r\n        this._readyState = this.UNSENT;\r\n        this._status = 0;\r\n        this.eventDispatch(\"abort\");\r\n    }\r\n\r\n    /**\r\n     * Returns all the response headers, separated by CRLF, as a string, or returns `null`\r\n     * if no response has been received.\r\n     * \r\n     * @returns All the response headers, separated by CRLF, as a string, or returns `null`\r\n     *          if no response has been received.\r\n     */\r\n    getAllResponseHeaders(): string {\r\n        return this._dataStorage ? HttpHeadersUtil.stringify(this._headers) : EMPTY_STRING;\r\n    }\r\n\r\n    /**\r\n     * Sends the request to the server.\r\n     * \r\n     * @param body A body of data to be sent in the XHR request.\r\n     */\r\n    send(body?: Document | XMLHttpRequestBodyInit | null | undefined): void {\r\n        const request: HttpRequest<any> = new HttpRequest<any>(this._method as string, this._url as any, body);\r\n        const rc: RouteMockConfig = this._routeConfig;\r\n        const httpResponseMock: HttpResponseMock = (rc.methodConfig as any).data(request, rc.parameters);\r\n        let timer: number = httpResponseMock.delay || 0;\r\n        if (timer > MAX_TIMER) timer = MAX_TIMER;\r\n        this._loadSubscription = this.loadData(httpResponseMock).subscribe((data: any) => {\r\n            this._dataStorage = DataStorageBuilder.buildDataStorage(httpResponseMock, data);\r\n            const error: HttpMockError | null = this._dataStorage.httpResponse.error;\r\n            setTimeout(()=> {\r\n                this.setReadyState(this.HEADERS_RECEIVED);\r\n                if (error) return this.onError(error);\r\n                this.setReadyState(this.LOADING);\r\n                const response: HttpResponseMock = this._dataStorage.httpResponse;\r\n                let headers: any = response.headers;\r\n                if (headers) {\r\n                    this._headers.keys().forEach((key: string)=> {\r\n                        headers = headers.set(key, this._headers.get(key) as any)\r\n                    });\r\n                    this._headers = headers;\r\n                }\r\n                if (!this._progressiveDownload) {\r\n                    this._statusText = response.statusText || EMPTY_STRING;\r\n                    this._status = response.status || 0;\r\n                    return this.onLoadComplete();\r\n                }\r\n                this.doProgressiveDownload();\r\n            }, timer);\r\n        });\r\n    }\r\n\r\n    /**\r\n     * Sets the value of an HTTP request header.\r\n     * \r\n     * @param name The name of the header whose value is to be set.\r\n     * @param value The value to set as the body of the header.\r\n     */\r\n    setRequestHeader(name: string, value: string): void {\r\n        this._headers = this._headers.set(name, value);\r\n    }\r\n\r\n    /**\r\n     * @private \r\n     */\r\n    constructor(routeConfig: RouteMockConfig) {\r\n        super();\r\n        const methodConfig: HttpMethodMock = routeConfig.methodConfig;\r\n        this._routeConfig = routeConfig;\r\n        this._progressiveDownload = methodConfig.progressive || false;\r\n        this.responseType = methodConfig.responseType || \"\";\r\n        this._headers = new HttpHeaders();\r\n    }\r\n    \r\n    /**\r\n     * @private \r\n     * Internally used by the framework to delete a `DelegateXhr` instance.\r\n     */\r\n    public destroy(): void {\r\n        this._routeConfig = null as any;\r\n        this._headers = null as any;\r\n        this._dataStorage = null as any;\r\n        if (this._loadSubscription) {\r\n            this._loadSubscription.unsubscribe();\r\n            this._loadSubscription = null;\r\n        }\r\n    }\r\n\r\n    /**\r\n     * @private \r\n     */\r\n    private doProgressiveDownload(): void {\r\n        const total: number = this._dataStorage.total;\r\n        if (total <= 200) {\r\n            console.warn(\"[Angular Toolbox]: Body content is too small for emulating progressive download! Minimum size is 200 octets.\");\r\n            return this.onLoadComplete();\r\n        }\r\n        // TODO: ameliorate the following process:\r\n        const self: DelegateXhr = this;\r\n        const chunckSize: number = Math.floor(total / 10);\r\n        let cursor: number = 0;\r\n        this._statusText = \"Partial Content\";\r\n        this._status = HttpStatusCode.PartialContent;\r\n        const idx = setInterval(()=> {\r\n            cursor += chunckSize;\r\n            if (cursor > total) {\r\n                cursor = total;\r\n                clearInterval(idx);\r\n                self.onLoadComplete();\r\n            } else {\r\n                this._dataStorage.loaded = cursor;\r\n                self.dispatchProgressEvent();\r\n            }\r\n        }, 100);\r\n    }\r\n\r\n    /**\r\n     * @private\r\n     */\r\n    private onLoadComplete(): void {\r\n        this._dataStorage.loaded = this._dataStorage.total;\r\n        this.setReadyState(this.DONE);\r\n        this.dispatchProgressEvent(\"load\");\r\n    }\r\n\r\n    /**\r\n     * @private\r\n     */\r\n    private onError(error: HttpMockError): void {\r\n        this._status = error.status;\r\n        this._statusText = error.statusText;\r\n        this.setReadyState(this.DONE);\r\n        this.dispatchProgressEvent(\"error\");\r\n    }\r\n\r\n    /**\r\n     * @private\r\n     */\r\n    private eventDispatch(type: string): void {\r\n        const event: Event = new Event(type);\r\n        Object.defineProperty(event, 'target', EVT_PROPS_CONFIG);\r\n        Object.defineProperty(event, 'currentTarget', EVT_PROPS_CONFIG);\r\n        this.dispatchEvent(event);\r\n    }\r\n\r\n    /**\r\n     * @private \r\n     */\r\n    private dispatchProgressEvent(type: string = \"progress\"): void {\r\n        const d: any = this._dataStorage;\r\n        const event: ProgressEventMock = new ProgressEventMock(type);\r\n        event.loaded = d.loaded;\r\n        event.total = d.total;\r\n        this.dispatchEvent(event);\r\n    }\r\n\r\n    /**\r\n     * @private \r\n     */\r\n    private setReadyState(state: number): void {\r\n        this._readyState = state;\r\n        const event: any = this.onreadystatechange;\r\n        if (event) event.call(this, READY_STATE_CHANGE_EVENT);\r\n    }\r\n\r\n    /**\r\n     * @private \r\n     */\r\n    private loadData(httpResponseMock: HttpResponseMock): Observable<any> {\r\n        const responseBody: any | Observable<any> = httpResponseMock.body;\r\n        return (responseBody instanceof Observable) ? responseBody : of(responseBody);\r\n    }\r\n}"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"delegate-xhr.js","sourceRoot":"","sources":["../../../../../../../../projects/angular-toolbox/src/lib/framework/mock/http/xhr/delegate-xhr.ts"],"names":[],"mappings":"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","sourcesContent":["/**\r\n * @license\r\n * Copyright Pascal ECHEMANN. All Rights Reserved.\r\n *\r\n * Use of this source code is governed by an MIT-style license that can be found in\r\n * the LICENSE file at https://pascalechemann.com/angular-toolbox/resources/license\r\n */\r\n\r\nimport { HttpHeaders, HttpParams, HttpRequest, HttpStatusCode } from \"@angular/common/http\";\r\nimport { XhrProxy, HttpResponseMock, HttpMethodMock, HttpMockError } from \"../../../../model\";\r\nimport { ProgressEventMock } from \"../event/progress-event-mock\";\r\nimport { EMPTY_STRING } from \"../../../../util\";\r\nimport { XhrBase } from \"./xhr-base\";\r\nimport { HttpHeadersUtil } from \"../util/http-headers.util\";\r\nimport { RouteMockConfig } from \"../config/route-mock-config\";\r\nimport { Observable, Subscription, of } from \"rxjs\";\r\nimport { DataStorage } from \"../core/data-storage\";\r\nimport { DataStorageBuilder } from \"../util/data-storage.builder\";\r\n\r\n/**\r\n * @private\r\n * The maximum value for a delayed HTTP response.\r\n */\r\nconst MAX_TIMER: number = 10000;\r\n\r\n/**\r\n * @private\r\n * Intenal \"onreadystatechange\" event.\r\n */\r\nconst READY_STATE_CHANGE_EVENT: Event = new Event(\"onreadystatechange\");\r\n\r\n/**\r\n * @private\r\n */\r\nconst EVT_PROPS_CONFIG: any =  { writable: false, value: this };\r\n\r\n/**\r\n * @private\r\n * A utility class used as delegate of `XMLHttpRequest` functionalities when\r\n * a HTTP request is intercepted by the Mocking Framework .\r\n */\r\nexport class DelegateXhr extends XhrBase implements XhrProxy {\r\n    \r\n    /**\r\n     * @private\r\n     * Indicates whether the progressive download is activated, or not.\r\n     */\r\n    private _progressiveDownload: boolean = false;\r\n\r\n    /**\r\n     * @private\r\n     * The config for the intercepted route.\r\n     */\r\n    private _routeConfig: RouteMockConfig;\r\n\r\n    /**\r\n     * @private\r\n     * \r\n     * Internal storage for HTTP response `data`.\r\n     */\r\n    private _dataStorage: DataStorage = null as any; \r\n\r\n    /**\r\n     * @private\r\n     * \r\n     * Internal storage for the HTTP request `method`.\r\n     */\r\n    private _method: unknown; \r\n\r\n    /**\r\n     * @private\r\n     * \r\n     * Internal storage for the HTTP request URL.\r\n     */\r\n    private _url: unknown; \r\n\r\n    /**\r\n     * @private\r\n     * \r\n     * Internal storage for the HTTP request `readyState`.\r\n     */\r\n    private _readyState: number = this.UNSENT;\r\n\r\n    /**\r\n     * @private\r\n     * \r\n     * Internal storage for the HTTP request `headers`.\r\n     */\r\n    private _headers: HttpHeaders = null as any;\r\n\r\n    /**\r\n     * @private\r\n     * \r\n     * Internal storage for the HTTP request `status`.\r\n     */\r\n    private _status: number = 0;\r\n\r\n    /**\r\n     * @private\r\n     * \r\n     * Internal storage for the HTTP request `statusText`.\r\n     */\r\n    private _statusText: string = EMPTY_STRING;\r\n\r\n    /**\r\n     * @private\r\n     */\r\n    private _loadSubscription: Subscription | null = null;\r\n\r\n    /**\r\n     * Returns the response body content.\r\n     *\r\n     * @see https://developer.mozilla.org/docs/Web/API/XMLHttpRequest/response\r\n     */\r\n    get response(): any {\r\n        return this._dataStorage?.data || null;\r\n    }\r\n\r\n    /**\r\n     * Returns the numerical HTTP status code of the `XMLHttpRequest` response.\r\n     *\r\n     * @see https://developer.mozilla.org/docs/Web/API/XMLHttpRequest/status\r\n     */\r\n    get status(): number {\r\n        return this._status;\r\n    }\r\n\r\n    /**\r\n     * Returns a string containing the response status message as returned by the HTTP server.\r\n     *\r\n     * @see https://developer.mozilla.org/docs/Web/API/XMLHttpRequest/statusText\r\n     */\r\n    get statusText(): string {\r\n        return this._statusText;\r\n    }\r\n\r\n    /**\r\n     * Returns the state the `XMLHttpRequest` client is in.\r\n     *\r\n     * @see https://developer.mozilla.org/docs/Web/API/XMLHttpRequest/readyState\r\n     */\r\n    get readyState(): number {\r\n        return this._readyState;\r\n    }\r\n\r\n    /**\r\n     * Returns the serialized URL of the response or the empty string if the URL is `null`. \r\n     *\r\n     * @see https://developer.mozilla.org/docs/Web/API/XMLHttpRequest/responseURL\r\n     */\r\n    get responseURL(): string {\r\n        return this._url as string;\r\n    }\r\n\r\n    /**\r\n     * Returns the text received from a server following a request being sent.\r\n     *\r\n     * Throws an `InvalidStateError` DOMException if responseType is not the empty string or \"text\".\r\n     *\r\n     * @see https://developer.mozilla.org/docs/Web/API/XMLHttpRequest/responseText\r\n     */\r\n    get responseText(): string {\r\n        return this._dataStorage?.stringifiedData || EMPTY_STRING;\r\n    }\r\n\r\n    /**\r\n     *  Returns an `XMLHttpRequestUpload` object that can be observed to monitor an upload progress. \r\n     *\r\n     * @see https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest/upload\r\n     */\r\n    get upload(): XMLHttpRequestUpload {\r\n        return null as any;\r\n    }\r\n    \r\n    /**\r\n     *  Returns an an enumerated string value specifying the type of data contained in the response. \r\n     *\r\n     * @see https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest/responseType\r\n     */\r\n    responseType: XMLHttpRequestResponseType = \"\";\r\n\r\n    /**\r\n     * Initializes a newly-created request, or re-initializes an existing one.\r\n     * \r\n     * @param method The HTTP request method to use, such as `\"GET\"`, `\"POST\"`, `\"PUT\"`, `\"DELETE\"`,\r\n     *               etc. Ignored for non-HTTP(S) URLs.\r\n     * @param url A string or any other object with a stringifier — including a URL object —\r\n     *            that provides the URL of the resource to send the request to.\r\n     */\r\n    open(method: string, url: string | URL): void;\r\n    /**\r\n     * @private\r\n     */\r\n    open(method: string, url: string | URL, async: boolean, username?: string | null | undefined, password?: string | null | undefined): void;\r\n    /**\r\n     * @private\r\n     */\r\n    open(method: unknown, url: unknown, async?: unknown, username?: unknown, password?: unknown): void {\r\n        this._method = method;\r\n        this._url = url;\r\n        this.setReadyState(this.OPENED);\r\n    }\r\n\r\n    /**\r\n     * Aborts the request if it has already been sent. When a request is aborted, its `readyState`\r\n     * is changed to `XMLHttpRequest.UNSENT` and the request status code is set to `0`.\r\n     */\r\n    abort(): void {\r\n        this._readyState = this.UNSENT;\r\n        this._status = 0;\r\n        this.eventDispatch(\"abort\");\r\n    }\r\n\r\n    /**\r\n     * Returns all the response headers, separated by CRLF, as a string, or returns `null`\r\n     * if no response has been received.\r\n     * \r\n     * @returns All the response headers, separated by CRLF, as a string, or returns `null`\r\n     *          if no response has been received.\r\n     */\r\n    getAllResponseHeaders(): string {\r\n        return this._dataStorage ? HttpHeadersUtil.stringify(this._headers) : EMPTY_STRING;\r\n    }\r\n\r\n    /**\r\n     * Sends the request to the server.\r\n     * \r\n     * @param body A body of data to be sent in the XHR request.\r\n     */\r\n    send(body?: Document | XMLHttpRequestBodyInit | null | undefined): void {\r\n        const request: HttpRequest<any> = this.buildHttpRequest(body);\r\n        const rc: RouteMockConfig = this._routeConfig;\r\n        const httpResponseMock: HttpResponseMock = (rc.methodConfig as any).data(request, rc.parameters);\r\n        let timer: number = httpResponseMock.delay || 0;\r\n        if (timer > MAX_TIMER) timer = MAX_TIMER;\r\n        this._loadSubscription = this.loadData(httpResponseMock).subscribe({\r\n            next: (data: any) => {\r\n                this.setDataStorage(httpResponseMock, data);\r\n                const error: HttpMockError | null = this._dataStorage.httpResponse.error;\r\n                setTimeout(()=> {\r\n                    this.setReadyState(this.HEADERS_RECEIVED);\r\n                    if (error) return this.onError(error);\r\n                    this.setReadyState(this.LOADING);\r\n                    const response: HttpResponseMock = this._dataStorage.httpResponse;\r\n                    let headers: any = response.headers;\r\n                    if (headers) {\r\n                        this._headers.keys().forEach((key: string)=> {\r\n                            headers = headers.set(key, this._headers.get(key) as any)\r\n                        });\r\n                        this._headers = headers;\r\n                    }\r\n                    if (!this._progressiveDownload) {\r\n                        this._statusText = response.statusText || EMPTY_STRING;\r\n                        this._status = response.status || 0;\r\n                        return this.onLoadComplete();\r\n                    }\r\n                    this.doProgressiveDownload();\r\n                }, timer);\r\n            },\r\n            error: (err: any) => {\r\n                this.setDataStorage(httpResponseMock);\r\n                this.onError(err);\r\n            }\r\n        });\r\n    }\r\n    /**\r\n     * Sets the value of an HTTP request header.\r\n     * \r\n     * @param name The name of the header whose value is to be set.\r\n     * @param value The value to set as the body of the header.\r\n     */\r\n    setRequestHeader(name: string, value: string): void {\r\n        this._headers = this._headers.set(name, value);\r\n    }\r\n\r\n    /**\r\n     * @private \r\n     */\r\n    constructor(routeConfig: RouteMockConfig) {\r\n        super();\r\n        const methodConfig: HttpMethodMock = routeConfig.methodConfig;\r\n        this._routeConfig = routeConfig;\r\n        this._progressiveDownload = methodConfig.progressive || false;\r\n        this.responseType = methodConfig.responseType || EMPTY_STRING as any;\r\n        this._headers = new HttpHeaders();\r\n    }\r\n    \r\n    /**\r\n     * @private \r\n     * Internally used by the framework to delete a `DelegateXhr` instance.\r\n     */\r\n    public destroy(): void {\r\n        this._routeConfig = null as any;\r\n        this._headers = null as any;\r\n        this._dataStorage = null as any;\r\n        if (this._loadSubscription) {\r\n            this._loadSubscription.unsubscribe();\r\n            this._loadSubscription = null;\r\n        }\r\n    }\r\n\r\n    /**\r\n     * @private \r\n     */\r\n    private doProgressiveDownload(): void {\r\n        const total: number = this._dataStorage.total;\r\n        if (total <= 200) {\r\n            console.warn(\"[Angular Toolbox]: Body content is too small for emulating progressive download! Minimum size is 200 octets.\");\r\n            return this.onLoadComplete();\r\n        }\r\n        // TODO: ameliorate the following process:\r\n        const self: DelegateXhr = this;\r\n        const chunckSize: number = Math.floor(total / 10);\r\n        let cursor: number = 0;\r\n        this._statusText = \"Partial Content\";\r\n        this._status = HttpStatusCode.PartialContent;\r\n        const idx = setInterval(()=> {\r\n            cursor += chunckSize;\r\n            if (cursor > total) {\r\n                cursor = total;\r\n                clearInterval(idx);\r\n                self.onLoadComplete();\r\n            } else {\r\n                this._dataStorage.loaded = cursor;\r\n                self.dispatchProgressEvent();\r\n            }\r\n        }, 100);\r\n    }\r\n\r\n    /**\r\n     * @private\r\n     */\r\n    private onLoadComplete(): void {\r\n        this._dataStorage.loaded = this._dataStorage.total;\r\n        this.setReadyState(this.DONE);\r\n        this.dispatchProgressEvent(\"load\");\r\n    }\r\n\r\n    /**\r\n     * @private\r\n     */\r\n    private onError(error: HttpMockError): void {\r\n        this._status = error.status;\r\n        this._statusText = error.statusText;\r\n        this.setReadyState(this.DONE);\r\n        this.dispatchProgressEvent(\"error\");\r\n    }\r\n\r\n    /**\r\n     * @private\r\n     */\r\n    private eventDispatch(type: string): void {\r\n        const event: Event = new Event(type);\r\n        Object.defineProperty(event, 'target', EVT_PROPS_CONFIG);\r\n        Object.defineProperty(event, 'currentTarget', EVT_PROPS_CONFIG);\r\n        this.dispatchEvent(event);\r\n    }\r\n\r\n    /**\r\n     * @private \r\n     */\r\n    private dispatchProgressEvent(type: string = \"progress\"): void {\r\n        const d: any = this._dataStorage;\r\n        const event: ProgressEventMock = new ProgressEventMock(type);\r\n        event.loaded = d.loaded;\r\n        event.total = d.total;\r\n        this.dispatchEvent(event);\r\n    }\r\n\r\n    /**\r\n     * @private \r\n     */\r\n    private setReadyState(state: number): void {\r\n        this._readyState = state;\r\n        const event: any = this.onreadystatechange;\r\n        if (event) event.call(this, READY_STATE_CHANGE_EVENT);\r\n    }\r\n\r\n    /**\r\n     * @private \r\n     */\r\n    private loadData(httpResponseMock: HttpResponseMock): Observable<any> {\r\n        const responseBody: any | Observable<any> = httpResponseMock.body;\r\n        return (responseBody instanceof Observable) ? responseBody : of(responseBody);\r\n    }\r\n\r\n    /**\r\n     * @private \r\n     */\r\n    private setDataStorage(responseMock: HttpResponseMock, data: any = null): void {\r\n        this._dataStorage =  DataStorageBuilder.buildDataStorage(responseMock, data);\r\n    }\r\n    \r\n    /**\r\n     * @private \r\n     */\r\n    private buildHttpRequest(body: any): HttpRequest<any> {\r\n        let params: HttpParams = new HttpParams();\r\n        const it: IterableIterator<[string, string]> = (this._routeConfig.searchParams as any).entries();\r\n        for (const pair of it) params = params.set(pair[0], pair[1]);\r\n        return new HttpRequest<any>(this._method as string, this._url as any, body, { params: params });\r\n    }\r\n}"]}

package/esm2022/lib/model/business/mock/http/fetch-client.mjs

@@ -0,0 +1,9 @@
+/**
+ * @license
+ * Copyright Pascal ECHEMANN. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be found in
+ * the LICENSE file at https://pascalechemann.com/angular-toolbox/resources/license
+ */
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmV0Y2gtY2xpZW50LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvYW5ndWxhci10b29sYm94L3NyYy9saWIvbW9kZWwvYnVzaW5lc3MvbW9jay9odHRwL2ZldGNoLWNsaWVudC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7O0dBTUciLCJzb3VyY2VzQ29udGVudCI6WyIvKipcclxuICogQGxpY2Vuc2VcclxuICogQ29weXJpZ2h0IFBhc2NhbCBFQ0hFTUFOTi4gQWxsIFJpZ2h0cyBSZXNlcnZlZC5cclxuICpcclxuICogVXNlIG9mIHRoaXMgc291cmNlIGNvZGUgaXMgZ292ZXJuZWQgYnkgYW4gTUlULXN0eWxlIGxpY2Vuc2UgdGhhdCBjYW4gYmUgZm91bmQgaW5cclxuICogdGhlIExJQ0VOU0UgZmlsZSBhdCBodHRwczovL3Bhc2NhbGVjaGVtYW5uLmNvbS9hbmd1bGFyLXRvb2xib3gvcmVzb3VyY2VzL2xpY2Vuc2VcclxuICovXHJcblxyXG5pbXBvcnQgeyBPYnNlcnZhYmxlIH0gZnJvbSBcInJ4anNcIjtcclxuXHJcbi8qKlxyXG4gKiBUaGUgbWFya3VwIGludGVyZmFjZSBmb3IgYE9ic2VydmFibGVgIG9iamVjdCBidWlsdCBmcm9tIHRoZSBGZXRjaCBBUEkuXHJcbiAqL1xyXG5leHBvcnQgaW50ZXJmYWNlIEZldGNoQ2xpZW50IGV4dGVuZHMgT2JzZXJ2YWJsZTxhbnk+IHt9XHJcbiJdfQ==

package/esm2022/lib/model/business/mock/http/index.mjs

@@ -5,4 +5,5 @@ export * from './http-mock-endpoint';
 export * from './http-mock-interceptor';
 export * from './http-mock-error';
 export * from './xhr-proxy';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9hbmd1bGFyLXRvb2xib3gvc3JjL2xpYi9tb2RlbC9idXNpbmVzcy9tb2NrL2h0dHAvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxzQkFBc0IsQ0FBQztBQUNyQyxjQUFjLG9CQUFvQixDQUFDO0FBQ25DLGNBQWMsb0JBQW9CLENBQUM7QUFDbkMsY0FBYyxzQkFBc0IsQ0FBQztBQUNyQyxjQUFjLHlCQUF5QixDQUFDO0FBQ3hDLGNBQWMsbUJBQW1CLENBQUM7QUFDbEMsY0FBYyxhQUFhLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2h0dHAtcmVzcG9uc2UtbW9jayc7XHJcbmV4cG9ydCAqIGZyb20gJy4vaHR0cC1tZXRob2QtbW9jayc7XHJcbmV4cG9ydCAqIGZyb20gJy4vaHR0cC1tb2NrLWNvbmZpZyc7XHJcbmV4cG9ydCAqIGZyb20gJy4vaHR0cC1tb2NrLWVuZHBvaW50JztcclxuZXhwb3J0ICogZnJvbSAnLi9odHRwLW1vY2staW50ZXJjZXB0b3InO1xyXG5leHBvcnQgKiBmcm9tICcuL2h0dHAtbW9jay1lcnJvcic7XHJcbmV4cG9ydCAqIGZyb20gJy4veGhyLXByb3h5JzsiXX0=
+export * from './fetch-client';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9hbmd1bGFyLXRvb2xib3gvc3JjL2xpYi9tb2RlbC9idXNpbmVzcy9tb2NrL2h0dHAvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxzQkFBc0IsQ0FBQztBQUNyQyxjQUFjLG9CQUFvQixDQUFDO0FBQ25DLGNBQWMsb0JBQW9CLENBQUM7QUFDbkMsY0FBYyxzQkFBc0IsQ0FBQztBQUNyQyxjQUFjLHlCQUF5QixDQUFDO0FBQ3hDLGNBQWMsbUJBQW1CLENBQUM7QUFDbEMsY0FBYyxhQUFhLENBQUM7QUFDNUIsY0FBYyxnQkFBZ0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vaHR0cC1yZXNwb25zZS1tb2NrJztcclxuZXhwb3J0ICogZnJvbSAnLi9odHRwLW1ldGhvZC1tb2NrJztcclxuZXhwb3J0ICogZnJvbSAnLi9odHRwLW1vY2stY29uZmlnJztcclxuZXhwb3J0ICogZnJvbSAnLi9odHRwLW1vY2stZW5kcG9pbnQnO1xyXG5leHBvcnQgKiBmcm9tICcuL2h0dHAtbW9jay1pbnRlcmNlcHRvcic7XHJcbmV4cG9ydCAqIGZyb20gJy4vaHR0cC1tb2NrLWVycm9yJztcclxuZXhwb3J0ICogZnJvbSAnLi94aHItcHJveHknO1xyXG5leHBvcnQgKiBmcm9tICcuL2ZldGNoLWNsaWVudCc7Il19

package/esm2022/lib/model/service/mock/http/http-mock.service.mjs

@@ -132,7 +132,8 @@ export class HttpMockService {
             if (regexp.test(route)) {
                 result = {
                     methodConfig: methodMap.methodMock,
-                    parameters: this.buildParameters(regexp, methodMap.keys, route)
+                    parameters: this.buildParameters(regexp, methodMap.keys, route),
+                    searchParams: url.searchParams
                 };
                 break;
             }
@@ -236,4 +237,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.3", ngImpor
                     providedIn: 'root'
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"http-mock.service.js","sourceRoot":"","sources":["../../../../../../../../projects/angular-toolbox/src/lib/model/service/mock/http/http-mock.service.ts"],"names":[],"mappings":"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","sourcesContent":["/**\r\n * @license\r\n * Copyright Pascal ECHEMANN. All Rights Reserved.\r\n *\r\n * Use of this source code is governed by an MIT-style license that can be found in\r\n * the LICENSE file at https://pascalechemann.com/angular-toolbox/resources/license\r\n */\r\n\r\nimport { Injectable } from '@angular/core';\r\nimport { HttpMockInterceptor, HttpMockConfig, HttpMethodMock, HttpMockEndpoint } from '../../../business';\r\nimport { HTTPMethodRef } from '../../../../framework/mock/http/util/http-method-ref.enum';\r\nimport { tokenDataToRegexp } from '../../../../framework/mock/http/path-to-regexp/token-data-to-regexp';\r\nimport { RouteMockConfig } from '../../../../framework/mock/http/config/route-mock-config';\r\nimport { Key } from '../../../../framework/mock/http/path-to-regexp/model/key';\r\nimport { stringToTokenData } from '../../../../framework/mock/http/path-to-regexp/string-to-token-data';\r\nimport { DEFAULT_DELIMITER } from '../../../../framework/mock/http/path-to-regexp/constants';\r\nimport { Uuid } from '../../../../util';\r\nimport { TokenData } from '../../../../framework/mock/http/path-to-regexp/token-data';\r\nimport { HttpMockServiceError } from '../../../../core/error';\r\n\r\n/**\r\n * @private\r\n * Reference to the original type for this class.\r\n */\r\nexport const HTTP_MOCK_SERVICE: string = \"HttpMockService\";\r\n\r\n/**\r\n * @private\r\n * An internal utility for storring references to endpoint mock configs.\r\n */\r\ninterface HttpMockEndpointStorage {\r\n  methodMock: HttpMethodMock;\r\n  regexp: RegExp;\r\n  keys: Key[];\r\n  configId: string;\r\n}\r\n\r\n/**\r\n * The `HttpMockService` class provides the API for managing HTTP mock configuration objects.\r\n */\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class HttpMockService {\r\n\r\n  /**\r\n   * @private\r\n   * Ensures that class type is still accessible after TypeScript compilation.\r\n   */\r\n  public readonly type: string = HTTP_MOCK_SERVICE;\r\n\r\n  /**\r\n   * @private\r\n   * The list of IDs associated with each config object.\r\n   */\r\n  private _configIdList: Uuid[] = [];\r\n\r\n  /**\r\n   * @private\r\n   * Stores the complete collection of mocking behaviors for each registered config.\r\n   */\r\n  private _configList: Map<string, Map<string, HttpMockEndpointStorage[]>> = new Map<string, Map<string, HttpMockEndpointStorage[]>>();\r\n\r\n  /**\r\n   * @private\r\n   * The reference to the current app URL origin.\r\n   */\r\n  private readonly APP_ORIGIN: string = window.location.origin;\r\n\r\n  /**\r\n   * Adds the specified `HttpMockConfig` object to this `HttpMockService` instance.\r\n   * \r\n   * @param config The `HttpMockConfig` object to add to this `HttpMockService` instance.\r\n   * @Returns The `Uuid` instance associated with the added `HttpMockConfig` object.\r\n   */\r\n  public addConfig(config: HttpMockConfig): Uuid {\r\n    const origin: string = config.origin || this.APP_ORIGIN;\r\n    this.checkOrigin(origin);\r\n    let id: Uuid | undefined = config.id;\r\n    if (!id) {\r\n      id = Uuid.build();\r\n      config.id = id;\r\n    } else {\r\n      if (this.hasRegisteredConfig(id)) throw new HttpMockServiceError(`A config object has already been registered with the id: [\"${id.toString()}\"].`) ;\r\n    }\r\n    this._configIdList.push(id);\r\n    const uuid: string = id.toString();\r\n    config.interceptors.forEach((interceptor: HttpMockInterceptor) => this.extractConfig(interceptor, origin, uuid) );\r\n    return id;\r\n  }\r\n\r\n  /**\r\n   * Returns the current app URL origin.\r\n   * \r\n   * @returns A string that represents the current app URL origin.\r\n   */\r\n  public getAppOrigin(): string {\r\n    return this.APP_ORIGIN;\r\n  }\r\n\r\n  /**\r\n   * Removes the configuration registered with the specified `uuid` from this `HttpMockService` instance.\r\n   * \r\n   * @param uuid The UUID of the configuration to remove.\r\n   */\r\n  public removeConfig(uuid: Uuid): void {\r\n    if (!this.hasRegisteredConfig(uuid)) return;\r\n    const configId: string = uuid.toString();\r\n    this._configList.forEach((value: Map<string, HttpMockEndpointStorage[]>, key: string) => {\r\n      this.deleteConfigById(value, configId);\r\n      if (value.size === 0) this._configList.delete(key);\r\n    });\r\n    this._configIdList.splice(this._configIdList.indexOf(uuid), 1);\r\n  }\r\n\r\n  /**\r\n   * Removes all registred configurations from this `HttpMockService` instance.\r\n   */\r\n  public clearConfigs(): void {\r\n    this._configList.clear();\r\n    this._configIdList.length = 0;\r\n  }\r\n  /**\r\n   * Returns a boolean value that indicates whether a config with the specified UUID has been registered\r\n   * (`true`), or not (`false`).\r\n   * \r\n   * @param uuid The UUID of the config to check.\r\n   * @returns `true` whether a config with the specified UUID has been registered; `false` otherwise.\r\n   */\r\n  public hasRegisteredConfig(uuid: Uuid): boolean {\r\n    return this._configIdList.indexOf(uuid) !== -1;\r\n  }\r\n\r\n  /**\r\n   * Returns the `RouteMockConfig` object associated with the specified `URL` instance and HTTP method.\r\n   * \r\n   * @param url The `URL` instance for which to find a route config.\r\n   * @param method The HTTP method for which to find a route config.\r\n   * @returns The `RouteMockConfig` object associated with the specified `URL` instance and HTTP method whether it exists;\r\n   *          `undefined` otherwise.\r\n   */\r\n  public getRouteConfig(url: URL, method: HTTPMethodRef): RouteMockConfig | undefined {\r\n    const urlConfigList: Map<string, HttpMockEndpointStorage[]> | undefined = this._configList.get(url.origin);\r\n    const route: string = url.pathname;\r\n    let result: RouteMockConfig | undefined = undefined;\r\n    if (!urlConfigList) return result;\r\n    const methodList: HttpMockEndpointStorage[] | undefined = urlConfigList.get(method);\r\n    if (!methodList) return result;\r\n    let len: number = methodList.length - 1;\r\n    while (len >= 0 ) {\r\n      const methodMap: HttpMockEndpointStorage = methodList[len];\r\n      const regexp: RegExp = methodMap.regexp;\r\n      if (regexp.test(route)) {\r\n        result = {\r\n          methodConfig: methodMap.methodMock,\r\n          parameters: this.buildParameters(regexp, methodMap.keys, route)\r\n        };\r\n        break;\r\n      }\r\n      len--;\r\n    }\r\n    return result;\r\n  }\r\n\r\n  /**\r\n   * @rivate \r\n   */\r\n  private buildParameters(regexp: RegExp, keys: Key[], route: string): any {\r\n    const execResult: RegExpExecArray | null = regexp.exec(route);\r\n    if (!execResult) return null;\r\n    const params: any = {};\r\n    let len: number = execResult.length - 1;\r\n    let i: number = 1;\r\n    for (; i <= len; ++i) {\r\n      const key: Key = keys[i - 1];\r\n      params[key.name] = execResult[i];\r\n    }\r\n    return params;\r\n  }\r\n\r\n  /**\r\n   * @rivate \r\n   */\r\n  private extractConfig(interceptor: HttpMockInterceptor, globalOrigin: string, configId: string): void {\r\n    const endpoints: HttpMockEndpoint[] = interceptor.endpoints;\r\n    let origin: string | undefined = interceptor.origin;\r\n    if (origin) this.checkOrigin(origin);\r\n    else origin = globalOrigin;\r\n    if (!this._configList.has(origin)) this._configList.set(origin, new Map<string, HttpMockEndpointStorage[]>());\r\n    endpoints.forEach((endpoint: HttpMockEndpoint) => {\r\n      this.extractEndpointConfig(origin, endpoint, HTTPMethodRef.GET, configId);\r\n      this.extractEndpointConfig(origin, endpoint, HTTPMethodRef.POST, configId);\r\n      this.extractEndpointConfig(origin, endpoint, HTTPMethodRef.PUT, configId);\r\n      this.extractEndpointConfig(origin, endpoint, HTTPMethodRef.DELETE, configId);\r\n      this.extractEndpointConfig(origin, endpoint, HTTPMethodRef.HEAD, configId);\r\n      this.extractEndpointConfig(origin, endpoint, HTTPMethodRef.OPTIONS, configId);\r\n      this.extractEndpointConfig(origin, endpoint, HTTPMethodRef.PATCH, configId);\r\n      this.extractEndpointConfig(origin, endpoint, HTTPMethodRef.CONNECT, configId);\r\n      this.extractEndpointConfig(origin, endpoint, HTTPMethodRef.TRACE, configId);\r\n    });\r\n  }\r\n\r\n  /**\r\n   * @rivate \r\n   */\r\n  private extractEndpointConfig(origin: string, endpoint: HttpMockEndpoint, method: HTTPMethodRef, configId: string): void {\r\n    const ep: any = endpoint;\r\n    if (!ep[method as any]) return;\r\n    const originConfig: Map<string, HttpMockEndpointStorage[]> = this._configList.get(origin) as any;\r\n    const route: string = endpoint.route;\r\n    const data: TokenData = stringToTokenData(route);\r\n    const keys: Key[] = [];\r\n    const regexp: RegExp = tokenDataToRegexp(data, keys, {});\r\n    if (!originConfig.has(method)) originConfig.set(method, []);\r\n    const methodConfig: HttpMockEndpointStorage[] = originConfig.get(method) as any;\r\n    methodConfig.push({\r\n      regexp: regexp,\r\n      keys: keys,\r\n      methodMock: ep[method],\r\n      configId: configId\r\n    });\r\n  }\r\n\r\n  /**\r\n   * @rivate \r\n   */\r\n  private checkOrigin(origin: string): void {\r\n    if (origin.endsWith(DEFAULT_DELIMITER)) throw new SyntaxError(`Origin must not end with a / character: [\"${origin}\"].`);\r\n  }\r\n  \r\n  /**\r\n   * @rivate \r\n   */\r\n  private deleteConfigById(storageMap: Map<string, HttpMockEndpointStorage[]>, configId: string): void {\r\n    storageMap.forEach((storage: HttpMockEndpointStorage[], key: string) => {\r\n      const cleanedConfig: HttpMockEndpointStorage[] = this.cleanConfig(storage, configId);\r\n      if (cleanedConfig.length) storageMap.set(key, cleanedConfig);\r\n      else storageMap.delete(key);\r\n    });\r\n  }\r\n\r\n  /**\r\n   * @rivate \r\n   */\r\n  private cleanConfig(storage: HttpMockEndpointStorage[], configId: string): HttpMockEndpointStorage[] {\r\n    return storage.filter((value: HttpMockEndpointStorage)=> value.configId !== configId);\r\n  }\r\n}\r\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"http-mock.service.js","sourceRoot":"","sources":["../../../../../../../../projects/angular-toolbox/src/lib/model/service/mock/http/http-mock.service.ts"],"names":[],"mappings":"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","sourcesContent":["/**\r\n * @license\r\n * Copyright Pascal ECHEMANN. All Rights Reserved.\r\n *\r\n * Use of this source code is governed by an MIT-style license that can be found in\r\n * the LICENSE file at https://pascalechemann.com/angular-toolbox/resources/license\r\n */\r\n\r\nimport { Injectable } from '@angular/core';\r\nimport { HttpMockInterceptor, HttpMockConfig, HttpMethodMock, HttpMockEndpoint } from '../../../business';\r\nimport { HTTPMethodRef } from '../../../../framework/mock/http/util/http-method-ref.enum';\r\nimport { tokenDataToRegexp } from '../../../../framework/mock/http/path-to-regexp/token-data-to-regexp';\r\nimport { RouteMockConfig } from '../../../../framework/mock/http/config/route-mock-config';\r\nimport { Key } from '../../../../framework/mock/http/path-to-regexp/model/key';\r\nimport { stringToTokenData } from '../../../../framework/mock/http/path-to-regexp/string-to-token-data';\r\nimport { DEFAULT_DELIMITER } from '../../../../framework/mock/http/path-to-regexp/constants';\r\nimport { Uuid } from '../../../../util';\r\nimport { TokenData } from '../../../../framework/mock/http/path-to-regexp/token-data';\r\nimport { HttpMockServiceError } from '../../../../core/error';\r\n\r\n/**\r\n * @private\r\n * Reference to the original type for this class.\r\n */\r\nexport const HTTP_MOCK_SERVICE: string = \"HttpMockService\";\r\n\r\n/**\r\n * @private\r\n * An internal utility for storring references to endpoint mock configs.\r\n */\r\ninterface HttpMockEndpointStorage {\r\n  methodMock: HttpMethodMock;\r\n  regexp: RegExp;\r\n  keys: Key[];\r\n  configId: string;\r\n}\r\n\r\n/**\r\n * The `HttpMockService` class provides the API for managing HTTP mock configuration objects.\r\n */\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class HttpMockService {\r\n\r\n  /**\r\n   * @private\r\n   * Ensures that class type is still accessible after TypeScript compilation.\r\n   */\r\n  public readonly type: string = HTTP_MOCK_SERVICE;\r\n\r\n  /**\r\n   * @private\r\n   * The list of IDs associated with each config object.\r\n   */\r\n  private _configIdList: Uuid[] = [];\r\n\r\n  /**\r\n   * @private\r\n   * Stores the complete collection of mocking behaviors for each registered config.\r\n   */\r\n  private _configList: Map<string, Map<string, HttpMockEndpointStorage[]>> = new Map<string, Map<string, HttpMockEndpointStorage[]>>();\r\n\r\n  /**\r\n   * @private\r\n   * The reference to the current app URL origin.\r\n   */\r\n  private readonly APP_ORIGIN: string = window.location.origin;\r\n\r\n  /**\r\n   * Adds the specified `HttpMockConfig` object to this `HttpMockService` instance.\r\n   * \r\n   * @param config The `HttpMockConfig` object to add to this `HttpMockService` instance.\r\n   * @Returns The `Uuid` instance associated with the added `HttpMockConfig` object.\r\n   */\r\n  public addConfig(config: HttpMockConfig): Uuid {\r\n    const origin: string = config.origin || this.APP_ORIGIN;\r\n    this.checkOrigin(origin);\r\n    let id: Uuid | undefined = config.id;\r\n    if (!id) {\r\n      id = Uuid.build();\r\n      config.id = id;\r\n    } else {\r\n      if (this.hasRegisteredConfig(id)) throw new HttpMockServiceError(`A config object has already been registered with the id: [\"${id.toString()}\"].`) ;\r\n    }\r\n    this._configIdList.push(id);\r\n    const uuid: string = id.toString();\r\n    config.interceptors.forEach((interceptor: HttpMockInterceptor) => this.extractConfig(interceptor, origin, uuid) );\r\n    return id;\r\n  }\r\n\r\n  /**\r\n   * Returns the current app URL origin.\r\n   * \r\n   * @returns A string that represents the current app URL origin.\r\n   */\r\n  public getAppOrigin(): string {\r\n    return this.APP_ORIGIN;\r\n  }\r\n\r\n  /**\r\n   * Removes the configuration registered with the specified `uuid` from this `HttpMockService` instance.\r\n   * \r\n   * @param uuid The UUID of the configuration to remove.\r\n   */\r\n  public removeConfig(uuid: Uuid): void {\r\n    if (!this.hasRegisteredConfig(uuid)) return;\r\n    const configId: string = uuid.toString();\r\n    this._configList.forEach((value: Map<string, HttpMockEndpointStorage[]>, key: string) => {\r\n      this.deleteConfigById(value, configId);\r\n      if (value.size === 0) this._configList.delete(key);\r\n    });\r\n    this._configIdList.splice(this._configIdList.indexOf(uuid), 1);\r\n  }\r\n\r\n  /**\r\n   * Removes all registred configurations from this `HttpMockService` instance.\r\n   */\r\n  public clearConfigs(): void {\r\n    this._configList.clear();\r\n    this._configIdList.length = 0;\r\n  }\r\n  /**\r\n   * Returns a boolean value that indicates whether a config with the specified UUID has been registered\r\n   * (`true`), or not (`false`).\r\n   * \r\n   * @param uuid The UUID of the config to check.\r\n   * @returns `true` whether a config with the specified UUID has been registered; `false` otherwise.\r\n   */\r\n  public hasRegisteredConfig(uuid: Uuid): boolean {\r\n    return this._configIdList.indexOf(uuid) !== -1;\r\n  }\r\n\r\n  /**\r\n   * Returns the `RouteMockConfig` object associated with the specified `URL` instance and HTTP method.\r\n   * \r\n   * @param url The `URL` instance for which to find a route config.\r\n   * @param method The HTTP method for which to find a route config.\r\n   * @returns The `RouteMockConfig` object associated with the specified `URL` instance and HTTP method whether it exists;\r\n   *          `undefined` otherwise.\r\n   */\r\n  public getRouteConfig(url: URL, method: HTTPMethodRef): RouteMockConfig | undefined {\r\n    const urlConfigList: Map<string, HttpMockEndpointStorage[]> | undefined = this._configList.get(url.origin);\r\n    const route: string = url.pathname;\r\n    let result: RouteMockConfig | undefined = undefined;\r\n    if (!urlConfigList) return result;\r\n    const methodList: HttpMockEndpointStorage[] | undefined = urlConfigList.get(method);\r\n    if (!methodList) return result;\r\n    let len: number = methodList.length - 1;\r\n    while (len >= 0 ) {\r\n      const methodMap: HttpMockEndpointStorage = methodList[len];\r\n      const regexp: RegExp = methodMap.regexp;\r\n      if (regexp.test(route)) {\r\n        result = {\r\n          methodConfig: methodMap.methodMock,\r\n          parameters: this.buildParameters(regexp, methodMap.keys, route),\r\n          searchParams: url.searchParams\r\n        };\r\n        break;\r\n      }\r\n      len--;\r\n    }\r\n    return result;\r\n  }\r\n\r\n  /**\r\n   * @rivate \r\n   */\r\n  private buildParameters(regexp: RegExp, keys: Key[], route: string): any {\r\n    const execResult: RegExpExecArray | null = regexp.exec(route);\r\n    if (!execResult) return null;\r\n    const params: any = {};\r\n    let len: number = execResult.length - 1;\r\n    let i: number = 1;\r\n    for (; i <= len; ++i) {\r\n      const key: Key = keys[i - 1];\r\n      params[key.name] = execResult[i];\r\n    }\r\n    return params;\r\n  }\r\n\r\n  /**\r\n   * @rivate \r\n   */\r\n  private extractConfig(interceptor: HttpMockInterceptor, globalOrigin: string, configId: string): void {\r\n    const endpoints: HttpMockEndpoint[] = interceptor.endpoints;\r\n    let origin: string | undefined = interceptor.origin;\r\n    if (origin) this.checkOrigin(origin);\r\n    else origin = globalOrigin;\r\n    if (!this._configList.has(origin)) this._configList.set(origin, new Map<string, HttpMockEndpointStorage[]>());\r\n    endpoints.forEach((endpoint: HttpMockEndpoint) => {\r\n      this.extractEndpointConfig(origin, endpoint, HTTPMethodRef.GET, configId);\r\n      this.extractEndpointConfig(origin, endpoint, HTTPMethodRef.POST, configId);\r\n      this.extractEndpointConfig(origin, endpoint, HTTPMethodRef.PUT, configId);\r\n      this.extractEndpointConfig(origin, endpoint, HTTPMethodRef.DELETE, configId);\r\n      this.extractEndpointConfig(origin, endpoint, HTTPMethodRef.HEAD, configId);\r\n      this.extractEndpointConfig(origin, endpoint, HTTPMethodRef.OPTIONS, configId);\r\n      this.extractEndpointConfig(origin, endpoint, HTTPMethodRef.PATCH, configId);\r\n      this.extractEndpointConfig(origin, endpoint, HTTPMethodRef.CONNECT, configId);\r\n      this.extractEndpointConfig(origin, endpoint, HTTPMethodRef.TRACE, configId);\r\n    });\r\n  }\r\n\r\n  /**\r\n   * @rivate \r\n   */\r\n  private extractEndpointConfig(origin: string, endpoint: HttpMockEndpoint, method: HTTPMethodRef, configId: string): void {\r\n    const ep: any = endpoint;\r\n    if (!ep[method as any]) return;\r\n    const originConfig: Map<string, HttpMockEndpointStorage[]> = this._configList.get(origin) as any;\r\n    const route: string = endpoint.route;\r\n    const data: TokenData = stringToTokenData(route);\r\n    const keys: Key[] = [];\r\n    const regexp: RegExp = tokenDataToRegexp(data, keys, {});\r\n    if (!originConfig.has(method)) originConfig.set(method, []);\r\n    const methodConfig: HttpMockEndpointStorage[] = originConfig.get(method) as any;\r\n    methodConfig.push({\r\n      regexp: regexp,\r\n      keys: keys,\r\n      methodMock: ep[method],\r\n      configId: configId\r\n    });\r\n  }\r\n\r\n  /**\r\n   * @rivate \r\n   */\r\n  private checkOrigin(origin: string): void {\r\n    if (origin.endsWith(DEFAULT_DELIMITER)) throw new SyntaxError(`Origin must not end with a / character: [\"${origin}\"].`);\r\n  }\r\n  \r\n  /**\r\n   * @rivate \r\n   */\r\n  private deleteConfigById(storageMap: Map<string, HttpMockEndpointStorage[]>, configId: string): void {\r\n    storageMap.forEach((storage: HttpMockEndpointStorage[], key: string) => {\r\n      const cleanedConfig: HttpMockEndpointStorage[] = this.cleanConfig(storage, configId);\r\n      if (cleanedConfig.length) storageMap.set(key, cleanedConfig);\r\n      else storageMap.delete(key);\r\n    });\r\n  }\r\n\r\n  /**\r\n   * @rivate \r\n   */\r\n  private cleanConfig(storage: HttpMockEndpointStorage[], configId: string): HttpMockEndpointStorage[] {\r\n    return storage.filter((value: HttpMockEndpointStorage)=> value.configId !== configId);\r\n  }\r\n}\r\n"]}

package/esm2022/lib/model/service/version/angular-toolbox-version.service.mjs

@@ -14,9 +14,9 @@ import * as i0 from "@angular/core";
  */
 const LAYERS_VERSION_CONFIG = {
     major: 0,
-    minor: 10,
-    patch: 2,
-    buildTimestamp: 1721804425756,
+    minor: 11,
+    patch: 1,
+    buildTimestamp: 1722003985958,
     metadata: "beta"
 };
 /**
@@ -35,4 +35,4 @@ export class AngularToolboxVersionService extends AbstractVersionManager {
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.3", ngImport: i0, type: AngularToolboxVersionService, decorators: [{
             type: Injectable
         }], ctorParameters: () => [] });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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