angular-toolbox 0.0.8 → 0.9.1

package/esm2022/lib/model/business/version/version-config.provider.mjs

@@ -0,0 +1,40 @@
+/**
+ * @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
+ */
+/**
+ * The default provider for the `VersionService` configuration. You typically define
+ * the custom properties in the main `NgModule` declaration to initialize the application
+ * config:
+ *
+ * @NgModule({
+ * ...
+ * providers: [
+ *   { provide: VERSION_CONFIG, useValue: { major: 1, minor: 2, patch: 12 } }
+ * ],
+ * ...
+ * });
+ */
+export const VERSION_CONFIG = {
+    /**
+     * Specifies the major number of this config.
+     */
+    major: 0,
+    /**
+     * Specifies the minor number of this config.
+     */
+    minor: 0,
+    /**
+     * Specifies the patch number of this config.
+     */
+    patch: 0,
+    /**
+     * Specifies the timestamp that corresponds to the build date for this `Version` object.
+     * Default value is `NaN`.
+     */
+    buildTimestamp: NaN
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/model/business/version/version.mjs

@@ -0,0 +1,10 @@
+/**
+ * @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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmVyc2lvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2FuZ3VsYXItdG9vbGJveC9zcmMvbGliL21vZGVsL2J1c2luZXNzL3ZlcnNpb24vdmVyc2lvbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7O0dBTUc7QUFpQ0YsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxyXG4gKiBAbGljZW5zZVxyXG4gKiBDb3B5cmlnaHQgUGFzY2FsIEVDSEVNQU5OLiBBbGwgUmlnaHRzIFJlc2VydmVkLlxyXG4gKlxyXG4gKiBVc2Ugb2YgdGhpcyBzb3VyY2UgY29kZSBpcyBnb3Zlcm5lZCBieSBhbiBNSVQtc3R5bGUgbGljZW5zZSB0aGF0IGNhbiBiZSBmb3VuZCBpblxyXG4gKiB0aGUgTElDRU5TRSBmaWxlIGF0IGh0dHBzOi8vcGFzY2FsZWNoZW1hbm4uY29tL2FuZ3VsYXItdG9vbGJveC9yZXNvdXJjZXMvbGljZW5zZVxyXG4gKi9cclxuXHJcbi8qKlxyXG4gKiBTcGVjaWZpZXMgdGhlIHNlbWFudGljIHZlcnNpb25pbmcgb2YgYW4gQW5ndWxhciBhcHBsaWNhdGlvbi5cclxuICovXHJcbmV4cG9ydCBpbnRlcmZhY2UgVmVyc2lvbiB7XHJcblxyXG4gICAgLyoqXHJcbiAgICAgKiBTcGVjaWZpZXMgdmVyc2lvbnMgd2l0aCBpbmNvbXBhdGlibGUgQVBJIGNoYW5nZXMuXHJcbiAgICAgKi9cclxuICAgIG1ham9yOiBudW1iZXI7XHJcbiAgICBcclxuICAgIC8qKlxyXG4gICAgICogU3BlY2lmaWVzIHZlcnNpb25zIHdpdGggZnVuY3Rpb25hbGl0aWVzIHRoYXQgaGF2ZSAgYmFja3dhcmQgY29tcGF0aWJpbGl0eS5cclxuICAgICAqL1xyXG4gICAgbWlub3I6IG51bWJlcjtcclxuXHJcbiAgICAvKipcclxuICAgICAqIFNwZWNpZmllcyB2ZXJzaW9ucyB0aGF0IGZpeGVzIGJ1Z3MuXHJcbiAgICAgKi9cclxuICAgIHBhdGNoOiBudW1iZXI7XHJcbiAgICBcclxuICAgIC8qKlxyXG4gICAgICogU3BlY2lmaWVzIHRoZSB0aW1lc3RhbXAgdGhhdCBjb3JyZXNwb25kcyB0byB0aGUgYnVpbGQgZGF0ZSBmb3IgdGhpcyBgVmVyc2lvbmAgb2JqZWN0LlxyXG4gICAgICovXHJcbiAgICBidWlsZFRpbWVTdGFtcDogbnVtYmVyO1xyXG5cclxuICAgIC8qKlxyXG4gICAgICogUmV0dXJucyBhIHN0cmluZyByZXByZXNlbnRhdGlvbiBvZiB0aGlzIGBWZXJzaW9uYCBvYmplY3QuXHJcbiAgICAgKiBcclxuICAgICAqIEByZXR1cm5zIEEgc3RyaW5nIHJlcHJlc2VudGF0aW9uIG9mIHRoaXMgYFZlcnNpb25gIG9iamVjdC5cclxuICAgICAqL1xyXG4gICAgdG9TdHJpbmcoKTogc3RyaW5nO1xyXG59OyJdfQ==

package/esm2022/lib/model/index.mjs

@@ -0,0 +1,3 @@
+export * from './business';
+export * from './service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9hbmd1bGFyLXRvb2xib3gvc3JjL2xpYi9tb2RlbC9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLFlBQVksQ0FBQztBQUMzQixjQUFjLFdBQVcsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vYnVzaW5lc3MnO1xyXG5leHBvcnQgKiBmcm9tICcuL3NlcnZpY2UnOyJdfQ==

package/esm2022/lib/model/service/index.mjs

@@ -0,0 +1,5 @@
+export * from './subscription/subscription.service';
+export * from './ui';
+export * from './version/version.service';
+export * from './mock/http/http-mock.service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9hbmd1bGFyLXRvb2xib3gvc3JjL2xpYi9tb2RlbC9zZXJ2aWNlL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMscUNBQXFDLENBQUM7QUFDcEQsY0FBYyxNQUFNLENBQUM7QUFDckIsY0FBYywyQkFBMkIsQ0FBQztBQUMxQyxjQUFjLCtCQUErQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9zdWJzY3JpcHRpb24vc3Vic2NyaXB0aW9uLnNlcnZpY2UnO1xyXG5leHBvcnQgKiBmcm9tICcuL3VpJztcclxuZXhwb3J0ICogZnJvbSAnLi92ZXJzaW9uL3ZlcnNpb24uc2VydmljZSc7XHJcbmV4cG9ydCAqIGZyb20gJy4vbW9jay9odHRwL2h0dHAtbW9jay5zZXJ2aWNlJzsiXX0=

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

@@ -0,0 +1,239 @@
+/**
+ * @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 { Injectable } from '@angular/core';
+import { HTTPMethodRef } from '../../../../framework/mock/http/util/http-method-ref.enum';
+import { tokenDataToRegexp } from '../../../../framework/mock/http/path-to-regexp/token-data-to-regexp';
+import { stringToTokenData } from '../../../../framework/mock/http/path-to-regexp/string-to-token-data';
+import { DEFAULT_DELIMITER } from '../../../../framework/mock/http/path-to-regexp/constants';
+import { Uuid } from '../../../../util';
+import { HttpMockServiceError } from '../../../../core/error';
+import * as i0 from "@angular/core";
+/**
+ * @private
+ * Reference to the original type for this class.
+ */
+export const HTTP_MOCK_SERVICE = "HttpMockService";
+/**
+ * The `HttpMockService` class provides the API for managing HTTP mock configuration objects.
+ */
+export class HttpMockService {
+    constructor() {
+        /**
+         * @private
+         * Ensures that class type is still accessible after TypeScript compilation.
+         */
+        this.type = HTTP_MOCK_SERVICE;
+        /**
+         * @private
+         * The list of IDs associated with each config object.
+         */
+        this._configIdList = [];
+        /**
+         * @private
+         * Stores the complete collection of mocking behaviors for each registered config.
+         */
+        this._configList = new Map();
+        /**
+         * @private
+         * The reference to the current app URL origin.
+         */
+        this.APP_ORIGIN = window.location.origin;
+    }
+    /**
+     * Adds the specified `HttpMockConfig` object to this `HttpMockService` instance.
+     *
+     * @param config The `HttpMockConfig` object to add to this `HttpMockService` instance.
+     * @Returns The `Uuid` instance associated with the added `HttpMockConfig` object.
+     */
+    addConfig(config) {
+        const origin = config.origin || this.APP_ORIGIN;
+        this.checkOrigin(origin);
+        let id = config.id;
+        if (!id) {
+            id = Uuid.build();
+            config.id = id;
+        }
+        else {
+            if (this.hasRegisteredConfig(id))
+                throw new HttpMockServiceError(`A config object has already been registered with the id: ["${id.toString()}"].`);
+        }
+        this._configIdList.push(id);
+        const uuid = id.toString();
+        config.interceptors.forEach((interceptor) => this.extractConfig(interceptor, origin, uuid));
+        return id;
+    }
+    /**
+     * Returns the current app URL origin.
+     *
+     * @returns A string that represents the current app URL origin.
+     */
+    getAppOrigin() {
+        return this.APP_ORIGIN;
+    }
+    /**
+     * Removes the configuration registered with the specified `uuid` from this `HttpMockService` instance.
+     *
+     * @param uuid The UUID of the configuration to remove.
+     */
+    removeConfig(uuid) {
+        if (!this.hasRegisteredConfig(uuid))
+            return;
+        const configId = uuid.toString();
+        this._configList.forEach((value, key) => {
+            this.deleteConfigById(value, configId);
+            if (value.size === 0)
+                this._configList.delete(key);
+        });
+        this._configIdList.splice(this._configIdList.indexOf(uuid), 1);
+    }
+    /**
+     * Removes all registred configurations from this `HttpMockService` instance.
+     */
+    clearConfigs() {
+        this._configList.clear();
+        this._configIdList.length = 0;
+    }
+    /**
+     * Returns a boolean value that indicates whether a config with the specified UUID has been registered
+     * (`true`), or not (`false`).
+     *
+     * @param uuid The UUID of the config to check.
+     * @returns `true` whether a config with the specified UUID has been registered; `false` otherwise.
+     */
+    hasRegisteredConfig(uuid) {
+        return this._configIdList.indexOf(uuid) !== -1;
+    }
+    /**
+     * Returns the `RouteMockConfig` object associated with the specified `URL` instance and HTTP method.
+     *
+     * @param url The `URL` instance for which to find a route config.
+     * @param method The HTTP method for which to find a route config.
+     * @returns The `RouteMockConfig` object associated with the specified `URL` instance and HTTP method whether it exists;
+     *          `undefined` otherwise.
+     */
+    getRouteConfig(url, method) {
+        const urlConfigList = this._configList.get(url.origin);
+        const route = url.pathname;
+        let result = undefined;
+        if (!urlConfigList)
+            return result;
+        const methodList = urlConfigList.get(method);
+        if (!methodList)
+            return result;
+        let len = methodList.length - 1;
+        while (len >= 0) {
+            const methodMap = methodList[len];
+            const regexp = methodMap.regexp;
+            if (regexp.test(route)) {
+                result = {
+                    methodConfig: methodMap.methodMock,
+                    parameters: this.buildParameters(regexp, methodMap.keys, route)
+                };
+                break;
+            }
+            len--;
+        }
+        return result;
+    }
+    /**
+     * @rivate
+     */
+    buildParameters(regexp, keys, route) {
+        const execResult = regexp.exec(route);
+        if (!execResult)
+            return null;
+        const params = {};
+        let len = execResult.length - 1;
+        let i = 1;
+        for (; i <= len; ++i) {
+            const key = keys[i - 1];
+            params[key.name] = execResult[i];
+        }
+        return params;
+    }
+    /**
+     * @rivate
+     */
+    extractConfig(interceptor, globalOrigin, configId) {
+        const endpoints = interceptor.endpoints;
+        let origin = interceptor.origin;
+        if (origin)
+            this.checkOrigin(origin);
+        else
+            origin = globalOrigin;
+        if (!this._configList.has(origin))
+            this._configList.set(origin, new Map());
+        endpoints.forEach((endpoint) => {
+            this.extractEndpointConfig(origin, endpoint, HTTPMethodRef.GET, configId);
+            this.extractEndpointConfig(origin, endpoint, HTTPMethodRef.POST, configId);
+            this.extractEndpointConfig(origin, endpoint, HTTPMethodRef.PUT, configId);
+            this.extractEndpointConfig(origin, endpoint, HTTPMethodRef.DELETE, configId);
+            this.extractEndpointConfig(origin, endpoint, HTTPMethodRef.HEAD, configId);
+            this.extractEndpointConfig(origin, endpoint, HTTPMethodRef.OPTIONS, configId);
+            this.extractEndpointConfig(origin, endpoint, HTTPMethodRef.PATCH, configId);
+            this.extractEndpointConfig(origin, endpoint, HTTPMethodRef.CONNECT, configId);
+            this.extractEndpointConfig(origin, endpoint, HTTPMethodRef.TRACE, configId);
+        });
+    }
+    /**
+     * @rivate
+     */
+    extractEndpointConfig(origin, endpoint, method, configId) {
+        const ep = endpoint;
+        if (!ep[method])
+            return;
+        const originConfig = this._configList.get(origin);
+        const route = endpoint.route;
+        const data = stringToTokenData(route);
+        const keys = [];
+        const regexp = tokenDataToRegexp(data, keys, {});
+        if (!originConfig.has(method))
+            originConfig.set(method, []);
+        const methodConfig = originConfig.get(method);
+        methodConfig.push({
+            regexp: regexp,
+            keys: keys,
+            methodMock: ep[method],
+            configId: configId
+        });
+    }
+    /**
+     * @rivate
+     */
+    checkOrigin(origin) {
+        if (origin.endsWith(DEFAULT_DELIMITER))
+            throw new SyntaxError(`Origin must not end with a / character: ["${origin}"].`);
+    }
+    /**
+     * @rivate
+     */
+    deleteConfigById(storageMap, configId) {
+        storageMap.forEach((storage, key) => {
+            const cleanedConfig = this.cleanConfig(storage, configId);
+            if (cleanedConfig.length)
+                storageMap.set(key, cleanedConfig);
+            else
+                storageMap.delete(key);
+        });
+    }
+    /**
+     * @rivate
+     */
+    cleanConfig(storage, configId) {
+        return storage.filter((value) => value.configId !== configId);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.3", ngImport: i0, type: HttpMockService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.3", ngImport: i0, type: HttpMockService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.3", ngImport: i0, type: HttpMockService, decorators: [{
+            type: Injectable,
+            args: [{
+                    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"]}

package/esm2022/lib/model/service/subscription/subscription.service.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
+ */
+import { Injectable } from '@angular/core';
+import { SubscriptionError } from '../../../core';
+import { IdentifiableComponent } from '../../../core/impl';
+import * as i0 from "@angular/core";
+/**
+ * A lightweight service that helps to manage unregistration issues of Angular subscriptions.
+ */
+export class SubscriptionService {
+    constructor() {
+        /**
+         * @private
+         * Stores an internal reference to the last reference used with the `register()`
+         * method.
+         */
+        this._lastRef = null;
+        /**
+         * @private
+         * The internal `Subscription` instances storage.
+         */
+        this._subMap = new Map();
+    }
+    /**
+     * Stores a new `Subscription` instance associated with the specified reference.
+     *
+     * @param ref The reference for which to store a new `Subscription` instance.
+     *            Can be either a string or an `Identifiable` object.
+     * @param subscription The `Subscription` instance to register.
+     *
+     * @returns A reference to this `SubscriptionService` instance.
+     */
+    register(ref, subscription) {
+        const REF = this.getRef(ref);
+        this._lastRef = REF;
+        if (!this._subMap.has(REF))
+            this._subMap.set(REF, []);
+        this._subMap.get(REF)?.push(subscription);
+        return this;
+    }
+    /**
+     * Stores a new `Subscription` instance associated with the reference specified
+     * by the last `register()` method invokation.
+     *
+     * @param subscription The `Subscription` instance to register.
+     *
+     * @returns A reference to this `SubscriptionService` instance.
+     */
+    append(subscription) {
+        if (!this._lastRef)
+            throw new SubscriptionError("Illegal Access Error: you must call the register() method before invoking the append() method.");
+        return this.register(this._lastRef, subscription);
+    }
+    /**
+     * Unsubscribes and removes all `Subscription` instances associated with the specified reference.
+     *
+     * @param ref The reference for which to remove all `Subscription` instances.
+     *            Can be either a string or an `Identifiable` object.
+     *
+     * @returns `true` whether the specified reference exists; `false` otherwise.
+     */
+    clearAll(ref) {
+        const REF = this.getRef(ref);
+        let result = false;
+        if (this._lastRef === REF)
+            this._lastRef = null;
+        if (this._subMap.has(REF)) {
+            this._subMap.get(REF)?.forEach(subscription => {
+                if (!subscription.closed)
+                    subscription.unsubscribe();
+            });
+            this._subMap.delete(REF);
+            result = true;
+        }
+        return result;
+    }
+    /**
+     * Returns all `Subscription` instances associated with the specified reference.
+     *
+     * @param ref The reference for which to remove get `Subscription` instances.
+     *            Can be either a string or an `Identifiable` object.
+     *
+     * @returns All `Subscription` instances associated with the specified reference, or
+     *          `null` whether the specified reference does not exists.
+     */
+    get(ref) {
+        return this._subMap.get(this.getRef(ref)) || null;
+    }
+    /**
+     * @private
+     * Returns the string reference for the regsitration process.
+     *
+     * @param ref The reference to be used the regsitration process.
+     *            Can be either a string or an `Identifiable` object.
+     *
+     * @returns the string reference for the regsitration process.
+     */
+    getRef(ref) {
+        let targetRef;
+        if (typeof ref === "string")
+            targetRef = ref;
+        else if (ref instanceof IdentifiableComponent)
+            targetRef = ref.getID().toString();
+        else
+            throw new TypeError("ref must be of type of string or Identifiable");
+        return targetRef;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.3", ngImport: i0, type: SubscriptionService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.3", ngImport: i0, type: SubscriptionService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.3", ngImport: i0, type: SubscriptionService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"subscription.service.js","sourceRoot":"","sources":["../../../../../../../projects/angular-toolbox/src/lib/model/service/subscription/subscription.service.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAE3C,OAAO,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAClD,OAAO,EAAE,qBAAqB,EAAE,MAAM,oBAAoB,CAAC;;AAM3D;;GAEG;AACH,MAAM,OAAO,mBAAmB;IANhC;QAQI;;;;WAIG;QACK,aAAQ,GAAkB,IAAI,CAAC;QAEvC;;;WAGG;QACK,YAAO,GAAqC,IAAI,GAAG,EAA+B,CAAC;KAmF9F;IAjFG;;;;;;;;OAQG;IACI,QAAQ,CAAC,GAA0B,EAAE,YAA0B;QAClE,MAAM,GAAG,GAAW,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;QACrC,IAAI,CAAC,QAAQ,GAAG,GAAG,CAAC;QACpB,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC;YAAE,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC;QACtD,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,IAAI,CAAC,YAAY,CAAC,CAAC;QAC1C,OAAO,IAAI,CAAC;IAChB,CAAC;IAED;;;;;;;OAOG;IACI,MAAM,CAAC,YAA0B;QACpC,IAAI,CAAC,IAAI,CAAC,QAAQ;YAAE,MAAM,IAAI,iBAAiB,CAAC,gGAAgG,CAAC,CAAC;QAClJ,OAAO,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,QAAQ,EAAE,YAAY,CAAC,CAAC;IACtD,CAAC;IAED;;;;;;;OAOG;IACI,QAAQ,CAAC,GAA0B;QACtC,MAAM,GAAG,GAAW,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;QACrC,IAAI,MAAM,GAAY,KAAK,CAAC;QAC5B,IAAI,IAAI,CAAC,QAAQ,KAAK,GAAG;YAAE,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC;QAChD,IAAI,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC;YACxB,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,OAAO,CAAC,YAAY,CAAC,EAAE;gBAC1C,IAAI,CAAC,YAAY,CAAC,MAAM;oBAAE,YAAY,CAAC,WAAW,EAAE,CAAC;YACxD,CAAC,CAAC,CAAC;YACJ,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;YACzB,MAAM,GAAG,IAAI,CAAC;QAClB,CAAC;QACD,OAAO,MAAM,CAAC;IAClB,CAAC;IAED;;;;;;;;OAQG;IACI,GAAG,CAAC,GAA0B;QACjC,OAAO,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,IAAI,IAAI,CAAC;IACtD,CAAC;IAED;;;;;;;;OAQG;IACK,MAAM,CAAC,GAA0B;QACrC,IAAI,SAAiB,CAAC;QACtB,IAAI,OAAO,GAAG,KAAK,QAAQ;YAAE,SAAS,GAAG,GAAG,CAAC;aACxC,IAAI,GAAG,YAAY,qBAAqB;YAAE,SAAS,GAAG,GAAG,CAAC,KAAK,EAAE,CAAC,QAAQ,EAAE,CAAC;;YAC7E,MAAM,IAAI,SAAS,CAAC,+CAA+C,CAAC,CAAC;QAC1E,OAAO,SAAS,CAAC;IACrB,CAAC;8GA/FQ,mBAAmB;kHAAnB,mBAAmB,cALhB,MAAM;;2FAKT,mBAAmB;kBAN/B,UAAU;mBAAC;oBACR,UAAU,EAAE,MAAM;iBACrB","sourcesContent":["/**\n * @license\n * Copyright Pascal ECHEMANN. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be found in \n * the LICENSE file at https://pascalechemann.com/angular-toolbox/resources/license\n */\n\nimport { Injectable } from '@angular/core';\nimport { Subscription } from 'rxjs';\nimport { SubscriptionError } from '../../../core';\nimport { IdentifiableComponent } from '../../../core/impl';\nimport { Identifiable } from '../../business';\n\n@Injectable({\n    providedIn: 'root'\n})\n/**\n * A lightweight service that helps to manage unregistration issues of Angular subscriptions.\n */\nexport class SubscriptionService {\n\n    /**\n     * @private\n     * Stores an internal reference to the last reference used with the `register()`\n     * method.\n     */\n    private _lastRef: string | null = null;\n\n    /**\n     * @private\n     * The internal `Subscription` instances storage.\n     */\n    private _subMap: Map<string, Array<Subscription>> = new Map<string, Array<Subscription>>();\n\n    /**\n     * Stores a new `Subscription` instance associated with the specified reference.\n     * \n     * @param ref The reference for which to store a new `Subscription` instance.\n     *            Can be either a string or an `Identifiable` object.\n     * @param subscription The `Subscription` instance to register.\n     * \n     * @returns A reference to this `SubscriptionService` instance.\n     */\n    public register(ref: string | Identifiable, subscription: Subscription): SubscriptionService {\n        const REF: string = this.getRef(ref);\n        this._lastRef = REF;\n        if (!this._subMap.has(REF)) this._subMap.set(REF, []);\n        this._subMap.get(REF)?.push(subscription);\n        return this;\n    }\n\n    /**\n     * Stores a new `Subscription` instance associated with the reference specified\n     * by the last `register()` method invokation.\n     * \n     * @param subscription The `Subscription` instance to register.\n     * \n     * @returns A reference to this `SubscriptionService` instance.\n     */\n    public append(subscription: Subscription): SubscriptionService {\n        if (!this._lastRef) throw new SubscriptionError(\"Illegal Access Error: you must call the register() method before invoking the append() method.\");\n        return this.register(this._lastRef, subscription);\n    }\n \n    /**\n     * Unsubscribes and removes all `Subscription` instances associated with the specified reference.\n     * \n     * @param ref The reference for which to remove all `Subscription` instances.\n     *            Can be either a string or an `Identifiable` object.\n     * \n     * @returns `true` whether the specified reference exists; `false` otherwise.\n     */\n    public clearAll(ref: string | Identifiable): boolean {\n        const REF: string = this.getRef(ref);\n        let result: boolean = false;\n        if (this._lastRef === REF) this._lastRef = null;\n        if (this._subMap.has(REF)) {\n            this._subMap.get(REF)?.forEach(subscription => {\n                if (!subscription.closed) subscription.unsubscribe();\n             });\n            this._subMap.delete(REF);\n            result = true;\n        }\n        return result;\n    }\n\n    /**\n     * Returns all `Subscription` instances associated with the specified reference.\n     * \n     * @param ref The reference for which to remove get `Subscription` instances.\n     *            Can be either a string or an `Identifiable` object.\n     * \n     * @returns All `Subscription` instances associated with the specified reference, or \n     *          `null` whether the specified reference does not exists.\n     */\n    public get(ref: string | Identifiable): Array<Subscription> | null {\n        return this._subMap.get(this.getRef(ref)) || null;\n    }\n\n    /**\n     * @private \n     * Returns the string reference for the regsitration process. \n     * \n     * @param ref The reference to be used the regsitration process. \n     *            Can be either a string or an `Identifiable` object.\n     * \n     * @returns the string reference for the regsitration process. \n     */\n    private getRef(ref: string | Identifiable): string {\n        let targetRef: string;\n        if (typeof ref === \"string\") targetRef = ref;\n        else if (ref instanceof IdentifiableComponent) targetRef = ref.getID().toString();\n        else throw new TypeError(\"ref must be of type of string or Identifiable\");\n        return targetRef;\n    }\n}\n"]}

package/esm2022/lib/model/service/ui/app-bridge.service.mjs

@@ -0,0 +1,142 @@
+/**
+ * @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
+ */
+import { DOCUMENT } from '@angular/common';
+import { Injectable, Inject } from '@angular/core';
+import { DEFAULT_SCROLL_BEHAVIOR } from '../../../util/default-scroll-behavior';
+import { AppBridge } from '../../../core/bridge/app-bridge';
+import { AppBridgeError } from '../../../core';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+/**
+ * @private
+ */
+export const APP_PRIDGE_REF = "appBridge";
+/**
+ * @private
+ */
+const HREF = "href";
+/**
+ * @private
+ */
+const NATIVE_COMMANDS = "navigate|goToAnchor|declareCommand|deleteCommand|getCommand";
+/**
+ * A utility service that allows dynamically injected HTML fragments, to interact with the Angular application.
+ */
+export class AppBrigeService {
+    /**
+     * @private
+     */
+    constructor(_router, _zone, _document) {
+        this._router = _router;
+        this._zone = _zone;
+        this._document = _document;
+        this._defaultView = _document.defaultView;
+        this._appBridge = new AppBridge();
+        if (!this._defaultView[APP_PRIDGE_REF])
+            this._defaultView[APP_PRIDGE_REF] = this;
+    }
+    /**
+     * Provides the ability to invoke the `navigate()` method of the Angular app router.
+     *
+     * @param commands The commands array as specified by the Angular router `navigate()` method.
+     * @param extras The navigation options as specified by the Angular router `navigate()` method.
+     * @return `Promise` that resolves to `true` when navigation succeeds, or `false` when navigation fails.
+     *
+     * @see https://angular.dev/api/router/Router#navigate
+     */
+    navigate(commands, extras) {
+        return this._zone.run(() => {
+            return this._router.navigate(commands, extras);
+        });
+    }
+    /**
+     * Allows to scroll to the fragment specified by the `href` attribute when the user element interact with the associated element.
+     *
+     * @example
+     * <a href="#myAnchor" onclick="appBridge.goToAnchor(event)">My Section</a></code>
+     *
+     * @param event The event that triggers the anchor navigation.
+     * @return `Promise` that resolves to `true` when navigation succeeds, or `false` when navigation fails.
+     *
+     * @see https://angular.dev/api/router/Router#navigate
+     */
+    goToAnchor(event) {
+        event.preventDefault();
+        const anchor = event.target.getAttribute(HREF);
+        if (!anchor)
+            throw new ReferenceError("href attribute is not defined.");
+        const elm = this._document.querySelector(anchor);
+        if (!elm)
+            return new Promise((resolve) => resolve(false));
+        elm.scrollIntoView(DEFAULT_SCROLL_BEHAVIOR);
+        return this._zone.run(() => {
+            return this._router.navigate([], { fragment: anchor.slice(1) });
+        });
+    }
+    /**
+     * Declares a new JavaScript command to be used with dynamically loaded documents.
+     *
+     * @param name The name of the command to declare.
+     * @param command The reference to a JavaScript command to be used with dynamically loaded documents.
+     */
+    declareCommand(name, command) {
+        this.checkCommandName(name);
+        if (!this._appBridge.hasCommand(name)) {
+            this._appBridge.addCommand(name, command);
+            Object.defineProperty(this, name, {
+                configurable: true,
+                get: function () {
+                    return this._appBridge.getCommand(name);
+                }
+            });
+        }
+    }
+    /**
+     * Unregisters a JavaScript command previously referenced with the `declareCommand()` method.
+     *
+     * @param name The name of the command to remove.
+     *
+     * @returns `true` whether the command existed and has been removed; `false` otherwise.
+     */
+    deleteCommand(name) {
+        this.checkCommandName(name);
+        if (!this._appBridge.removeCommand(name))
+            return false;
+        delete this._defaultView[APP_PRIDGE_REF][name];
+        return true;
+    }
+    /**
+     * Returns the JavaScript command previously referenced with the `declareCommand()` method.
+     *
+     * @param name The name of the command to retrieve.
+     * @returns The JavaScript command previously referenced with the specified `name` parameter.
+     *          If no command is found, returns `undefined`.
+     */
+    getCommand(name) {
+        return this._appBridge.getCommand(name);
+    }
+    /**
+     * @private
+     */
+    checkCommandName(name) {
+        if (NATIVE_COMMANDS.includes(name))
+            throw new AppBridgeError("Command name cannot be the reference to a native command: " + name);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.3", ngImport: i0, type: AppBrigeService, deps: [{ token: i1.Router }, { token: i0.NgZone }, { token: DOCUMENT }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.3", ngImport: i0, type: AppBrigeService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.3", ngImport: i0, type: AppBrigeService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.Router }, { type: i0.NgZone }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"app-bridge.service.js","sourceRoot":"","sources":["../../../../../../../projects/angular-toolbox/src/lib/model/service/ui/app-bridge.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 ound in\r\n * fthe LICENSE file at https://pascalechemann.com/angular-toolbox/resources/license\r\n */\r\n\r\nimport { DOCUMENT } from '@angular/common';\r\nimport { Injectable, NgZone, Inject } from '@angular/core';\r\nimport { NavigationExtras, Router } from '@angular/router';\r\nimport { DEFAULT_SCROLL_BEHAVIOR } from '../../../util/default-scroll-behavior';\r\nimport { AppBridge } from '../../../core/bridge/app-bridge';\r\nimport { AppBridgeError } from '../../../core';\r\nimport { AppBridgeCommand } from '../../business/lang/app-bridge-command';\r\n\r\n/**\r\n * @private\r\n */\r\nexport const APP_PRIDGE_REF: string = \"appBridge\";\r\n\r\n/**\r\n * @private\r\n */\r\nconst HREF: string = \"href\";\r\n\r\n/**\r\n * @private\r\n */\r\nconst NATIVE_COMMANDS: string = \"navigate|goToAnchor|declareCommand|deleteCommand|getCommand\";\r\n\r\n/**\r\n * A utility service that allows dynamically injected HTML fragments, to interact with the Angular application.\r\n */\r\n@Injectable({\r\n    providedIn: 'root'\r\n})\r\nexport class AppBrigeService {\r\n\r\n    /**\r\n     * @private\r\n     */\r\n    private readonly _defaultView: any;\r\n\r\n    /**\r\n     * @private\r\n     * Thereference to the command invoker.\r\n     */\r\n    private readonly _appBridge: AppBridge;\r\n\r\n    /**\r\n     * @private\r\n     */\r\n    constructor(private _router: Router,\r\n                private _zone: NgZone,\r\n                @Inject(DOCUMENT) private _document: any) {\r\n        this._defaultView = _document.defaultView;\r\n        this._appBridge = new AppBridge();\r\n        if(!this._defaultView[APP_PRIDGE_REF]) this._defaultView[APP_PRIDGE_REF] = this;\r\n    }\r\n\r\n    /**\r\n     * Provides the ability to invoke the `navigate()` method of the Angular app router.\r\n     * \r\n     * @param commands The commands array as specified by the Angular router `navigate()` method.\r\n     * @param extras The navigation options as specified by the Angular router `navigate()` method.\r\n     * @return `Promise` that resolves to `true` when navigation succeeds, or `false` when navigation fails.\r\n     * \r\n     * @see https://angular.dev/api/router/Router#navigate\r\n     */\r\n    public navigate(commands: string[], extras?: NavigationExtras | undefined): Promise<boolean> {\r\n        return this._zone.run(() => {\r\n            return this._router.navigate(commands, extras);\r\n        });\r\n    }\r\n\r\n    /**\r\n     * Allows to scroll to the fragment specified by the `href` attribute when the user element interact with the associated element.\r\n     * \r\n     * @example\r\n     * <a href=\"#myAnchor\" onclick=\"appBridge.goToAnchor(event)\">My Section</a></code>\r\n     * \r\n     * @param event The event that triggers the anchor navigation.\r\n     * @return `Promise` that resolves to `true` when navigation succeeds, or `false` when navigation fails.\r\n     * \r\n     * @see https://angular.dev/api/router/Router#navigate\r\n     */\r\n    public goToAnchor(event: Event): Promise<boolean> {\r\n        event.preventDefault();\r\n        const anchor: string = (event.target as any).getAttribute(HREF);\r\n        if (!anchor) throw new ReferenceError(\"href attribute is not defined.\");\r\n        const elm: any = this._document.querySelector(anchor);\r\n        if (!elm) return new Promise((resolve: Function) => resolve(false));\r\n        elm.scrollIntoView(DEFAULT_SCROLL_BEHAVIOR);\r\n        return this._zone.run(() => {\r\n           return this._router.navigate([], { fragment: anchor.slice(1)});\r\n        });\r\n    }\r\n\r\n    /**\r\n     * Declares a new JavaScript command to be used with dynamically loaded documents.\r\n     * \r\n     * @param name The name of the command to declare.\r\n     * @param command The reference to a JavaScript command to be used with dynamically loaded documents.\r\n     */\r\n    public declareCommand(name: string, command: AppBridgeCommand): void {\r\n        this.checkCommandName(name);\r\n        if(!this._appBridge.hasCommand(name)) {\r\n            this._appBridge.addCommand(name, command);\r\n            Object.defineProperty(this, name, {\r\n                configurable: true,\r\n                get: function() {\r\n                    return this._appBridge.getCommand(name);\r\n                }\r\n            });\r\n        }\r\n    }\r\n    \r\n    /**\r\n     * Unregisters a JavaScript command previously referenced with the `declareCommand()` method.\r\n     * \r\n     * @param name The name of the command to remove.\r\n     * \r\n     * @returns `true` whether the command existed and has been removed; `false` otherwise.\r\n     */\r\n    public deleteCommand(name: string): boolean {\r\n        this.checkCommandName(name);\r\n        if(!this._appBridge.removeCommand(name)) return false;\r\n        delete this._defaultView[APP_PRIDGE_REF][name];\r\n        return true;\r\n    }\r\n    \r\n    /**\r\n     * Returns the JavaScript command previously referenced with the `declareCommand()` method.\r\n     * \r\n     * @param name The name of the command to retrieve.\r\n     * @returns The JavaScript command previously referenced with the specified `name` parameter.\r\n     *          If no command is found, returns `undefined`.\r\n     */\r\n    public getCommand(name: string): AppBridgeCommand | undefined {   \r\n        return this._appBridge.getCommand(name);\r\n    }\r\n\r\n    /**\r\n     * @private\r\n     */\r\n    private checkCommandName(name: string): void {\r\n        if (NATIVE_COMMANDS.includes(name)) throw new AppBridgeError(\"Command name cannot be the reference to a native command: \" + name);\r\n    }\r\n}"]}