@energycap/components 0.41.0 → 0.41.1-ECAP-27592-angular-17.20241219-1718

package/{esm2020 → esm2022}/lib/core/validation-patterns.mjs

@@ -1,31 +1,31 @@
-/** Regex to flag all spaces */
-export const findAllSpacesPattern = / /g;
-/** Pattern to validate United States zip codes.  Allows numbers and dash only */
-export const unitedStatesZipCodeRegex = /^[0-9-]+$/;
-/** Pattern to validate Canadian postal codes,
- *  must follow the 'letter number letter space number letter number' pattern */
-export const canadianPostalCodeRegex = /^[a-zA-Z][0-9][a-zA-Z] [0-9][a-zA-Z][0-9]$/;
-/** Pattern to validate other country zip codes, anything goes */
-export const otherZipCodeRegex = /.*/;
-/** Pattern to validate a correct date format */
-export const dateInputFormatRegex = /^[0-9./-]+$/;
-/** Pattern to validate integer numbers.  Negative sign is optional and will not
- *  invalidate if just a minus sign is entered in the input, any digit `0-9` is allowed
- */
-export const integerPattern = new RegExp("^(-)?([\\d]+)?$");
-/** Pattern to validate most public domains */
-export const domainPattern = /^(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?\.)+[a-z0-9][a-z0-9-]{0,61}[a-z0-9]$/i;
-/**
- * Function to return a decimal RegExp.  Takes in the number of decimals to validate
- * against
- */
-export const getDecimalPattern = (decimals) => {
-    let decimalPattern;
-    // Decimal portion, allowing zero to the maximum allowed decimals
-    // This enables us to allow a number like "1." or "." and not invalidate
-    let decimalPortion = "{0," + decimals.toString() + "}";
-    // Negative sign is optional as well as the decimal, any digit 0-9 is allowed
-    decimalPattern = new RegExp(`^((((-)?\\d+\\.?\\d${decimalPortion}?)|((-)?\\.?\\d${decimalPortion})))?$`);
-    return decimalPattern;
-};
+/** Regex to flag all spaces */
+export const findAllSpacesPattern = / /g;
+/** Pattern to validate United States zip codes.  Allows numbers and dash only */
+export const unitedStatesZipCodeRegex = /^[0-9-]+$/;
+/** Pattern to validate Canadian postal codes,
+ *  must follow the 'letter number letter space number letter number' pattern */
+export const canadianPostalCodeRegex = /^[a-zA-Z][0-9][a-zA-Z] [0-9][a-zA-Z][0-9]$/;
+/** Pattern to validate other country zip codes, anything goes */
+export const otherZipCodeRegex = /.*/;
+/** Pattern to validate a correct date format */
+export const dateInputFormatRegex = /^[0-9./-]+$/;
+/** Pattern to validate integer numbers.  Negative sign is optional and will not
+ *  invalidate if just a minus sign is entered in the input, any digit `0-9` is allowed
+ */
+export const integerPattern = new RegExp("^(-)?([\\d]+)?$");
+/** Pattern to validate most public domains */
+export const domainPattern = /^(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?\.)+[a-z0-9][a-z0-9-]{0,61}[a-z0-9]$/i;
+/**
+ * Function to return a decimal RegExp.  Takes in the number of decimals to validate
+ * against
+ */
+export const getDecimalPattern = (decimals) => {
+    let decimalPattern;
+    // Decimal portion, allowing zero to the maximum allowed decimals
+    // This enables us to allow a number like "1." or "." and not invalidate
+    let decimalPortion = "{0," + decimals.toString() + "}";
+    // Negative sign is optional as well as the decimal, any digit 0-9 is allowed
+    decimalPattern = new RegExp(`^((((-)?\\d+\\.?\\d${decimalPortion}?)|((-)?\\.?\\d${decimalPortion})))?$`);
+    return decimalPattern;
+};
 //# sourceMappingURL=data:application/json;base64,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

package/{esm2020 → esm2022}/lib/core/window.service.mjs

@@ -1,186 +1,186 @@
-import { Injectable } from '@angular/core';
-import { fromEvent } from 'rxjs';
-import * as i0 from "@angular/core";
-import * as i1 from "@angular/router";
-/**
- * Service to help with interfacing with the window object
- * and navigating around the application (going outside of the Angular 2+ router)
- */
-export class WindowService {
-    /**
-     * Tracks if there are any unsaved changes that the user could lose.
-     *
-     * It is set up as `get` only because it is set with `addNavigateAwayPrompt`.
-     *
-     * This also includes adding a prompt to the window itself (in addition to
-     * working with the `CanDeactivateUnsavedChanges` guard) to cover page reloads
-     * which do not trigger router events.
-     */
-    get hasUnsavedChanges() {
-        return this._hasUnsavedChanges;
-    }
-    /**
-     * Expose the innerWidth on the window global. Protects against errors when code
-     * is running on a non-browser platform.
-     */
-    get innerWidth() {
-        return window ? window.innerWidth : undefined;
-    }
-    constructor(router, activatedRoute) {
-        this.router = router;
-        this.activatedRoute = activatedRoute;
-        this._hasUnsavedChanges = false;
-        /**
-         * Function called when the window `beforeunload` event is fired.
-         *
-         * A reference to the function that was passed to `window.addEventListener`
-         * must be retained for `window.removeEventListener` to function properly.
-         *
-         * Some browsers require the event's `returnValue` to be set to show the confirmation
-         * dialog.
-         * @see https://developer.mozilla.org/en-US/docs/Web/API/Window/beforeunload_event
-         */
-        this.beforeUnloadFunction = (event) => {
-            // Cancel the event as stated by the standard.
-            event.preventDefault();
-            // Chrome requires returnValue to be set.
-            event.returnValue = '';
-        };
-        if (window) {
-            this.resized = fromEvent(window, 'resize');
-        }
-    }
-    /**
-     * Navigates to the previous page the user had visited
-     */
-    goBack() {
-        window.history.back();
-    }
-    /**An abstraction around the browsers window history length.
-     * Returns zero if unable to access or running outside a browser context
-     */
-    getHistoryLength() {
-        return window?.history?.length || 0;
-    }
-    /**
-     * Navigate to any url you know the path to
-     * @param url The URL to navigate to
-     *
-     * @deprecated For legacy support only; use `router.navigateByUrl` instead
-     */
-    async navigateToUrl(url) {
-        try {
-            if (url.indexOf('/app/') === 0) {
-                await this.router.navigateByUrl(url.substring(5));
-            }
-            else {
-                await this.router.navigateByUrl(url);
-            }
-        }
-        catch (e) {
-            // If the router throws we will try to navigate to the fully qualified url as a last ditch effort.
-            // This can happen if we missed a link that needs to be converted to ng5 or our ng1Href directive
-            // didn't handle a link correctly
-            window.location.href = url;
-        }
-    }
-    /**
-     * Adds a `beforeunload` function to the window to alert the user that there are about to leave
-     * the current page and ask if they'd like to leave or stay
-     */
-    addNavigateAwayPrompt() {
-        this._hasUnsavedChanges = true;
-        window.addEventListener("beforeunload", this.beforeUnloadFunction);
-    }
-    /**
-     * Removes the `beforeunload` function added to the window
-     */
-    removeNavigateAwayPrompt() {
-        this._hasUnsavedChanges = false;
-        window.removeEventListener("beforeunload", this.beforeUnloadFunction);
-    }
-    /**
-     * Send data to another window.
-     *
-     * __SECURITY RISK__ - Always use a specific target origin. Failing to provide a specific target origin can allow
-     * malicious sites to receive the message.
-     *
-     * @param targetWindow - Window to send the message to
-     * @param message - Data to send
-     * @param targetOrigin - What the URI of the target window must be for the message to be sent.
-     * If sending data to another EnergyCAP window, this should always be `window.location.origin` to ensure
-     * that only instances of EnergyCAP app receive the message.
-     */
-    postMessage(targetWindow, message, targetOrigin) {
-        targetWindow.postMessage(message, targetOrigin);
-    }
-    /**
-     * Open a new window
-     * @param url - The URL of the resource to be loaded
-     */
-    openNew(url) {
-        window.open(url, '_blank');
-    }
-    /**
-     * A wrapper around the router for changing the query params for the current url
-     * without creating a new history entry or removing any existing query parameters.
-     * The provided params are updated if they already exist or added to the url if they don't
-     *
-     * @returns a promise that resolves to true if the navigation succeeds, false if something (like a guard) blocks it.
-     * In normal use, the navigation should succeed unless we use query params to block access to a route the user is already on
-     */
-    async modifyHistoryQueryParamsSubset(queryParams) {
-        return this.router.navigate([], {
-            relativeTo: this.activatedRoute,
-            replaceUrl: true,
-            queryParams: queryParams,
-            queryParamsHandling: 'merge',
-        });
-    }
-    /**A wrapper around the default javascript confirm dialog to allow us to unit test dependent code.
-     * Of course eventually we'd like to have pretty confirmations for everything, but in some cases it wasn't worth the extra time
-     * so we're using this instead.
-     */
-    confirm(prompt) {
-        return Promise.resolve(confirm(prompt));
-    }
-    /**
-     * Close the current window or a window instance if one is provided
-     * @param windowInstance - Window to close (optional)
-     */
-    closeWindow(windowInstance) {
-        if (windowInstance) {
-            windowInstance.close();
-        }
-        else {
-            window.close();
-        }
-    }
-    getLocation() {
-        return window.location.pathname + window.location.hash;
-    }
-    /** Get the current value of the full url, including protocol, host and path */
-    getFullUrl() {
-        return window.location.href;
-    }
-    /** Get the current value of the base url, including protocol, domain and port (if explicitly specified) */
-    getBaseUrl() {
-        return window.location.origin;
-    }
-    /**
-     * Reloads the browser window.
-     * NOT RECOMMENDED. Seek other options for reloading content within Angular before resorting to this.
-     */
-    reloadWindow() {
-        window.location.reload();
-    }
-}
-WindowService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: WindowService, deps: [{ token: i1.Router }, { token: i1.ActivatedRoute }], target: i0.ɵɵFactoryTarget.Injectable });
-WindowService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: WindowService, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: WindowService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root'
-                }]
-        }], ctorParameters: function () { return [{ type: i1.Router }, { type: i1.ActivatedRoute }]; } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"window.service.js","sourceRoot":"","sources":["../../../../../projects/components/src/lib/core/window.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\r\nimport { Router, ActivatedRoute, Params } from '@angular/router';\r\nimport { Observable, fromEvent } from 'rxjs';\r\n\r\n/**\r\n * Service to help with interfacing with the window object\r\n * and navigating around the application (going outside of the Angular 2+ router)\r\n */\r\n@Injectable({\r\n    providedIn: 'root'\r\n})\r\nexport class WindowService {\r\n\r\n    /**\r\n     * Tracks if there are any unsaved changes that the user could lose.\r\n     *\r\n     * It is set up as `get` only because it is set with `addNavigateAwayPrompt`.\r\n     *\r\n     * This also includes adding a prompt to the window itself (in addition to\r\n     * working with the `CanDeactivateUnsavedChanges` guard) to cover page reloads\r\n     * which do not trigger router events.\r\n     */\r\n    public get hasUnsavedChanges(): boolean {\r\n        return this._hasUnsavedChanges\r\n    }\r\n    private _hasUnsavedChanges: boolean = false;\r\n\r\n    /** \r\n     * Expose the innerWidth on the window global. Protects against errors when code\r\n     * is running on a non-browser platform.\r\n     */\r\n    public get innerWidth(): number|undefined {\r\n        return window ? window.innerWidth : undefined;\r\n    }\r\n\r\n    /**\r\n     * Observable of the window resize event\r\n     */\r\n    public resized?: Observable<Event>;\r\n\r\n    constructor(\r\n        private router:Router,\r\n        private activatedRoute: ActivatedRoute\r\n    ) { \r\n        if (window) {\r\n            this.resized = fromEvent(window, 'resize');\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Navigates to the previous page the user had visited\r\n     */\r\n    public goBack() {\r\n        window.history.back();\r\n    }\r\n\r\n    /**An abstraction around the browsers window history length.\r\n     * Returns zero if unable to access or running outside a browser context\r\n     */\r\n    public getHistoryLength(): number {\r\n        return window?.history?.length || 0;\r\n    }\r\n\r\n    /**\r\n     * Navigate to any url you know the path to\r\n     * @param url The URL to navigate to\r\n     *\r\n     * @deprecated For legacy support only; use `router.navigateByUrl` instead\r\n     */\r\n    public async navigateToUrl(url: string) {\r\n        try {\r\n            if (url.indexOf('/app/') === 0) {\r\n                await this.router.navigateByUrl(url.substring(5));\r\n            } else {\r\n                await this.router.navigateByUrl(url);\r\n            }\r\n        } catch (e) {\r\n            // If the router throws we will try to navigate to the fully qualified url as a last ditch effort.\r\n            // This can happen if we missed a link that needs to be converted to ng5 or our ng1Href directive\r\n            // didn't handle a link correctly\r\n            window.location.href = url;\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Adds a `beforeunload` function to the window to alert the user that there are about to leave\r\n     * the current page and ask if they'd like to leave or stay\r\n     */\r\n    public addNavigateAwayPrompt(): void {\r\n        this._hasUnsavedChanges = true;\r\n        window.addEventListener(\"beforeunload\", this.beforeUnloadFunction);\r\n    }\r\n\r\n    /**\r\n     * Removes the `beforeunload` function added to the window\r\n     */\r\n    public removeNavigateAwayPrompt(): void {\r\n        this._hasUnsavedChanges = false;\r\n        window.removeEventListener(\"beforeunload\", this.beforeUnloadFunction);\r\n    }\r\n\r\n\r\n    /**\r\n     * Send data to another window.\r\n     *\r\n     * __SECURITY RISK__ - Always use a specific target origin. Failing to provide a specific target origin can allow\r\n     * malicious sites to receive the message.\r\n     *\r\n     * @param targetWindow - Window to send the message to\r\n     * @param message - Data to send\r\n     * @param targetOrigin - What the URI of the target window must be for the message to be sent.\r\n     * If sending data to another EnergyCAP window, this should always be `window.location.origin` to ensure\r\n     * that only instances of EnergyCAP app receive the message.\r\n     */\r\n    public postMessage(targetWindow: Window, message: any, targetOrigin: string) {\r\n        targetWindow.postMessage(message, targetOrigin);\r\n    }\r\n\r\n    /**\r\n     * Open a new window\r\n     * @param url - The URL of the resource to be loaded\r\n     */\r\n    public openNew(url: string): void {\r\n        window.open(url, '_blank');\r\n    }\r\n\r\n    /**\r\n     * A wrapper around the router for changing the query params for the current url \r\n     * without creating a new history entry or removing any existing query parameters.\r\n     * The provided params are updated if they already exist or added to the url if they don't\r\n     * \r\n     * @returns a promise that resolves to true if the navigation succeeds, false if something (like a guard) blocks it.\r\n     * In normal use, the navigation should succeed unless we use query params to block access to a route the user is already on\r\n     */\r\n    public async modifyHistoryQueryParamsSubset(queryParams: Params) : Promise<boolean>{\r\n        return this.router.navigate( [], {\r\n            relativeTo: this.activatedRoute,\r\n            replaceUrl: true,\r\n            queryParams: queryParams,\r\n            queryParamsHandling: 'merge', \r\n        });\r\n    }\r\n\r\n    /**A wrapper around the default javascript confirm dialog to allow us to unit test dependent code.\r\n     * Of course eventually we'd like to have pretty confirmations for everything, but in some cases it wasn't worth the extra time\r\n     * so we're using this instead.\r\n     */\r\n    public confirm(prompt: string): Promise<boolean> {\r\n        return Promise.resolve(confirm(prompt));\r\n    }\r\n\r\n    /**\r\n     * Close the current window or a window instance if one is provided\r\n     * @param windowInstance - Window to close (optional)\r\n     */\r\n    public closeWindow(windowInstance?: Window): void {\r\n        if (windowInstance) {\r\n            windowInstance.close();\r\n        } else {\r\n            window.close();\r\n        }\r\n    }\r\n\r\n    public getLocation(): string {\r\n        return window.location.pathname + window.location.hash;\r\n    }\r\n\r\n    /** Get the current value of the full url, including protocol, host and path */\r\n    public getFullUrl(): string {\r\n        return window.location.href;\r\n    }\r\n\r\n    /** Get the current value of the base url, including protocol, domain and port (if explicitly specified) */\r\n    public getBaseUrl(): string {\r\n        return window.location.origin;\r\n    }\r\n\r\n    /**\r\n     * Reloads the browser window.\r\n     * NOT RECOMMENDED. Seek other options for reloading content within Angular before resorting to this.\r\n     */\r\n    public reloadWindow() {\r\n        window.location.reload();\r\n    }\r\n\r\n    /**\r\n     * Function called when the window `beforeunload` event is fired.\r\n     *\r\n     * A reference to the function that was passed to `window.addEventListener`\r\n     * must be retained for `window.removeEventListener` to function properly.\r\n     *\r\n     * Some browsers require the event's `returnValue` to be set to show the confirmation\r\n     * dialog.\r\n     * @see https://developer.mozilla.org/en-US/docs/Web/API/Window/beforeunload_event\r\n     */\r\n    private beforeUnloadFunction = (event: BeforeUnloadEvent) => {\r\n        // Cancel the event as stated by the standard.\r\n        event.preventDefault();\r\n        // Chrome requires returnValue to be set.\r\n        event.returnValue = '';\r\n    };\r\n}\r\n"]}
+import { Injectable } from '@angular/core';
+import { fromEvent } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+/**
+ * Service to help with interfacing with the window object
+ * and navigating around the application (going outside of the Angular 2+ router)
+ */
+export class WindowService {
+    /**
+     * Tracks if there are any unsaved changes that the user could lose.
+     *
+     * It is set up as `get` only because it is set with `addNavigateAwayPrompt`.
+     *
+     * This also includes adding a prompt to the window itself (in addition to
+     * working with the `CanDeactivateUnsavedChanges` guard) to cover page reloads
+     * which do not trigger router events.
+     */
+    get hasUnsavedChanges() {
+        return this._hasUnsavedChanges;
+    }
+    /**
+     * Expose the innerWidth on the window global. Protects against errors when code
+     * is running on a non-browser platform.
+     */
+    get innerWidth() {
+        return window ? window.innerWidth : undefined;
+    }
+    constructor(router, activatedRoute) {
+        this.router = router;
+        this.activatedRoute = activatedRoute;
+        this._hasUnsavedChanges = false;
+        /**
+         * Function called when the window `beforeunload` event is fired.
+         *
+         * A reference to the function that was passed to `window.addEventListener`
+         * must be retained for `window.removeEventListener` to function properly.
+         *
+         * Some browsers require the event's `returnValue` to be set to show the confirmation
+         * dialog.
+         * @see https://developer.mozilla.org/en-US/docs/Web/API/Window/beforeunload_event
+         */
+        this.beforeUnloadFunction = (event) => {
+            // Cancel the event as stated by the standard.
+            event.preventDefault();
+            // Chrome requires returnValue to be set.
+            event.returnValue = '';
+        };
+        if (window) {
+            this.resized = fromEvent(window, 'resize');
+        }
+    }
+    /**
+     * Navigates to the previous page the user had visited
+     */
+    goBack() {
+        window.history.back();
+    }
+    /**An abstraction around the browsers window history length.
+     * Returns zero if unable to access or running outside a browser context
+     */
+    getHistoryLength() {
+        return window?.history?.length || 0;
+    }
+    /**
+     * Navigate to any url you know the path to
+     * @param url The URL to navigate to
+     *
+     * @deprecated For legacy support only; use `router.navigateByUrl` instead
+     */
+    async navigateToUrl(url) {
+        try {
+            if (url.indexOf('/app/') === 0) {
+                await this.router.navigateByUrl(url.substring(5));
+            }
+            else {
+                await this.router.navigateByUrl(url);
+            }
+        }
+        catch (e) {
+            // If the router throws we will try to navigate to the fully qualified url as a last ditch effort.
+            // This can happen if we missed a link that needs to be converted to ng5 or our ng1Href directive
+            // didn't handle a link correctly
+            window.location.href = url;
+        }
+    }
+    /**
+     * Adds a `beforeunload` function to the window to alert the user that there are about to leave
+     * the current page and ask if they'd like to leave or stay
+     */
+    addNavigateAwayPrompt() {
+        this._hasUnsavedChanges = true;
+        window.addEventListener("beforeunload", this.beforeUnloadFunction);
+    }
+    /**
+     * Removes the `beforeunload` function added to the window
+     */
+    removeNavigateAwayPrompt() {
+        this._hasUnsavedChanges = false;
+        window.removeEventListener("beforeunload", this.beforeUnloadFunction);
+    }
+    /**
+     * Send data to another window.
+     *
+     * __SECURITY RISK__ - Always use a specific target origin. Failing to provide a specific target origin can allow
+     * malicious sites to receive the message.
+     *
+     * @param targetWindow - Window to send the message to
+     * @param message - Data to send
+     * @param targetOrigin - What the URI of the target window must be for the message to be sent.
+     * If sending data to another EnergyCAP window, this should always be `window.location.origin` to ensure
+     * that only instances of EnergyCAP app receive the message.
+     */
+    postMessage(targetWindow, message, targetOrigin) {
+        targetWindow.postMessage(message, targetOrigin);
+    }
+    /**
+     * Open a new window
+     * @param url - The URL of the resource to be loaded
+     */
+    openNew(url) {
+        window.open(url, '_blank');
+    }
+    /**
+     * A wrapper around the router for changing the query params for the current url
+     * without creating a new history entry or removing any existing query parameters.
+     * The provided params are updated if they already exist or added to the url if they don't
+     *
+     * @returns a promise that resolves to true if the navigation succeeds, false if something (like a guard) blocks it.
+     * In normal use, the navigation should succeed unless we use query params to block access to a route the user is already on
+     */
+    async modifyHistoryQueryParamsSubset(queryParams) {
+        return this.router.navigate([], {
+            relativeTo: this.activatedRoute,
+            replaceUrl: true,
+            queryParams: queryParams,
+            queryParamsHandling: 'merge',
+        });
+    }
+    /**A wrapper around the default javascript confirm dialog to allow us to unit test dependent code.
+     * Of course eventually we'd like to have pretty confirmations for everything, but in some cases it wasn't worth the extra time
+     * so we're using this instead.
+     */
+    confirm(prompt) {
+        return Promise.resolve(confirm(prompt));
+    }
+    /**
+     * Close the current window or a window instance if one is provided
+     * @param windowInstance - Window to close (optional)
+     */
+    closeWindow(windowInstance) {
+        if (windowInstance) {
+            windowInstance.close();
+        }
+        else {
+            window.close();
+        }
+    }
+    getLocation() {
+        return window.location.pathname + window.location.hash;
+    }
+    /** Get the current value of the full url, including protocol, host and path */
+    getFullUrl() {
+        return window.location.href;
+    }
+    /** Get the current value of the base url, including protocol, domain and port (if explicitly specified) */
+    getBaseUrl() {
+        return window.location.origin;
+    }
+    /**
+     * Reloads the browser window.
+     * NOT RECOMMENDED. Seek other options for reloading content within Angular before resorting to this.
+     */
+    reloadWindow() {
+        window.location.reload();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: WindowService, deps: [{ token: i1.Router }, { token: i1.ActivatedRoute }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: WindowService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: WindowService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.Router }, { type: i1.ActivatedRoute }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"window.service.js","sourceRoot":"","sources":["../../../../../projects/components/src/lib/core/window.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\r\nimport { Router, ActivatedRoute, Params } from '@angular/router';\r\nimport { Observable, fromEvent } from 'rxjs';\r\n\r\n/**\r\n * Service to help with interfacing with the window object\r\n * and navigating around the application (going outside of the Angular 2+ router)\r\n */\r\n@Injectable({\r\n    providedIn: 'root'\r\n})\r\nexport class WindowService {\r\n\r\n    /**\r\n     * Tracks if there are any unsaved changes that the user could lose.\r\n     *\r\n     * It is set up as `get` only because it is set with `addNavigateAwayPrompt`.\r\n     *\r\n     * This also includes adding a prompt to the window itself (in addition to\r\n     * working with the `CanDeactivateUnsavedChanges` guard) to cover page reloads\r\n     * which do not trigger router events.\r\n     */\r\n    public get hasUnsavedChanges(): boolean {\r\n        return this._hasUnsavedChanges\r\n    }\r\n    private _hasUnsavedChanges: boolean = false;\r\n\r\n    /** \r\n     * Expose the innerWidth on the window global. Protects against errors when code\r\n     * is running on a non-browser platform.\r\n     */\r\n    public get innerWidth(): number|undefined {\r\n        return window ? window.innerWidth : undefined;\r\n    }\r\n\r\n    /**\r\n     * Observable of the window resize event\r\n     */\r\n    public resized?: Observable<Event>;\r\n\r\n    constructor(\r\n        private router:Router,\r\n        private activatedRoute: ActivatedRoute\r\n    ) { \r\n        if (window) {\r\n            this.resized = fromEvent(window, 'resize');\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Navigates to the previous page the user had visited\r\n     */\r\n    public goBack() {\r\n        window.history.back();\r\n    }\r\n\r\n    /**An abstraction around the browsers window history length.\r\n     * Returns zero if unable to access or running outside a browser context\r\n     */\r\n    public getHistoryLength(): number {\r\n        return window?.history?.length || 0;\r\n    }\r\n\r\n    /**\r\n     * Navigate to any url you know the path to\r\n     * @param url The URL to navigate to\r\n     *\r\n     * @deprecated For legacy support only; use `router.navigateByUrl` instead\r\n     */\r\n    public async navigateToUrl(url: string) {\r\n        try {\r\n            if (url.indexOf('/app/') === 0) {\r\n                await this.router.navigateByUrl(url.substring(5));\r\n            } else {\r\n                await this.router.navigateByUrl(url);\r\n            }\r\n        } catch (e) {\r\n            // If the router throws we will try to navigate to the fully qualified url as a last ditch effort.\r\n            // This can happen if we missed a link that needs to be converted to ng5 or our ng1Href directive\r\n            // didn't handle a link correctly\r\n            window.location.href = url;\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Adds a `beforeunload` function to the window to alert the user that there are about to leave\r\n     * the current page and ask if they'd like to leave or stay\r\n     */\r\n    public addNavigateAwayPrompt(): void {\r\n        this._hasUnsavedChanges = true;\r\n        window.addEventListener(\"beforeunload\", this.beforeUnloadFunction);\r\n    }\r\n\r\n    /**\r\n     * Removes the `beforeunload` function added to the window\r\n     */\r\n    public removeNavigateAwayPrompt(): void {\r\n        this._hasUnsavedChanges = false;\r\n        window.removeEventListener(\"beforeunload\", this.beforeUnloadFunction);\r\n    }\r\n\r\n\r\n    /**\r\n     * Send data to another window.\r\n     *\r\n     * __SECURITY RISK__ - Always use a specific target origin. Failing to provide a specific target origin can allow\r\n     * malicious sites to receive the message.\r\n     *\r\n     * @param targetWindow - Window to send the message to\r\n     * @param message - Data to send\r\n     * @param targetOrigin - What the URI of the target window must be for the message to be sent.\r\n     * If sending data to another EnergyCAP window, this should always be `window.location.origin` to ensure\r\n     * that only instances of EnergyCAP app receive the message.\r\n     */\r\n    public postMessage(targetWindow: Window, message: any, targetOrigin: string) {\r\n        targetWindow.postMessage(message, targetOrigin);\r\n    }\r\n\r\n    /**\r\n     * Open a new window\r\n     * @param url - The URL of the resource to be loaded\r\n     */\r\n    public openNew(url: string): void {\r\n        window.open(url, '_blank');\r\n    }\r\n\r\n    /**\r\n     * A wrapper around the router for changing the query params for the current url \r\n     * without creating a new history entry or removing any existing query parameters.\r\n     * The provided params are updated if they already exist or added to the url if they don't\r\n     * \r\n     * @returns a promise that resolves to true if the navigation succeeds, false if something (like a guard) blocks it.\r\n     * In normal use, the navigation should succeed unless we use query params to block access to a route the user is already on\r\n     */\r\n    public async modifyHistoryQueryParamsSubset(queryParams: Params) : Promise<boolean>{\r\n        return this.router.navigate( [], {\r\n            relativeTo: this.activatedRoute,\r\n            replaceUrl: true,\r\n            queryParams: queryParams,\r\n            queryParamsHandling: 'merge', \r\n        });\r\n    }\r\n\r\n    /**A wrapper around the default javascript confirm dialog to allow us to unit test dependent code.\r\n     * Of course eventually we'd like to have pretty confirmations for everything, but in some cases it wasn't worth the extra time\r\n     * so we're using this instead.\r\n     */\r\n    public confirm(prompt: string): Promise<boolean> {\r\n        return Promise.resolve(confirm(prompt));\r\n    }\r\n\r\n    /**\r\n     * Close the current window or a window instance if one is provided\r\n     * @param windowInstance - Window to close (optional)\r\n     */\r\n    public closeWindow(windowInstance?: Window): void {\r\n        if (windowInstance) {\r\n            windowInstance.close();\r\n        } else {\r\n            window.close();\r\n        }\r\n    }\r\n\r\n    public getLocation(): string {\r\n        return window.location.pathname + window.location.hash;\r\n    }\r\n\r\n    /** Get the current value of the full url, including protocol, host and path */\r\n    public getFullUrl(): string {\r\n        return window.location.href;\r\n    }\r\n\r\n    /** Get the current value of the base url, including protocol, domain and port (if explicitly specified) */\r\n    public getBaseUrl(): string {\r\n        return window.location.origin;\r\n    }\r\n\r\n    /**\r\n     * Reloads the browser window.\r\n     * NOT RECOMMENDED. Seek other options for reloading content within Angular before resorting to this.\r\n     */\r\n    public reloadWindow() {\r\n        window.location.reload();\r\n    }\r\n\r\n    /**\r\n     * Function called when the window `beforeunload` event is fired.\r\n     *\r\n     * A reference to the function that was passed to `window.addEventListener`\r\n     * must be retained for `window.removeEventListener` to function properly.\r\n     *\r\n     * Some browsers require the event's `returnValue` to be set to show the confirmation\r\n     * dialog.\r\n     * @see https://developer.mozilla.org/en-US/docs/Web/API/Window/beforeunload_event\r\n     */\r\n    private beforeUnloadFunction = (event: BeforeUnloadEvent) => {\r\n        // Cancel the event as stated by the standard.\r\n        event.preventDefault();\r\n        // Chrome requires returnValue to be set.\r\n        event.returnValue = '';\r\n    };\r\n}\r\n"]}

package/{esm2020 → esm2022}/lib/display/app-bar/app-bar.component.mjs

@@ -1,46 +1,46 @@
-import { Component, Input } from '@angular/core';
-import * as i0 from "@angular/core";
-import * as i1 from "../avatar/avatar.service";
-import * as i2 from "@angular/common";
-import * as i3 from "../../controls/dropdown/dropdown.component";
-import * as i4 from "../avatar/avatar.component";
-export class AppBarComponent {
-    constructor(avatarService) {
-        this.avatarService = avatarService;
-        this.userMenuItems = [];
-        this.userMenuWidth = 0;
-        this.userMenuMinWidth = 160;
-        this.userMenuTabindex = 0;
-        this.iconPath = '/assets/images/icon.svg';
-        this.menuItems = [];
-        this.userItem = [];
-    }
-    ngOnChanges() {
-        if (this.user) {
-            this.userItem[0] = { label: this.avatarService.getAvatarLabels(this.user).full || '', display: 'heading' };
-        }
-        else {
-            this.userItem = [];
-        }
-        this.menuItems = [...this.userItem, ...this.userMenuItems];
-    }
-}
-AppBarComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: AppBarComponent, deps: [{ token: i1.AvatarService }], target: i0.ɵɵFactoryTarget.Component });
-AppBarComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.2.9", type: AppBarComponent, selector: "ec-app-bar", inputs: { user: "user", userMenuItems: "userMenuItems", userMenuWidth: "userMenuWidth", userMenuMinWidth: "userMenuMinWidth", userMenuTabindex: "userMenuTabindex", iconPath: "iconPath" }, usesOnChanges: true, ngImport: i0, template: "<section class=\"logo-container\">\r\n  <img src=\"{{iconPath}}\"\r\n       alt=\"EnergyCAP Platform\">\r\n</section>\r\n\r\n<section class=\"title-container\">\r\n  <ng-content select=\".app-bar-title\"></ng-content>\r\n</section>\r\n\r\n<section class=\"actions-container\">\r\n  <ng-content select=\".app-bar-actions\"></ng-content>\r\n  <ec-dropdown id=\"AppBarUserMenu\"\r\n               *ngIf=\"userMenuItems.length; else avatar\"\r\n               [items]=\"menuItems\"\r\n               [buttonCustomTemplate]=\"avatar\"\r\n               [showArrow]=\"false\"\r\n               [menuWidth]=\"userMenuWidth\"\r\n               [menuMinWidth]=\"userMenuMinWidth\"\r\n               [tabindex]=\"userMenuTabindex\"></ec-dropdown>\r\n</section>\r\n\r\n<ng-template #avatar>\r\n  <ec-avatar [user]=\"user\"></ec-avatar>\r\n</ng-template>", styles: [":host{display:flex;height:3rem;align-items:center;width:100%;padding:0 .75rem 0 1rem;background-color:var(--ec-background-color);position:relative;z-index:var(--ec-z-index-navbar)}:host ::ng-deep .app-bar-actions{display:flex;align-items:center;justify-content:flex-end;margin-right:.25rem}section{flex:1 1}.logo-container img{width:2rem;height:2rem}.title-container{text-align:center}.actions-container{display:flex;justify-content:flex-end}#AppBarUserMenu ::ng-deep ec-button{--ec-border-radius: 50%}#AppBarUserMenu ::ng-deep ec-button.active>.ec-button-custom{background-color:transparent;border-color:var(--ec-color-primary-light)}#AppBarUserMenu ::ng-deep ec-button .ec-button-custom:focus{background-color:var(--ec-background-color)}\n"], dependencies: [{ kind: "directive", type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: i3.DropdownComponent, selector: "ec-dropdown", inputs: ["id", "autofocus", "status", "disabled", "label", "icon", "buttonType", "buttonAlignment", "buttonTitle", "tabindex", "showArrow", "items", "menuTemplateType", "menuTitle", "menuHeight", "menuWidth", "menuMinWidth", "menuPosition", "menuFooter", "popupFixed", "buttonCustomTemplate", "pending"], outputs: ["itemSelected", "popupOpened"] }, { kind: "component", type: i4.AvatarComponent, selector: "ec-avatar", inputs: ["user"] }] });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: AppBarComponent, decorators: [{
-            type: Component,
-            args: [{ selector: 'ec-app-bar', template: "<section class=\"logo-container\">\r\n  <img src=\"{{iconPath}}\"\r\n       alt=\"EnergyCAP Platform\">\r\n</section>\r\n\r\n<section class=\"title-container\">\r\n  <ng-content select=\".app-bar-title\"></ng-content>\r\n</section>\r\n\r\n<section class=\"actions-container\">\r\n  <ng-content select=\".app-bar-actions\"></ng-content>\r\n  <ec-dropdown id=\"AppBarUserMenu\"\r\n               *ngIf=\"userMenuItems.length; else avatar\"\r\n               [items]=\"menuItems\"\r\n               [buttonCustomTemplate]=\"avatar\"\r\n               [showArrow]=\"false\"\r\n               [menuWidth]=\"userMenuWidth\"\r\n               [menuMinWidth]=\"userMenuMinWidth\"\r\n               [tabindex]=\"userMenuTabindex\"></ec-dropdown>\r\n</section>\r\n\r\n<ng-template #avatar>\r\n  <ec-avatar [user]=\"user\"></ec-avatar>\r\n</ng-template>", styles: [":host{display:flex;height:3rem;align-items:center;width:100%;padding:0 .75rem 0 1rem;background-color:var(--ec-background-color);position:relative;z-index:var(--ec-z-index-navbar)}:host ::ng-deep .app-bar-actions{display:flex;align-items:center;justify-content:flex-end;margin-right:.25rem}section{flex:1 1}.logo-container img{width:2rem;height:2rem}.title-container{text-align:center}.actions-container{display:flex;justify-content:flex-end}#AppBarUserMenu ::ng-deep ec-button{--ec-border-radius: 50%}#AppBarUserMenu ::ng-deep ec-button.active>.ec-button-custom{background-color:transparent;border-color:var(--ec-color-primary-light)}#AppBarUserMenu ::ng-deep ec-button .ec-button-custom:focus{background-color:var(--ec-background-color)}\n"] }]
-        }], ctorParameters: function () { return [{ type: i1.AvatarService }]; }, propDecorators: { user: [{
-                type: Input
-            }], userMenuItems: [{
-                type: Input
-            }], userMenuWidth: [{
-                type: Input
-            }], userMenuMinWidth: [{
-                type: Input
-            }], userMenuTabindex: [{
-                type: Input
-            }], iconPath: [{
-                type: Input
-            }] } });
-//# sourceMappingURL=data:application/json;base64,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
+import { Component, Input } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "../avatar/avatar.service";
+import * as i2 from "@angular/common";
+import * as i3 from "../../controls/dropdown/dropdown.component";
+import * as i4 from "../avatar/avatar.component";
+export class AppBarComponent {
+    constructor(avatarService) {
+        this.avatarService = avatarService;
+        this.userMenuItems = [];
+        this.userMenuWidth = 0;
+        this.userMenuMinWidth = 160;
+        this.userMenuTabindex = 0;
+        this.iconPath = '/assets/images/icon.svg';
+        this.menuItems = [];
+        this.userItem = [];
+    }
+    ngOnChanges() {
+        if (this.user) {
+            this.userItem[0] = { label: this.avatarService.getAvatarLabels(this.user).full || '', display: 'heading' };
+        }
+        else {
+            this.userItem = [];
+        }
+        this.menuItems = [...this.userItem, ...this.userMenuItems];
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: AppBarComponent, deps: [{ token: i1.AvatarService }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.12", type: AppBarComponent, selector: "ec-app-bar", inputs: { user: "user", userMenuItems: "userMenuItems", userMenuWidth: "userMenuWidth", userMenuMinWidth: "userMenuMinWidth", userMenuTabindex: "userMenuTabindex", iconPath: "iconPath" }, usesOnChanges: true, ngImport: i0, template: "<section class=\"logo-container\">\r\n  <img src=\"{{iconPath}}\"\r\n       alt=\"EnergyCAP Platform\">\r\n</section>\r\n\r\n<section class=\"title-container\">\r\n  <ng-content select=\".app-bar-title\"></ng-content>\r\n</section>\r\n\r\n<section class=\"actions-container\">\r\n  <ng-content select=\".app-bar-actions\"></ng-content>\r\n  <ec-dropdown id=\"AppBarUserMenu\"\r\n               *ngIf=\"userMenuItems.length; else avatar\"\r\n               [items]=\"menuItems\"\r\n               [buttonCustomTemplate]=\"avatar\"\r\n               [showArrow]=\"false\"\r\n               [menuWidth]=\"userMenuWidth\"\r\n               [menuMinWidth]=\"userMenuMinWidth\"\r\n               [tabindex]=\"userMenuTabindex\"></ec-dropdown>\r\n</section>\r\n\r\n<ng-template #avatar>\r\n  <ec-avatar [user]=\"user\"></ec-avatar>\r\n</ng-template>", styles: [":host{display:flex;height:3rem;align-items:center;width:100%;padding:0 .75rem 0 1rem;background-color:var(--ec-background-color);position:relative;z-index:var(--ec-z-index-navbar)}:host ::ng-deep .app-bar-actions{display:flex;align-items:center;justify-content:flex-end;margin-right:.25rem}section{flex:1 1}.logo-container img{width:2rem;height:2rem}.title-container{text-align:center}.actions-container{display:flex;justify-content:flex-end}#AppBarUserMenu ::ng-deep ec-button{--ec-border-radius: 50%}#AppBarUserMenu ::ng-deep ec-button.active>.ec-button-custom{background-color:transparent;border-color:var(--ec-color-primary-light)}#AppBarUserMenu ::ng-deep ec-button .ec-button-custom:focus{background-color:var(--ec-background-color)}\n"], dependencies: [{ kind: "directive", type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: i3.DropdownComponent, selector: "ec-dropdown", inputs: ["id", "autofocus", "status", "disabled", "label", "icon", "buttonType", "buttonAlignment", "buttonTitle", "tabindex", "showArrow", "items", "menuTemplateType", "menuTitle", "menuHeight", "menuWidth", "menuMinWidth", "menuPosition", "menuFooter", "popupFixed", "buttonCustomTemplate", "pending"], outputs: ["itemSelected", "popupOpened"] }, { kind: "component", type: i4.AvatarComponent, selector: "ec-avatar", inputs: ["user"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: AppBarComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'ec-app-bar', template: "<section class=\"logo-container\">\r\n  <img src=\"{{iconPath}}\"\r\n       alt=\"EnergyCAP Platform\">\r\n</section>\r\n\r\n<section class=\"title-container\">\r\n  <ng-content select=\".app-bar-title\"></ng-content>\r\n</section>\r\n\r\n<section class=\"actions-container\">\r\n  <ng-content select=\".app-bar-actions\"></ng-content>\r\n  <ec-dropdown id=\"AppBarUserMenu\"\r\n               *ngIf=\"userMenuItems.length; else avatar\"\r\n               [items]=\"menuItems\"\r\n               [buttonCustomTemplate]=\"avatar\"\r\n               [showArrow]=\"false\"\r\n               [menuWidth]=\"userMenuWidth\"\r\n               [menuMinWidth]=\"userMenuMinWidth\"\r\n               [tabindex]=\"userMenuTabindex\"></ec-dropdown>\r\n</section>\r\n\r\n<ng-template #avatar>\r\n  <ec-avatar [user]=\"user\"></ec-avatar>\r\n</ng-template>", styles: [":host{display:flex;height:3rem;align-items:center;width:100%;padding:0 .75rem 0 1rem;background-color:var(--ec-background-color);position:relative;z-index:var(--ec-z-index-navbar)}:host ::ng-deep .app-bar-actions{display:flex;align-items:center;justify-content:flex-end;margin-right:.25rem}section{flex:1 1}.logo-container img{width:2rem;height:2rem}.title-container{text-align:center}.actions-container{display:flex;justify-content:flex-end}#AppBarUserMenu ::ng-deep ec-button{--ec-border-radius: 50%}#AppBarUserMenu ::ng-deep ec-button.active>.ec-button-custom{background-color:transparent;border-color:var(--ec-color-primary-light)}#AppBarUserMenu ::ng-deep ec-button .ec-button-custom:focus{background-color:var(--ec-background-color)}\n"] }]
+        }], ctorParameters: function () { return [{ type: i1.AvatarService }]; }, propDecorators: { user: [{
+                type: Input
+            }], userMenuItems: [{
+                type: Input
+            }], userMenuWidth: [{
+                type: Input
+            }], userMenuMinWidth: [{
+                type: Input
+            }], userMenuTabindex: [{
+                type: Input
+            }], iconPath: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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