angular-toolbox 0.0.8 → 0.9.0

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

@@ -0,0 +1,117 @@
+/**
+ * @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 { HttpStatusCode } from "@angular/common/http";
+/**
+ * @private
+ */
+const OK = "OK";
+/**
+ * A statefull builder for creating new `HttpResponseMock` instances.
+ */
+export class HttpResponseMockBuilder {
+    constructor() {
+        /**
+         * @private
+         */
+        this._response = {
+            url: null,
+            body: null,
+            status: HttpStatusCode.Ok,
+            statusText: OK,
+            error: null,
+            delay: 0
+        };
+    }
+    /**
+     * Sets the body property of the new `HttpResponseMock` instance with the specified `body` value.
+     *
+     * @param body The value used to set the body property of the new `HttpResponseMock` instance.
+     *
+     * @returns A reference to this `HttpResponseMockBuilder` instance.
+     */
+    body(body) {
+        this._response.body = body;
+        return this;
+    }
+    /**
+     * Sets the headers property of the new `HttpResponseMock` instance with the specified `headers` value.
+     *
+     * @param headers The value used to set the `headers` property of the new `HttpResponseMock` instance.
+     *
+     * @returns A reference to this `HttpResponseMockBuilder` instance.
+     */
+    headers(headers) {
+        this._response.headers = headers;
+        return this;
+    }
+    /**
+     * Sets the `status` property of the new `HttpResponseMock` instance with the specified `status` value.
+     *
+     * @param status The value used to set the `status` property of the new `HttpResponseMock` instance.
+     *
+     * @returns A reference to this `HttpResponseMockBuilder` instance.
+     */
+    status(status) {
+        this._response.status = status;
+        return this;
+    }
+    /**
+     * Sets the `statusText` property of the new `HttpResponseMock` instance with the specified `statusText` value.
+     *
+     * @param statusText The value used to set the `statusText` property of the new `HttpResponseMock` instance.
+     *
+     * @returns A reference to this `HttpResponseMockBuilder` instance.
+     */
+    statusText(statusText) {
+        this._response.statusText = statusText;
+        return this;
+    }
+    /**
+     * Sets the `url` property of the new `HttpResponseMock` instance with the specified `url` value.
+     *
+     * @param url The value used to set the `url` property of the new `HttpResponseMock` instance.
+     *
+     * @returns A reference to this `HttpResponseMockBuilder` instance.
+     */
+    url(url) {
+        this._response.url = url;
+        return this;
+    }
+    /**
+     * Sets the `delay` property of the new `HttpResponseMock` instance with the specified `timer` duration.
+     * Maximum value is `10000` miliseconds (10 seconds).
+     *
+     * @param timer The value used to set the `delay` property of the new `HttpResponseMock` instance.
+     *
+     * @returns A reference to this `HttpResponseMockBuilder` instance.
+     */
+    delay(timer = 0) {
+        this._response.delay = timer;
+        return this;
+    }
+    /**
+     * Returns a new `HttpResponseMock` instance, built from the properties specified with the
+     * `HttpResponseMockBuilder` methods.
+     *
+     * @param error An optional value used to set the `error` property of the new `HttpResponseMock` instance.
+     *              The `error` parameter values take precedence over all other properties of the `HttpResponseMock`
+     *              instance.
+     * @returns A new `HttpResponseMock` instance.
+     */
+    response(error = null) {
+        this._response.error = error;
+        return this._response;
+    }
+}
+/**
+ * A utility function used to create new "chainable" `HttpResponseMockBuilder` instances.
+ *
+ * @returns A new `HttpResponseMockBuilder` instance.
+ */
+export const httpResponseMock = () => new HttpResponseMockBuilder();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"http-mock-response.builder.js","sourceRoot":"","sources":["../../../../../../../../projects/angular-toolbox/src/lib/framework/mock/http/util/http-mock-response.builder.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAe,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAGnE;;GAEG;AACH,MAAM,EAAE,GAAW,IAAI,CAAC;AAExB;;GAEG;AACH,MAAM,OAAO,uBAAuB;IAApC;QAEI;;WAEG;QACK,cAAS,GAAqB;YAClC,GAAG,EAAE,IAAI;YACT,IAAI,EAAE,IAAI;YACV,MAAM,EAAE,cAAc,CAAC,EAAE;YACzB,UAAU,EAAE,EAAE;YACd,KAAK,EAAE,IAAI;YACX,KAAK,EAAE,CAAC;SACX,CAAC;IAwFN,CAAC;IAtFG;;;;;;OAMG;IACI,IAAI,CAAC,IAAS;QACjB,IAAI,CAAC,SAAS,CAAC,IAAI,GAAG,IAAI,CAAC;QAC3B,OAAO,IAAI,CAAC;IAChB,CAAC;IAED;;;;;;OAMG;IACI,OAAO,CAAC,OAAoB;QAC/B,IAAI,CAAC,SAAS,CAAC,OAAO,GAAG,OAAO,CAAC;QACjC,OAAO,IAAI,CAAC;IAChB,CAAC;IAED;;;;;;OAMG;IACI,MAAM,CAAC,MAAc;QACxB,IAAI,CAAC,SAAS,CAAC,MAAM,GAAG,MAAM,CAAC;QAC/B,OAAO,IAAI,CAAC;IAChB,CAAC;IAED;;;;;;OAMG;IACI,UAAU,CAAC,UAAkB;QAChC,IAAI,CAAC,SAAS,CAAC,UAAU,GAAG,UAAU,CAAC;QACvC,OAAO,IAAI,CAAC;IAChB,CAAC;IAED;;;;;;OAMG;IACI,GAAG,CAAC,GAAkB;QACzB,IAAI,CAAC,SAAS,CAAC,GAAG,GAAG,GAAG,CAAC;QACzB,OAAO,IAAI,CAAC;IAChB,CAAC;IAED;;;;;;;OAOG;IACI,KAAK,CAAC,QAAgB,CAAC;QAC1B,IAAI,CAAC,SAAS,CAAC,KAAK,GAAG,KAAK,CAAC;QAC7B,OAAO,IAAI,CAAC;IAChB,CAAC;IAED;;;;;;;;OAQG;IACI,QAAQ,CAAC,QAA8B,IAAI;QAC9C,IAAI,CAAC,SAAS,CAAC,KAAK,GAAG,KAAK,CAAC;QAC7B,OAAO,IAAI,CAAC,SAAS,CAAC;IAC1B,CAAC;CACJ;AAED;;;;GAIG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAgC,GAAE,EAAE,CAAC,IAAI,uBAAuB,EAAE,CAAC","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, HttpStatusCode } from \"@angular/common/http\";\r\nimport { HttpMockError, HttpResponseMock } from \"../../../../model\";\r\n\r\n/**\r\n * @private\r\n */\r\nconst OK: string = \"OK\";\r\n\r\n/**\r\n * A statefull builder for creating new `HttpResponseMock` instances.\r\n */\r\nexport class HttpResponseMockBuilder {\r\n\r\n    /**\r\n     * @private\r\n     */\r\n    private _response: HttpResponseMock = {\r\n        url: null,\r\n        body: null,\r\n        status: HttpStatusCode.Ok,\r\n        statusText: OK,\r\n        error: null,\r\n        delay: 0\r\n    };\r\n\r\n    /**\r\n     * Sets the body property of the new `HttpResponseMock` instance with the specified `body` value.\r\n     * \r\n     * @param body The value used to set the body property of the new `HttpResponseMock` instance.\r\n     * \r\n     * @returns A reference to this `HttpResponseMockBuilder` instance.\r\n     */\r\n    public body(body: any): HttpResponseMockBuilder {\r\n        this._response.body = body;\r\n        return this;\r\n    }\r\n\r\n    /**\r\n     * Sets the headers property of the new `HttpResponseMock` instance with the specified `headers` value.\r\n     * \r\n     * @param headers The value used to set the `headers` property of the new `HttpResponseMock` instance.\r\n     * \r\n     * @returns A reference to this `HttpResponseMockBuilder` instance.\r\n     */\r\n    public headers(headers: HttpHeaders): HttpResponseMockBuilder {\r\n        this._response.headers = headers;\r\n        return this;\r\n    }\r\n\r\n    /**\r\n     * Sets the `status` property of the new `HttpResponseMock` instance with the specified `status` value.\r\n     * \r\n     * @param status The value used to set the `status` property of the new `HttpResponseMock` instance.\r\n     * \r\n     * @returns A reference to this `HttpResponseMockBuilder` instance.\r\n     */\r\n    public status(status: number): HttpResponseMockBuilder {\r\n        this._response.status = status;\r\n        return this;\r\n    }\r\n\r\n    /**\r\n     * Sets the `statusText` property of the new `HttpResponseMock` instance with the specified `statusText` value.\r\n     * \r\n     * @param statusText The value used to set the `statusText` property of the new `HttpResponseMock` instance.\r\n     * \r\n     * @returns A reference to this `HttpResponseMockBuilder` instance.\r\n     */\r\n    public statusText(statusText: string): HttpResponseMockBuilder {\r\n        this._response.statusText = statusText;\r\n        return this;\r\n    }\r\n\r\n    /**\r\n     * Sets the `url` property of the new `HttpResponseMock` instance with the specified `url` value.\r\n     * \r\n     * @param url The value used to set the `url` property of the new `HttpResponseMock` instance.\r\n     * \r\n     * @returns A reference to this `HttpResponseMockBuilder` instance.\r\n     */\r\n    public url(url: string | null): HttpResponseMockBuilder {\r\n        this._response.url = url;\r\n        return this;\r\n    }\r\n\r\n    /**\r\n     * Sets the `delay` property of the new `HttpResponseMock` instance with the specified `timer` duration.\r\n     * Maximum value is `10000` miliseconds (10 seconds).\r\n     * \r\n     * @param timer The value used to set the `delay` property of the new `HttpResponseMock` instance.\r\n     * \r\n     * @returns A reference to this `HttpResponseMockBuilder` instance.\r\n     */\r\n    public delay(timer: number = 0): HttpResponseMockBuilder {\r\n        this._response.delay = timer;\r\n        return this;\r\n    }\r\n\r\n    /**\r\n     * Returns a new `HttpResponseMock` instance, built from the properties specified with the\r\n     * `HttpResponseMockBuilder` methods.\r\n     * \r\n     * @param error An optional value used to set the `error` property of the new `HttpResponseMock` instance.\r\n     *              The `error` parameter values take precedence over all other properties of the `HttpResponseMock`\r\n     *              instance.\r\n     * @returns A new `HttpResponseMock` instance.\r\n     */\r\n    public response(error: HttpMockError | null = null): HttpResponseMock {\r\n        this._response.error = error;\r\n        return this._response;\r\n    }\r\n}\r\n\r\n/**\r\n * A utility function used to create new \"chainable\" `HttpResponseMockBuilder` instances.\r\n * \r\n * @returns A new `HttpResponseMockBuilder` instance.\r\n */\r\nexport const httpResponseMock:()=> HttpResponseMockBuilder = ()=> new HttpResponseMockBuilder();"]}

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

@@ -0,0 +1,3 @@
+export * from './http-mock-response.builder';
+export * from './http-headers-mock.builder';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9hbmd1bGFyLXRvb2xib3gvc3JjL2xpYi9mcmFtZXdvcmsvbW9jay9odHRwL3V0aWwvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyw4QkFBOEIsQ0FBQztBQUM3QyxjQUFjLDZCQUE2QixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9odHRwLW1vY2stcmVzcG9uc2UuYnVpbGRlcic7XHJcbmV4cG9ydCAqIGZyb20gJy4vaHR0cC1oZWFkZXJzLW1vY2suYnVpbGRlcic7Il19

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

@@ -0,0 +1,316 @@
+/**
+ * @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 { HttpHeaders, HttpRequest, HttpStatusCode } from "@angular/common/http";
+import { ProgressEventMock } from "../event/progress-event-mock";
+import { EMPTY_STRING } from "../../../../util";
+import { XhrBase } from "./xhr-base";
+import { HttpHeadersUtil } from "../util/http-headers.util";
+import { Observable, of } from "rxjs";
+import { DataStorageBuilder } from "../util/data-storage.builder";
+/**
+ * @private
+ * The maximum value for a delayed HTTP response.
+ */
+const MAX_TIMER = 10000;
+/**
+ * @private
+ * Intenal "onreadystatechange" event.
+ */
+const READY_STATE_CHANGE_EVENT = new Event("onreadystatechange");
+/**
+ * @private
+ */
+const EVT_PROPS_CONFIG = { writable: false, value: this };
+/**
+ * @private
+ * A utility class used as delegate of `XMLHttpRequest` functionalities when
+ * a HTTP request is intercepted by the Mocking Framework .
+ */
+export class DelegateXhr extends XhrBase {
+    /**
+     * Returns the response body content.
+     *
+     * @see https://developer.mozilla.org/docs/Web/API/XMLHttpRequest/response
+     */
+    get response() {
+        return this._dataStorage?.data || null;
+    }
+    /**
+     * Returns the numerical HTTP status code of the `XMLHttpRequest` response.
+     *
+     * @see https://developer.mozilla.org/docs/Web/API/XMLHttpRequest/status
+     */
+    get status() {
+        return this._status;
+    }
+    /**
+     * Returns a string containing the response status message as returned by the HTTP server.
+     *
+     * @see https://developer.mozilla.org/docs/Web/API/XMLHttpRequest/statusText
+     */
+    get statusText() {
+        return this._statusText;
+    }
+    /**
+     * Returns the state the `XMLHttpRequest` client is in.
+     *
+     * @see https://developer.mozilla.org/docs/Web/API/XMLHttpRequest/readyState
+     */
+    get readyState() {
+        return this._readyState;
+    }
+    /**
+     * Returns the serialized URL of the response or the empty string if the URL is `null`.
+     *
+     * @see https://developer.mozilla.org/docs/Web/API/XMLHttpRequest/responseURL
+     */
+    get responseURL() {
+        return this._url;
+    }
+    /**
+     * Returns the text received from a server following a request being sent.
+     *
+     * Throws an `InvalidStateError` DOMException if responseType is not the empty string or "text".
+     *
+     * @see https://developer.mozilla.org/docs/Web/API/XMLHttpRequest/responseText
+     */
+    get responseText() {
+        return this._dataStorage?.stringifiedData || EMPTY_STRING;
+    }
+    /**
+     *  Returns an `XMLHttpRequestUpload` object that can be observed to monitor an upload progress.
+     *
+     * @see https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest/upload
+     */
+    get upload() {
+        return null;
+    }
+    /**
+     * @private
+     */
+    open(method, url, async, username, password) {
+        this._method = method;
+        this._url = url;
+        this.setReadyState(this.OPENED);
+    }
+    /**
+     * Aborts the request if it has already been sent. When a request is aborted, its `readyState`
+     * is changed to `XMLHttpRequest.UNSENT` and the request status code is set to `0`.
+     */
+    abort() {
+        this._readyState = this.UNSENT;
+        this._status = 0;
+        this.eventDispatch("abort");
+    }
+    /**
+     * Returns all the response headers, separated by CRLF, as a string, or returns `null`
+     * if no response has been received.
+     *
+     * @returns All the response headers, separated by CRLF, as a string, or returns `null`
+     *          if no response has been received.
+     */
+    getAllResponseHeaders() {
+        return this._dataStorage ? HttpHeadersUtil.stringify(this._headers) : EMPTY_STRING;
+    }
+    /**
+     * Sends the request to the server.
+     *
+     * @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 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);
+        });
+    }
+    /**
+     * Sets the value of an HTTP request header.
+     *
+     * @param name The name of the header whose value is to be set.
+     * @param value The value to set as the body of the header.
+     */
+    setRequestHeader(name, value) {
+        this._headers = this._headers.set(name, value);
+    }
+    /**
+     * @private
+     */
+    constructor(routeConfig) {
+        super();
+        /**
+         * @private
+         * Indicates whether the progressive download is activated, or not.
+         */
+        this._progressiveDownload = false;
+        /**
+         * @private
+         *
+         * Internal storage for HTTP response `data`.
+         */
+        this._dataStorage = null;
+        /**
+         * @private
+         *
+         * Internal storage for the HTTP request `readyState`.
+         */
+        this._readyState = this.UNSENT;
+        /**
+         * @private
+         *
+         * Internal storage for the HTTP request `headers`.
+         */
+        this._headers = null;
+        /**
+         * @private
+         *
+         * Internal storage for the HTTP request `status`.
+         */
+        this._status = 0;
+        /**
+         * @private
+         *
+         * Internal storage for the HTTP request `statusText`.
+         */
+        this._statusText = EMPTY_STRING;
+        /**
+         * @private
+         */
+        this._loadSubscription = null;
+        /**
+         *  Returns an an enumerated string value specifying the type of data contained in the response.
+         *
+         * @see https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest/responseType
+         */
+        this.responseType = "";
+        const methodConfig = routeConfig.methodConfig;
+        this._routeConfig = routeConfig;
+        this._progressiveDownload = methodConfig.progressive || false;
+        this.responseType = methodConfig.responseType || "";
+        this._headers = new HttpHeaders();
+    }
+    /**
+     * @private
+     * Internally used by the framework to delete a `DelegateXhr` instance.
+     */
+    destroy() {
+        this._routeConfig = null;
+        this._headers = null;
+        this._dataStorage = null;
+        if (this._loadSubscription) {
+            this._loadSubscription.unsubscribe();
+            this._loadSubscription = null;
+        }
+    }
+    /**
+     * @private
+     */
+    doProgressiveDownload() {
+        const total = this._dataStorage.total;
+        if (total <= 200) {
+            console.warn("[Angular Toolbox]: Body content is too small for emulating progressive download! Minimum size is 200 octets.");
+            return this.onLoadComplete();
+        }
+        // TODO: ameliorate the following process:
+        const self = this;
+        const chunckSize = Math.floor(total / 10);
+        let cursor = 0;
+        this._statusText = "Partial Content";
+        this._status = HttpStatusCode.PartialContent;
+        const idx = setInterval(() => {
+            cursor += chunckSize;
+            if (cursor > total) {
+                cursor = total;
+                clearInterval(idx);
+                self.onLoadComplete();
+            }
+            else {
+                this._dataStorage.loaded = cursor;
+                self.dispatchProgressEvent();
+            }
+        }, 100);
+    }
+    /**
+     * @private
+     */
+    onLoadComplete() {
+        this._dataStorage.loaded = this._dataStorage.total;
+        this.setReadyState(this.DONE);
+        this.dispatchProgressEvent("load");
+    }
+    /**
+     * @private
+     */
+    onError(error) {
+        this._status = error.status;
+        this._statusText = error.statusText;
+        this.setReadyState(this.DONE);
+        this.dispatchProgressEvent("error");
+    }
+    /**
+     * @private
+     */
+    eventDispatch(type) {
+        const event = new Event(type);
+        Object.defineProperty(event, 'target', EVT_PROPS_CONFIG);
+        Object.defineProperty(event, 'currentTarget', EVT_PROPS_CONFIG);
+        this.dispatchEvent(event);
+    }
+    /**
+     * @private
+     */
+    dispatchProgressEvent(type = "progress") {
+        const d = this._dataStorage;
+        const event = new ProgressEventMock(type);
+        event.loaded = d.loaded;
+        event.total = d.total;
+        this.dispatchEvent(event);
+    }
+    /**
+     * @private
+     */
+    setReadyState(state) {
+        this._readyState = state;
+        const event = this.onreadystatechange;
+        if (event)
+            event.call(this, READY_STATE_CHANGE_EVENT);
+    }
+    /**
+     * @private
+     */
+    loadData(httpResponseMock) {
+        const responseBody = httpResponseMock.body;
+        return (responseBody instanceof Observable) ? responseBody : of(responseBody);
+    }
+}
+//# 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}"]}

package/esm2022/lib/framework/mock/http/xhr/http-mock-factory.impl.mjs

@@ -0,0 +1,29 @@
+/**
+ * @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 { XhrFactory } from "@angular/common";
+import { XhrProxyImpl } from "./xhr-proxy-impl";
+/**
+ * @private
+ * The concrete implementation of the `XhrFactory` interface.
+ */
+export class XhrProxyFactoryImpl extends XhrFactory {
+    /**
+     * @private
+     */
+    constructor(_httpMockService) {
+        super();
+        this._httpMockService = _httpMockService;
+    }
+    /**
+     * @private
+     */
+    build() {
+        return new XhrProxyImpl(this._httpMockService);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaHR0cC1tb2NrLWZhY3RvcnkuaW1wbC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2FuZ3VsYXItdG9vbGJveC9zcmMvbGliL2ZyYW1ld29yay9tb2NrL2h0dHAveGhyL2h0dHAtbW9jay1mYWN0b3J5LmltcGwudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7OztHQU1HO0FBRUgsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLGlCQUFpQixDQUFDO0FBRTdDLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxrQkFBa0IsQ0FBQztBQUVoRDs7O0dBR0c7QUFDSCxNQUFNLE9BQU8sbUJBQW9CLFNBQVEsVUFBVTtJQUUvQzs7T0FFRztJQUNILFlBQW9CLGdCQUFpQztRQUNqRCxLQUFLLEVBQUUsQ0FBQztRQURRLHFCQUFnQixHQUFoQixnQkFBZ0IsQ0FBaUI7SUFFckQsQ0FBQztJQUVEOztPQUVHO0lBQ0ksS0FBSztRQUNSLE9BQU8sSUFBSSxZQUFZLENBQUMsSUFBSSxDQUFDLGdCQUFnQixDQUFDLENBQUM7SUFDbkQsQ0FBQztDQUNKIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXHJcbiAqIEBsaWNlbnNlXHJcbiAqIENvcHlyaWdodCBQYXNjYWwgRUNIRU1BTk4uIEFsbCBSaWdodHMgUmVzZXJ2ZWQuXHJcbiAqXHJcbiAqIFVzZSBvZiB0aGlzIHNvdXJjZSBjb2RlIGlzIGdvdmVybmVkIGJ5IGFuIE1JVC1zdHlsZSBsaWNlbnNlIHRoYXQgY2FuIGJlIGZvdW5kIGluXHJcbiAqIHRoZSBMSUNFTlNFIGZpbGUgYXQgaHR0cHM6Ly9wYXNjYWxlY2hlbWFubi5jb20vYW5ndWxhci10b29sYm94L3Jlc291cmNlcy9saWNlbnNlXHJcbiAqL1xyXG5cclxuaW1wb3J0IHsgWGhyRmFjdG9yeSB9IGZyb20gXCJAYW5ndWxhci9jb21tb25cIjtcclxuaW1wb3J0IHsgSHR0cE1vY2tTZXJ2aWNlIH0gZnJvbSBcIi4uLy4uLy4uLy4uL21vZGVsL3NlcnZpY2UvbW9jay9odHRwL2h0dHAtbW9jay5zZXJ2aWNlXCI7XHJcbmltcG9ydCB7IFhoclByb3h5SW1wbCB9IGZyb20gXCIuL3hoci1wcm94eS1pbXBsXCI7XHJcblxyXG4vKipcclxuICogQHByaXZhdGVcclxuICogVGhlIGNvbmNyZXRlIGltcGxlbWVudGF0aW9uIG9mIHRoZSBgWGhyRmFjdG9yeWAgaW50ZXJmYWNlLlxyXG4gKi9cclxuZXhwb3J0IGNsYXNzIFhoclByb3h5RmFjdG9yeUltcGwgZXh0ZW5kcyBYaHJGYWN0b3J5IHtcclxuXHJcbiAgICAvKipcclxuICAgICAqIEBwcml2YXRlXHJcbiAgICAgKi9cclxuICAgIGNvbnN0cnVjdG9yKHByaXZhdGUgX2h0dHBNb2NrU2VydmljZTogSHR0cE1vY2tTZXJ2aWNlKSB7XHJcbiAgICAgICAgc3VwZXIoKTtcclxuICAgIH1cclxuXHJcbiAgICAvKipcclxuICAgICAqIEBwcml2YXRlXHJcbiAgICAgKi9cclxuICAgIHB1YmxpYyBidWlsZCgpOiBYTUxIdHRwUmVxdWVzdCB7XHJcbiAgICAgICAgcmV0dXJuIG5ldyBYaHJQcm94eUltcGwodGhpcy5faHR0cE1vY2tTZXJ2aWNlKTtcclxuICAgIH1cclxufVxyXG4iXX0=

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

@@ -0,0 +1,19 @@
+/**
+ * @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 { inject } from "@angular/core";
+import { HttpMockService } from "../../../../model/service/mock/http/http-mock.service";
+import { XhrProxyFactoryImpl } from "./http-mock-factory.impl";
+/**
+ * A factory function that creates and returns a new `XhrFactory` object.
+ *
+ * @returns A new `XhrFactory` object.
+ */
+export const httpMockFactory = () => {
+    return new XhrProxyFactoryImpl(inject(HttpMockService));
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaHR0cC1tb2NrLWZhY3RvcnkuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9hbmd1bGFyLXRvb2xib3gvc3JjL2xpYi9mcmFtZXdvcmsvbW9jay9odHRwL3hoci9odHRwLW1vY2stZmFjdG9yeS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7O0dBTUc7QUFFSCxPQUFPLEVBQUUsTUFBTSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQ3ZDLE9BQU8sRUFBRSxlQUFlLEVBQUUsTUFBTSx1REFBdUQsQ0FBQztBQUN4RixPQUFPLEVBQUUsbUJBQW1CLEVBQUUsTUFBTSwwQkFBMEIsQ0FBQztBQUUvRDs7OztHQUlHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sZUFBZSxHQUFHLEdBQUUsRUFBRTtJQUMvQixPQUFPLElBQUksbUJBQW1CLENBQUMsTUFBTSxDQUFDLGVBQWUsQ0FBQyxDQUFDLENBQUM7QUFDNUQsQ0FBQyxDQUFBIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXHJcbiAqIEBsaWNlbnNlXHJcbiAqIENvcHlyaWdodCBQYXNjYWwgRUNIRU1BTk4uIEFsbCBSaWdodHMgUmVzZXJ2ZWQuXHJcbiAqXHJcbiAqIFVzZSBvZiB0aGlzIHNvdXJjZSBjb2RlIGlzIGdvdmVybmVkIGJ5IGFuIE1JVC1zdHlsZSBsaWNlbnNlIHRoYXQgY2FuIGJlIGZvdW5kIGluXHJcbiAqIHRoZSBMSUNFTlNFIGZpbGUgYXQgaHR0cHM6Ly9wYXNjYWxlY2hlbWFubi5jb20vYW5ndWxhci10b29sYm94L3Jlc291cmNlcy9saWNlbnNlXHJcbiAqL1xyXG5cclxuaW1wb3J0IHsgaW5qZWN0IH0gZnJvbSBcIkBhbmd1bGFyL2NvcmVcIjtcclxuaW1wb3J0IHsgSHR0cE1vY2tTZXJ2aWNlIH0gZnJvbSBcIi4uLy4uLy4uLy4uL21vZGVsL3NlcnZpY2UvbW9jay9odHRwL2h0dHAtbW9jay5zZXJ2aWNlXCI7XHJcbmltcG9ydCB7IFhoclByb3h5RmFjdG9yeUltcGwgfSBmcm9tIFwiLi9odHRwLW1vY2stZmFjdG9yeS5pbXBsXCI7XHJcblxyXG4vKipcclxuICogQSBmYWN0b3J5IGZ1bmN0aW9uIHRoYXQgY3JlYXRlcyBhbmQgcmV0dXJucyBhIG5ldyBgWGhyRmFjdG9yeWAgb2JqZWN0LlxyXG4gKiBcclxuICogQHJldHVybnMgQSBuZXcgYFhockZhY3RvcnlgIG9iamVjdC5cclxuICovXHJcbmV4cG9ydCBjb25zdCBodHRwTW9ja0ZhY3RvcnkgPSAoKT0+IHtcclxuICAgIHJldHVybiBuZXcgWGhyUHJveHlGYWN0b3J5SW1wbChpbmplY3QoSHR0cE1vY2tTZXJ2aWNlKSk7XHJcbn1cclxuIl19

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

@@ -0,0 +1,2 @@
+export * from './http-mock-factory';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9hbmd1bGFyLXRvb2xib3gvc3JjL2xpYi9mcmFtZXdvcmsvbW9jay9odHRwL3hoci9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLHFCQUFxQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9odHRwLW1vY2stZmFjdG9yeSc7Il19