angular-toolbox 0.0.7 → 0.9.0

package/esm2022/lib/directive/content-renderer.directive.mjs

@@ -0,0 +1,61 @@
+/**
+ * @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 { Directive, EventEmitter, Output } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * @private
+ */
+const CHILD_LIST_TYPE = "childList";
+/**
+ * Allows injection of any value into an HTML element container (`div`, `button`, etc...).
+ * A rendered event is emitted after the injected content has been rendered and is
+ * available for DOM manipulation.
+ */
+export class ContentRendererDirective {
+    /**
+     * @private
+     */
+    constructor(_elmRef) {
+        this._elmRef = _elmRef;
+        /**
+         * Dispatches events when the content of the HTML element has been rendered.
+         */
+        this.rendered = new EventEmitter();
+        const nativeElement = this._elmRef.nativeElement;
+        this._observer = new MutationObserver((mutations) => {
+            mutations.forEach((mutation) => {
+                if (mutation.type === CHILD_LIST_TYPE)
+                    this.rendered.emit(nativeElement);
+            });
+        });
+    }
+    /**
+     * @private
+     */
+    ngOnDestroy() {
+        this._observer.disconnect();
+    }
+    /**
+     * @private
+     */
+    ngOnInit() {
+        this._observer.observe(this._elmRef.nativeElement, { attributes: false, childList: true, characterData: false });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.3", ngImport: i0, type: ContentRendererDirective, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.0.3", type: ContentRendererDirective, isStandalone: true, selector: "[contentRenderer]", outputs: { rendered: "rendered" }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.3", ngImport: i0, type: ContentRendererDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[contentRenderer]',
+                    standalone: true
+                }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }], propDecorators: { rendered: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/directive/index.mjs

@@ -0,0 +1,5 @@
+export * from './button-role.directive';
+export * from './navigate-to-url.directive';
+export * from './anchor-link.directive';
+export * from './content-renderer.directive';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9hbmd1bGFyLXRvb2xib3gvc3JjL2xpYi9kaXJlY3RpdmUvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyx5QkFBeUIsQ0FBQztBQUN4QyxjQUFjLDZCQUE2QixDQUFDO0FBQzVDLGNBQWMseUJBQXlCLENBQUM7QUFDeEMsY0FBYyw4QkFBOEIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vYnV0dG9uLXJvbGUuZGlyZWN0aXZlJztcclxuZXhwb3J0ICogZnJvbSAnLi9uYXZpZ2F0ZS10by11cmwuZGlyZWN0aXZlJztcclxuZXhwb3J0ICogZnJvbSAnLi9hbmNob3ItbGluay5kaXJlY3RpdmUnO1xyXG5leHBvcnQgKiBmcm9tICcuL2NvbnRlbnQtcmVuZGVyZXIuZGlyZWN0aXZlJzsiXX0=

package/esm2022/lib/directive/navigate-to-url.directive.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 { DOCUMENT } from '@angular/common';
+import { Directive, HostListener, Inject, Input } from '@angular/core';
+import { LINK_ROLE } from '../util';
+import { NavigationDirectiveBase } from './navigation-directive-base';
+import * as i0 from "@angular/core";
+/**
+ * An easy-to-use directive that enables keyboard navigation and provides support for navigating to an external URL.
+ */
+export class NavigateToUrlDirective extends NavigationDirectiveBase {
+    /**
+     * @private
+     */
+    onClick() {
+        const HREF = this.href;
+        if (!HREF)
+            throw new ReferenceError("href attribute is not defined.");
+        this._document.defaultView.location.href = HREF;
+    }
+    /**
+     * @private
+     */
+    constructor(_document, elmRef) {
+        super(elmRef, LINK_ROLE);
+        this._document = _document;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.3", ngImport: i0, type: NavigateToUrlDirective, deps: [{ token: DOCUMENT }, { token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.0.3", type: NavigateToUrlDirective, isStandalone: true, selector: "[navigateToUrl]", inputs: { href: "href" }, host: { listeners: { "click": "onClick()" } }, usesInheritance: true, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.3", ngImport: i0, type: NavigateToUrlDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[navigateToUrl]',
+                    standalone: true
+                }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }, { type: i0.ElementRef }], propDecorators: { href: [{
+                type: Input
+            }], onClick: [{
+                type: HostListener,
+                args: ['click']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/directive/navigation-directive-base.mjs

@@ -0,0 +1,23 @@
+/**
+ * @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
+ */
+/**
+ * @private
+ * The base class for all directives that are responsible for navigation whithin ab Angular app.
+ */
+export class NavigationDirectiveBase {
+    /**
+     * @private
+     */
+    constructor(elmRef, role) {
+        this.elmRef = elmRef;
+        const elm = elmRef.nativeElement;
+        elm.role = role;
+        elm.tabIndex = 0;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmF2aWdhdGlvbi1kaXJlY3RpdmUtYmFzZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2FuZ3VsYXItdG9vbGJveC9zcmMvbGliL2RpcmVjdGl2ZS9uYXZpZ2F0aW9uLWRpcmVjdGl2ZS1iYXNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7R0FNRztBQUlIOzs7R0FHRztBQUNILE1BQU0sT0FBTyx1QkFBdUI7SUFFbEM7O09BRUc7SUFDSCxZQUFzQixNQUFrQixFQUFFLElBQVk7UUFBaEMsV0FBTSxHQUFOLE1BQU0sQ0FBWTtRQUN0QyxNQUFNLEdBQUcsR0FBZ0IsTUFBTSxDQUFDLGFBQWEsQ0FBQztRQUM5QyxHQUFHLENBQUMsSUFBSSxHQUFHLElBQUksQ0FBQztRQUNoQixHQUFHLENBQUMsUUFBUSxHQUFHLENBQUMsQ0FBQztJQUNuQixDQUFDO0NBQ0YiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcclxuICogQGxpY2Vuc2VcclxuICogQ29weXJpZ2h0IFBhc2NhbCBFQ0hFTUFOTi4gQWxsIFJpZ2h0cyBSZXNlcnZlZC5cclxuICpcclxuICogVXNlIG9mIHRoaXMgc291cmNlIGNvZGUgaXMgZ292ZXJuZWQgYnkgYW4gTUlULXN0eWxlIGxpY2Vuc2UgdGhhdCBjYW4gYmVcclxuICogZm91bmQgaW4gdGhlIExJQ0VOU0UgZmlsZSBhdCBodHRwczovL3Bhc2NhbGVjaGVtYW5uLmNvbS9hbmd1bGFyLXRvb2xib3gvcmVzb3VyY2VzL2xpY2Vuc2VcclxuICovXHJcblxyXG5pbXBvcnQgeyBFbGVtZW50UmVmIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XHJcblxyXG4vKipcclxuICogQHByaXZhdGVcclxuICogVGhlIGJhc2UgY2xhc3MgZm9yIGFsbCBkaXJlY3RpdmVzIHRoYXQgYXJlIHJlc3BvbnNpYmxlIGZvciBuYXZpZ2F0aW9uIHdoaXRoaW4gYWIgQW5ndWxhciBhcHAuXHJcbiAqL1xyXG5leHBvcnQgY2xhc3MgTmF2aWdhdGlvbkRpcmVjdGl2ZUJhc2Uge1xyXG5cclxuICAvKipcclxuICAgKiBAcHJpdmF0ZVxyXG4gICAqL1xyXG4gIGNvbnN0cnVjdG9yKHByb3RlY3RlZCBlbG1SZWY6IEVsZW1lbnRSZWYsIHJvbGU6IHN0cmluZykge1xyXG4gICAgY29uc3QgZWxtOiBIVE1MRWxlbWVudCA9IGVsbVJlZi5uYXRpdmVFbGVtZW50O1xyXG4gICAgZWxtLnJvbGUgPSByb2xlO1xyXG4gICAgZWxtLnRhYkluZGV4ID0gMDtcclxuICB9XHJcbn1cclxuIl19

package/esm2022/lib/framework/index.mjs

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

package/esm2022/lib/framework/mock/http/config/http-mock-parameters.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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaHR0cC1tb2NrLXBhcmFtZXRlcnMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9hbmd1bGFyLXRvb2xib3gvc3JjL2xpYi9mcmFtZXdvcmsvbW9jay9odHRwL2NvbmZpZy9odHRwLW1vY2stcGFyYW1ldGVycy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7O0dBTUciLCJzb3VyY2VzQ29udGVudCI6WyIvKipcclxuICogQGxpY2Vuc2VcclxuICogQ29weXJpZ2h0IFBhc2NhbCBFQ0hFTUFOTi4gQWxsIFJpZ2h0cyBSZXNlcnZlZC5cclxuICpcclxuICogVXNlIG9mIHRoaXMgc291cmNlIGNvZGUgaXMgZ292ZXJuZWQgYnkgYW4gTUlULXN0eWxlIGxpY2Vuc2UgdGhhdCBjYW4gYmUgZm91bmQgaW5cclxuICogdGhlIExJQ0VOU0UgZmlsZSBhdCBodHRwczovL3Bhc2NhbGVjaGVtYW5uLmNvbS9hbmd1bGFyLXRvb2xib3gvcmVzb3VyY2VzL2xpY2Vuc2VcclxuICovXHJcblxyXG4vKipcclxuICogVGhlIHR5cGUgb2YgcGFyYW1ldGVyIG9iamVjdHMgYXNzb2NpYXRlZCB3aXRoIGEgSFRUUCBjYWxsLlxyXG4gKi9cclxuZXhwb3J0IHR5cGUgSHR0cE1vY2tQYXJhbWV0ZXJzID0geyBba2V5OiBzdHJpbmddOiBhbnkgfTtcclxuIl19

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

@@ -0,0 +1,48 @@
+/**
+ * @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 { Uuid } from "../../../../util";
+import { HTTP_MOCK_SERVICE } from "../../../../model";
+/**
+ * The definition function for the `@HttpMock` decorator.
+ *
+ * @param config The `HttpMockConfig` object used to initialize the HTTP Mocking Framework.
+ */
+export const HttpMock = (config) => {
+    return (constructor) => {
+        const getMockService = (instance) => {
+            return Object.values(instance).find((v) => {
+                return (v.hasOwnProperty('type') && v.type === HTTP_MOCK_SERVICE);
+            });
+        };
+        const ngOnInit = constructor.prototype.ngOnInit;
+        const ngOnDestroy = constructor.prototype.ngOnDestroy;
+        const uiid = config.id || Uuid.build();
+        if (!ngOnDestroy)
+            throw new ReferenceError("Component must implement the OnDestroy interface.");
+        if (!ngOnInit)
+            throw new ReferenceError("Component must implement the OnInit interface.");
+        if (!config.id)
+            config.id = uiid;
+        constructor.prototype.ngOnInit = function () {
+            const mockService = getMockService(this);
+            if (!mockService)
+                throw new ReferenceError("No provider found for HttpMockService.");
+            mockService.addConfig(config);
+            ngOnInit.call(this);
+        };
+        constructor.prototype.ngOnDestroy = function () {
+            const mockService = getMockService(this);
+            // An exception is already thrown by the ngOnInit() method when HttpMockService is not provided.
+            // Following check statement prevents failure during Unit Testing:
+            if (mockService)
+                mockService.removeConfig(uiid);
+            ngOnDestroy.call(this);
+        };
+    };
+};
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,3 @@
+export * from './http-mock-parameters';
+export * from './http-mock.decorator';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9hbmd1bGFyLXRvb2xib3gvc3JjL2xpYi9mcmFtZXdvcmsvbW9jay9odHRwL2NvbmZpZy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxjQUFjLHdCQUF3QixDQUFDO0FBQ3ZDLGNBQWMsdUJBQXVCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJcclxuZXhwb3J0ICogZnJvbSAnLi9odHRwLW1vY2stcGFyYW1ldGVycyc7XHJcbmV4cG9ydCAqIGZyb20gJy4vaHR0cC1tb2NrLmRlY29yYXRvcic7Il19

package/esm2022/lib/framework/mock/http/config/route-mock-config.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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicm91dGUtbW9jay1jb25maWcuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9hbmd1bGFyLXRvb2xib3gvc3JjL2xpYi9mcmFtZXdvcmsvbW9jay9odHRwL2NvbmZpZy9yb3V0ZS1tb2NrLWNvbmZpZy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7O0dBTUciLCJzb3VyY2VzQ29udGVudCI6WyIvKipcclxuICogQGxpY2Vuc2VcclxuICogQ29weXJpZ2h0IFBhc2NhbCBFQ0hFTUFOTi4gQWxsIFJpZ2h0cyBSZXNlcnZlZC5cclxuICpcclxuICogVXNlIG9mIHRoaXMgc291cmNlIGNvZGUgaXMgZ292ZXJuZWQgYnkgYW4gTUlULXN0eWxlIGxpY2Vuc2UgdGhhdCBjYW4gYmUgZm91bmQgaW5cclxuICogdGhlIExJQ0VOU0UgZmlsZSBhdCBodHRwczovL3Bhc2NhbGVjaGVtYW5uLmNvbS9hbmd1bGFyLXRvb2xib3gvcmVzb3VyY2VzL2xpY2Vuc2VcclxuICovXHJcblxyXG5pbXBvcnQgeyBIdHRwTWV0aG9kTW9jayB9IGZyb20gXCIuLi8uLi8uLi8uLi9tb2RlbFwiO1xyXG5pbXBvcnQgeyBIdHRwTW9ja1BhcmFtZXRlcnMgfSBmcm9tIFwiLi9odHRwLW1vY2stcGFyYW1ldGVyc1wiO1xyXG5cclxuLyoqXHJcbiAqIEBwcml2YXRlXHJcbiAqIFxyXG4gKiBUaGUgbWFya3VwIGludGVyZmFjZSBmb3IgRFRPcyB0aGF0IGFyZSB1c2VkIHRvIHNlbmQgYSBtb2NrIGNvbmZpZyB0byB0aGUgZGVsZWdhdGVcclxuICogYFhoclByb3h5YCBpbnN0YW5jZS5cclxuICogVGhpcyBpbnRlcmZhY2UgaXMgbm90IGV4cG9zZWQuXHJcbiAqL1xyXG5leHBvcnQgaW50ZXJmYWNlIFJvdXRlTW9ja0NvbmZpZyB7XHJcblxyXG4gICAgLyoqXHJcbiAgICAgKiBAcHJpdmF0ZVxyXG4gICAgICogXHJcbiAgICAgKiBUaGUgYEh0dHBNZXRob2RNb2NrYG9iamVjdCB0byBiZSBjb25zdW1lZCBieSB0aGUgdGhlIGRlbGVnYXRlIGBYaHJQcm94eWAgaW5zdGFuY2UuXHJcbiAgICAgKi9cclxuICAgIG1ldGhvZENvbmZpZzogSHR0cE1ldGhvZE1vY2s7XHJcbiAgICBcclxuICAgIC8qKlxyXG4gICAgICogQHByaXZhdGVcclxuICAgICAqIFxyXG4gICAgICogVGhlIGxpc3Qgb2YgVVJJIHBhcmFtZXRlcnMgYXNzb2NpYXRlZCB3aXRoIHRoZSBjdXJyZW50IEhUVFAgY2FsbC5cclxuICAgICAqL1xyXG4gICAgcGFyYW1ldGVyczogSHR0cE1vY2tQYXJhbWV0ZXJzIHwgbnVsbDtcclxufSJdfQ==

package/esm2022/lib/framework/mock/http/core/data-storage.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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGF0YS1zdG9yYWdlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvYW5ndWxhci10b29sYm94L3NyYy9saWIvZnJhbWV3b3JrL21vY2svaHR0cC9jb3JlL2RhdGEtc3RvcmFnZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7O0dBTUciLCJzb3VyY2VzQ29udGVudCI6WyIvKipcclxuICogQGxpY2Vuc2VcclxuICogQ29weXJpZ2h0IFBhc2NhbCBFQ0hFTUFOTi4gQWxsIFJpZ2h0cyBSZXNlcnZlZC5cclxuICpcclxuICogVXNlIG9mIHRoaXMgc291cmNlIGNvZGUgaXMgZ292ZXJuZWQgYnkgYW4gTUlULXN0eWxlIGxpY2Vuc2UgdGhhdCBjYW4gYmUgZm91bmQgaW5cclxuICogdGhlIExJQ0VOU0UgZmlsZSBhdCBodHRwczovL3Bhc2NhbGVjaGVtYW5uLmNvbS9hbmd1bGFyLXRvb2xib3gvcmVzb3VyY2VzL2xpY2Vuc2VcclxuICovXHJcblxyXG5cclxuaW1wb3J0IHsgSHR0cFJlc3BvbnNlTW9jayB9IGZyb20gXCIuLi8uLi8uLi8uLi9tb2RlbFwiO1xyXG5cclxuLyoqXHJcbiAqIEBwcml2YXRlXHJcbiAqIFV0aWxpdHkgaW50ZXJmYWNlIHVzZWQgYnkgdGhlIGBEZWxlZ2F0ZVhocmAgY2xhc3MgdG8gc3RvcmUgSFRUUCByZXF1ZXN0IGluZm9ybWF0aW9uLlxyXG4gKi9cclxuZXhwb3J0IGludGVyZmFjZSBEYXRhU3RvcmFnZSB7XHJcbiAgICBcclxuICAgIC8qKlxyXG4gICAgICogQHByaXZhdGVcclxuICAgICAqL1xyXG4gICAgaHR0cFJlc3BvbnNlOiBIdHRwUmVzcG9uc2VNb2NrO1xyXG5cclxuICAgIC8qKlxyXG4gICAgICogQHByaXZhdGVcclxuICAgICAqIFRoZSBhbW91bnQgb2YgZGF0YSBjdXJyZW50bHkgbG9hZGVkLlxyXG4gICAgICovXHJcbiAgICBsb2FkZWQ6IG51bWJlcjtcclxuXHJcbiAgICAvKipcclxuICAgICAqIEBwcml2YXRlXHJcbiAgICAgKiBUaGUgdG90YWwgc2l6ZSBvZiBkYXRhIHRvIGxvYWQuXHJcbiAgICAgKi9cclxuICAgIHRvdGFsOiBudW1iZXI7XHJcblxyXG4gICAgLyoqXHJcbiAgICAgKiBAcHJpdmF0ZVxyXG4gICAgICogVGhlIGxvYWRlZCBkYXRhLlxyXG4gICAgICovXHJcbiAgICBkYXRhOiBhbnk7XHJcblxyXG4gICAgLyoqXHJcbiAgICAgKiBAcHJpdmF0ZVxyXG4gICAgICogVGhlIEpTT04gc3RyaW5nIHByZXByZXNlbnRhdGlvbiBvZiB0aGUgbG9hZGVkIGRhdGEuXHJcbiAgICAgKi9cclxuICAgIHN0cmluZ2lmaWVkRGF0YTogc3RyaW5nO1xyXG59XHJcbiJdfQ==

package/esm2022/lib/framework/mock/http/event/event-target.impl.mjs

@@ -0,0 +1,122 @@
+/**
+ * @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
+ *
+ * This source code is derived from the following original source code:
+ * - https://github.com/benlesh/event-target-polyfill
+ * - Copyright (c) 2020 Ben Lesh
+ *
+ * Use of the original source code is governed by an MIT-style license
+ * that can be found in the LICENSE file at
+ * https://github.com/benlesh/event-target-polyfill/blob/master/LICENSE
+ */
+import { FUNCTION } from "../../../../util";
+/**
+ * @private
+ */
+const ADD = "addEventListener";
+/**
+ * @private
+ */
+const REMOVE = "removeEventListener";
+/**
+ * @private
+ * A utility class the provides an implementation for the `EventTarget` interface.
+ * This class is used internally by the framework; please do not expose it.
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/EventTarget
+ */
+export class EventTargetImpl {
+    /**
+     * @private
+     */
+    constructor() {
+        this._listenerList = new Map();
+    }
+    /**
+     * @private
+     * Sets up a function that will be called whenever the specified event is delivered to the target.
+     *
+     * @param type a case-sensitive string representing the event type to listen for.
+     * @param listener the object that receives a notification (an object that implements the
+     *                 `Event` interface) when an event of the specified type occurs.
+     * @param options an object that specifies characteristics about the event listener.
+     *
+     * @see https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/addEventListener
+     */
+    addEventListener(type, listener, options) {
+        this.checkArgLength(arguments.length, ADD);
+        const ll = this._listenerList;
+        if (!ll.has(type))
+            ll.set(type, new Map());
+        const listenersForType = ll.get(type);
+        if (!listenersForType.has(listener)) {
+            // Any given listener is only registered once
+            listenersForType.set(listener, options);
+        }
+    }
+    /**
+     * @private
+     * Removes an event listener previously registered with `EventTarget.addEventListener()` from the target.
+     *
+     * @param type a case-sensitive which specifies the type of event for which to remove an event listener.
+     * @param listener the event listener function of the event handler to remove from the event target.
+     * @param options An options object that specifies characteristics about the event listener.
+     *
+     * @see https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/removeEventListener
+     */
+    removeEventListener(type, listener, options) {
+        this.checkArgLength(arguments.length, REMOVE);
+        const ll = this._listenerList;
+        if (ll.has(type)) {
+            const listenersForType = ll.get(type);
+            if (listenersForType.has(listener))
+                listenersForType.delete(listener);
+        }
+    }
+    /**
+     * @private
+     * Sends an `Event` to this to the `Event` object, (synchronously) invoking the affected event listeners
+     * in the appropriate order.
+     *
+     * @param event the `Event object to dispatch. Its Event.target property will be set to the current EventTarget.
+     * @returns true since there are no cancellable events on a base `EventTarget`.
+     *
+     * @see https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/dispatchEvent
+     */
+    dispatchEvent(event) {
+        if (!(event instanceof Event)) {
+            throw new TypeError("Failed to execute 'dispatchEvent' on 'EventTarget': parameter 1 is not of type 'Event'.");
+        }
+        const type = event.type;
+        const ll = this._listenerList;
+        const listenersForType = ll.get(type);
+        if (!listenersForType)
+            return true;
+        for (const listnerEntry of listenersForType.entries()) {
+            const listener = listnerEntry[0];
+            const options = listnerEntry[1];
+            // Listener functions must be executed with the EventTarget as the `this` context.
+            if (typeof listener === FUNCTION)
+                listener.call(this, event);
+            // Listener objects have their handleEvent method called, if they have one
+            else if (listener && typeof listener.handleEvent === FUNCTION)
+                listener.handleEvent(event);
+            if (options && options.once)
+                listenersForType.delete(listener);
+        }
+        return true;
+    }
+    /**
+     * @private
+     */
+    checkArgLength(argLen, method) {
+        if (argLen < 2) {
+            throw new TypeError(`TypeError: Failed to execute '${method}' on 'EventTarget': 2 arguments required, but ${argLen === 1 ? 'only 1' : '0'} present.`);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"event-target.impl.js","sourceRoot":"","sources":["../../../../../../../../projects/angular-toolbox/src/lib/framework/mock/http/event/event-target.impl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAE5C;;GAEG;AACH,MAAM,GAAG,GAAW,kBAAkB,CAAC;AAEvC;;GAEG;AACH,MAAM,MAAM,GAAW,qBAAqB,CAAC;AAE7C;;;;;;GAMG;AACH,MAAM,OAAO,eAAe;IAOxB;;OAEG;IACH;QACI,IAAI,CAAC,aAAa,GAAG,IAAI,GAAG,EAAe,CAAC;IAChD,CAAC;IAED;;;;;;;;;;OAUG;IACI,gBAAgB,CAAC,IAAY,EAAE,QAAmD,EAAE,OAAuD;QAC9I,IAAI,CAAC,cAAc,CAAC,SAAS,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;QAC3C,MAAM,EAAE,GAAqB,IAAI,CAAC,aAAa,CAAC;QAChD,IAAI,CAAC,EAAE,CAAC,GAAG,CAAC,IAAI,CAAC;YAAE,EAAE,CAAC,GAAG,CAAC,IAAI,EAAE,IAAI,GAAG,EAAE,CAAC,CAAC;QAC3C,MAAM,gBAAgB,GAAkB,EAAE,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QACrD,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC,QAAQ,CAAC,EAAE,CAAC;YAClC,6CAA6C;YAC7C,gBAAgB,CAAC,GAAG,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAC;QAC5C,CAAC;IACL,CAAC;IAED;;;;;;;;;OASG;IACI,mBAAmB,CAAC,IAAY,EAAE,QAAmD,EAAE,OAAoD;QAC9I,IAAI,CAAC,cAAc,CAAC,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;QAC9C,MAAM,EAAE,GAAqB,IAAI,CAAC,aAAa,CAAC;QAChD,IAAI,EAAE,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC;YACf,MAAM,gBAAgB,GAAkB,EAAE,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;YACrD,IAAI,gBAAgB,CAAC,GAAG,CAAC,QAAQ,CAAC;gBAAE,gBAAgB,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;QAC1E,CAAC;IACL,CAAC;IAED;;;;;;;;;OASG;IACI,aAAa,CAAC,KAAY;QAC7B,IAAI,CAAC,CAAC,KAAK,YAAY,KAAK,CAAC,EAAE,CAAC;YAC5B,MAAM,IAAI,SAAS,CACf,yFAAyF,CAC5F,CAAC;QACN,CAAC;QACD,MAAM,IAAI,GAAW,KAAK,CAAC,IAAI,CAAC;QAChC,MAAM,EAAE,GAAqB,IAAI,CAAC,aAAa,CAAC;QAChD,MAAM,gBAAgB,GAAG,EAAE,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QACtC,IAAI,CAAC,gBAAgB;YAAE,OAAO,IAAI,CAAC;QACnC,KAAK,MAAM,YAAY,IAAI,gBAAgB,CAAC,OAAO,EAAE,EAAE,CAAC;YACpD,MAAM,QAAQ,GAAQ,YAAY,CAAC,CAAC,CAAC,CAAC;YACtC,MAAM,OAAO,GAAQ,YAAY,CAAC,CAAC,CAAC,CAAC;YACrC,kFAAkF;YAClF,IAAI,OAAO,QAAQ,KAAK,QAAQ;gBAAE,QAAQ,CAAC,IAAI,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;YAC7D,0EAA0E;iBACrE,IAAI,QAAQ,IAAI,OAAO,QAAQ,CAAC,WAAW,KAAK,QAAQ;gBAAE,QAAQ,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC;YAC3F,IAAI,OAAO,IAAI,OAAO,CAAC,IAAI;gBAAE,gBAAgB,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;QACnE,CAAC;QACD,OAAO,IAAI,CAAC;IAChB,CAAC;IAED;;OAEG;IACK,cAAc,CAAC,MAAc,EAAE,MAAc;QACjD,IAAI,MAAM,GAAG,CAAC,EAAE,CAAC;YACb,MAAM,IAAI,SAAS,CACf,iCAAiC,MAAM,iDAAiD,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,GAAG,WAAW,CACnI,CAAC;QACN,CAAC;IACL,CAAC;CACJ","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 * This source code is derived from the following original source code:\r\n * - https://github.com/benlesh/event-target-polyfill\r\n * - Copyright (c) 2020 Ben Lesh\r\n * \r\n * Use of the original source code is governed by an MIT-style license \r\n * that can be found in the LICENSE file at\r\n * https://github.com/benlesh/event-target-polyfill/blob/master/LICENSE\r\n */\r\n\r\nimport { FUNCTION } from \"../../../../util\";\r\n\r\n/**\r\n * @private\r\n */\r\nconst ADD: string = \"addEventListener\";\r\n\r\n/**\r\n * @private\r\n */\r\nconst REMOVE: string = \"removeEventListener\";\r\n\r\n/**\r\n * @private\r\n * A utility class the provides an implementation for the `EventTarget` interface.\r\n * This class is used internally by the framework; please do not expose it.\r\n * \r\n * @see https://developer.mozilla.org/en-US/docs/Web/API/EventTarget\r\n */\r\nexport class EventTargetImpl implements EventTarget {\r\n\r\n    /**\r\n     * @private\r\n     */\r\n    private _listenerList: Map<string, any>;\r\n\r\n    /**\r\n     * @private\r\n     */\r\n    constructor() {\r\n        this._listenerList = new Map<string, any>();\r\n    }\r\n\r\n    /**\r\n     * @private\r\n     * Sets up a function that will be called whenever the specified event is delivered to the target.\r\n     * \r\n     * @param type a case-sensitive string representing the event type to listen for.\r\n     * @param listener the object that receives a notification (an object that implements the\r\n     *                 `Event` interface) when an event of the specified type occurs. \r\n     * @param options an object that specifies characteristics about the event listener.\r\n     * \r\n     * @see https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/addEventListener\r\n     */\r\n    public addEventListener(type: string, listener: EventListenerOrEventListenerObject | null, options?: boolean | AddEventListenerOptions | undefined): void {\r\n        this.checkArgLength(arguments.length, ADD);\r\n        const ll: Map<string, any> = this._listenerList;\r\n        if (!ll.has(type)) ll.set(type, new Map());\r\n        const listenersForType: Map<any, any> = ll.get(type);\r\n        if (!listenersForType.has(listener)) {\r\n            // Any given listener is only registered once\r\n            listenersForType.set(listener, options);\r\n        }\r\n    }\r\n\r\n    /**\r\n     * @private\r\n     * Removes an event listener previously registered with `EventTarget.addEventListener()` from the target. \r\n     * \r\n     * @param type a case-sensitive which specifies the type of event for which to remove an event listener.\r\n     * @param listener the event listener function of the event handler to remove from the event target.\r\n     * @param options An options object that specifies characteristics about the event listener.\r\n     * \r\n     * @see https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/removeEventListener\r\n     */\r\n    public removeEventListener(type: string, listener: EventListenerOrEventListenerObject | null, options?: boolean | EventListenerOptions | undefined): void {\r\n        this.checkArgLength(arguments.length, REMOVE);\r\n        const ll: Map<string, any> = this._listenerList;\r\n        if (ll.has(type)) {\r\n            const listenersForType: Map<any, any> = ll.get(type);\r\n            if (listenersForType.has(listener)) listenersForType.delete(listener);\r\n        }\r\n    }\r\n\r\n    /**\r\n     * @private\r\n     * Sends an `Event` to this to the `Event` object, (synchronously) invoking the affected event listeners\r\n     * in the appropriate order.\r\n     *\r\n     * @param event the `Event object to dispatch. Its Event.target property will be set to the current EventTarget.\r\n     * @returns true since there are no cancellable events on a base `EventTarget`.\r\n     * \r\n     * @see https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/dispatchEvent\r\n     */\r\n    public dispatchEvent(event: Event): boolean {\r\n        if (!(event instanceof Event)) {\r\n            throw new TypeError(\r\n                \"Failed to execute 'dispatchEvent' on 'EventTarget': parameter 1 is not of type 'Event'.\"\r\n            );\r\n        }\r\n        const type: string = event.type;\r\n        const ll: Map<string, any> = this._listenerList;\r\n        const listenersForType = ll.get(type);\r\n        if (!listenersForType) return true;\r\n        for (const listnerEntry of listenersForType.entries()) {\r\n            const listener: any = listnerEntry[0];\r\n            const options: any = listnerEntry[1];\r\n            // Listener functions must be executed with the EventTarget as the `this` context.\r\n            if (typeof listener === FUNCTION) listener.call(this, event);\r\n            // Listener objects have their handleEvent method called, if they have one\r\n            else if (listener && typeof listener.handleEvent === FUNCTION) listener.handleEvent(event);\r\n            if (options && options.once) listenersForType.delete(listener);\r\n        }\r\n        return true;\r\n    }\r\n\r\n    /**\r\n     * @private\r\n     */\r\n    private checkArgLength(argLen: number, method: string): void {\r\n        if (argLen < 2) {\r\n            throw new TypeError(\r\n                `TypeError: Failed to execute '${method}' on 'EventTarget': 2 arguments required, but ${argLen === 1 ? 'only 1' : '0'} present.`\r\n            );\r\n        }\r\n    }\r\n}"]}

package/esm2022/lib/framework/mock/http/event/progress-event-mock.mjs

@@ -0,0 +1,48 @@
+/**
+ * @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
+ */
+/**
+ * @private
+ * A utility class used by delegate `XhrProxy` instances to dispatch `ProgressEvent`
+ * instances.
+ *
+ * This class is not exposed.
+ */
+export class ProgressEventMock extends ProgressEvent {
+    constructor() {
+        super(...arguments);
+        /**
+         * @private
+         */
+        this._total = NaN;
+        /**
+         * @private
+         */
+        this._loaded = 0;
+    }
+    /**
+     * A 64-bit unsigned integer indicating the size, in bytes, of the data already
+     * transmitted or processed.
+     */
+    set total(value) {
+        this._total = value;
+    }
+    get total() {
+        return this._total;
+    }
+    /**
+     * A 64-bit unsigned integer indicating the total size, in bytes, of the data being
+     * transmitted or processed.
+     */
+    set loaded(value) {
+        this._loaded = value;
+    }
+    get loaded() {
+        return this._loaded;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,4 @@
+export * from './config';
+export * from './util';
+export * from './xhr';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9hbmd1bGFyLXRvb2xib3gvc3JjL2xpYi9mcmFtZXdvcmsvbW9jay9odHRwL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsVUFBVSxDQUFDO0FBQ3pCLGNBQWMsUUFBUSxDQUFDO0FBQ3ZCLGNBQWMsT0FBTyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9jb25maWcnO1xyXG5leHBvcnQgKiBmcm9tICcuL3V0aWwnO1xyXG5leHBvcnQgKiBmcm9tICcuL3hocic7Il19

package/esm2022/lib/framework/mock/http/path-to-regexp/constants.mjs

@@ -0,0 +1,111 @@
+/**
+ * @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
+ */
+/**
+ * @private
+ * The reference to the default delimiter.
+ * Value is `"/"`.
+ */
+export const DEFAULT_DELIMITER = "/";
+/**
+ * @private
+ * The reference to the case insensitive flag.
+ * Value is `"i"`.
+ */
+export const I_FLAG = "i";
+/**
+ * @private
+ * The reference to the global flag.
+ * Value is `"g"`.
+ */
+export const G_FLAG = "g";
+/**
+ * @private
+ * The reference to the `{` `TokenType`.
+ */
+export const LEFT_CURLY_BRACE = "{";
+/**
+ * @private
+ * The reference to the `}` `TokenType`.
+ */
+export const RIGHT_CURLY_BRACE = "}";
+/**
+ * @private
+ * The reference to the `*` `TokenType`.
+ */
+export const ASTERISK = "*";
+/**
+ * @private
+ * The reference to the `+` `TokenType`.
+ */
+export const PLUS = "+";
+/**
+ * @private
+ * The reference to the `?` `TokenType`.
+ */
+export const QUESTION_MARK = "?";
+/**
+ * @private
+ * The reference to the `NAME` `TokenType`.
+ */
+export const NAME = "NAME";
+/**
+ * @private
+ * The reference to the `PATTERN` `TokenType`.
+ */
+export const PATTERN = "PATTERN";
+/**
+ * @private
+ * The reference to the `CHAR` `TokenType`.
+ */
+export const CHAR = "CHAR";
+/**
+ * @private
+ * The reference to the `ESCAPED` `TokenType`.
+ */
+export const ESCAPED = "ESCAPED";
+/**
+ * @private
+ * The reference to the `END` `TokenType`.
+ */
+export const END = "END";
+/**
+ * @private
+ * The reference to the semi colon (`;`) character.
+ */
+export const SEMI_COLON = ";";
+/**
+ * @private
+ * The reference to the colon (`:`) character.
+ */
+export const COLON = ":";
+/**
+ * @private
+ * The reference to the left parenthesis (`(`) character.
+ */
+export const LEFT_PARENTHESIS = "(";
+/**
+ * @private
+ * The reference to the right parenthesis (`)`) character.
+ */
+export const RIGHT_PARENTHESIS = ")";
+/**
+ * @private
+ * The reference to the escaped back slash (`\\`) character.
+ */
+export const ESC_BACK_SLASH = "\\";
+/**
+ * @private
+ * The reference to the carret (`^`) character.
+ */
+export const CARRET = "^";
+/**
+ * @private
+ * The reference to the carret (`$`) character.
+ */
+export const DOLLAR = "$";
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/framework/mock/http/path-to-regexp/escape-to-regexp-string.mjs

@@ -0,0 +1,34 @@
+/**
+ * @license
+ * Copyright Pascal ECHEMANN. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be ound in
+ * fthe LICENSE file at https://pascalechemann.com/angular-toolbox/resources/license
+ *
+ * This source code is derived from the following original source code:
+ * - https://github.com/pillarjs/path-to-regexp
+ * - Copyright (c) 2014 Blake Embrey (hello@blakeembrey.com)
+ *
+ * Use of the original source code is governed by an MIT-style license
+ * that can be found in the LICENSE file at
+ * https://github.com/pillarjs/path-to-regexp/blob/master/LICENSE
+ */
+/**
+ * @private
+ */
+const ESCAPE_REGEXP = /([.+*?=^!:${}()[\]|/\\])/g;
+/**
+ * @private
+ */
+const ESCAPE_VALUE = "\\$1";
+/**
+ * @private
+ * Escape a regular expression string.
+ *
+ * @param str The regular expression string to escape.
+ * @returns An escaped a regular expression string.
+ */
+export const escapeRegexpString = (str) => {
+    return str.replace(ESCAPE_REGEXP, ESCAPE_VALUE);
+};
+//# sourceMappingURL=data:application/json;base64,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