@energycap/components 0.42.4-esbuild.20250131-1219 → 0.42.4-esbuild.20250131-1256

package/esm2022/lib/core/validation-message.service.mjs

@@ -0,0 +1,185 @@
+import { Injectable } from '@angular/core';
+import { forkJoin, lastValueFrom } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "@ngx-translate/core";
+import * as i2 from "../shared/display/pipes/date-display.pipe";
+/**
+ * "Weak Type" describing interpolation parameters for NumericBox
+ */
+class NumericBoxInterpolationParameters {
+}
+/**
+ * Service to take {@link ValidationErrors} and return meaningful error messages
+ */
+export class ValidationMessageService {
+    constructor(translate, dateDisplayPipe) {
+        this.translate = translate;
+        this.dateDisplayPipe = dateDisplayPipe;
+    }
+    /**
+     * Get meaningful error messages from {@link ValidationErrors}
+     */
+    getErrorMessages(errors) {
+        /** Array of observables returned from the TranslateService. */
+        let translationObservables = new Array();
+        if (errors !== null) {
+            for (var errorKey in errors) {
+                // it would be nice to have typing on the ValidationErrors
+                let error = errors[errorKey];
+                switch (errorKey) {
+                    case 'email':
+                        translationObservables.push(this.translate.get('InvalidEmailValidationMessage_LC'));
+                        break;
+                    case 'required':
+                        translationObservables.push(this.translate.get('is required'));
+                        break;
+                    case 'requiredPlural':
+                        translationObservables.push(this.translate.get('RequiredPluralValidationMessage_LC'));
+                        break;
+                    case 'minlength':
+                        translationObservables.push(this.translate
+                            .get('MinLengthValidationMessage_LC', { minLength: error.requiredLength }));
+                        break;
+                    case 'maxlength':
+                        translationObservables.push(this.translate
+                            .get(`MaxLengthValidationMessage`, { maxLength: error.requiredLength }));
+                        break;
+                    case 'pattern':
+                        translationObservables.push(this.translate.get('IncorrectFormat_LC'));
+                        break;
+                    case 'min':
+                        translationObservables.push(this.translate
+                            .get('MinValueValidationMessage_LC', { minValue: error.min }));
+                        break;
+                    case 'max':
+                        translationObservables.push(this.translate
+                            .get('MaxValueValidationMessage_LC', { maxValue: error.max }));
+                        break;
+                    case 'zipCodeInvalidFormat':
+                        translationObservables.push(this.translate.get('must be 5–9 numbers'));
+                        break;
+                    case 'postalCodeInvalidFormat':
+                        translationObservables.push(this.translate
+                            .get('must be 6 characters, alternating letters and numbers'));
+                        break;
+                    case 'zipCodeNotFound':
+                        translationObservables.push(this.translate
+                            .get('ZipCodeNotFoundValidationMessage_LC'));
+                        break;
+                    // Custom validator from the NumericboxComponent
+                    case 'numericbox':
+                        translationObservables.push(this.getNumericBoxValidationMessages(error));
+                        break;
+                    case 'addnew':
+                        translationObservables.push(this.translate.get('CouldNotBeAddedValidationMessage_LC'));
+                        break;
+                    // Kendo datepicker min error
+                    case 'minError':
+                    case 'minDate':
+                        var value = this.dateDisplayPipe.transform(error.minValue);
+                        translationObservables.push(this.translate
+                            .get('MinValueValidationMessage_LC', { minValue: value }));
+                        break;
+                    // Kendo datepicker max error
+                    case 'maxError':
+                    case 'maxDate':
+                        var value = this.dateDisplayPipe.transform(error.maxValue, true);
+                        translationObservables.push(this.translate
+                            .get('MaxValueValidationMessage_LC', { maxValue: value }));
+                        break;
+                    // Custom validator for the DateRangeComponent
+                    case 'dateRange':
+                        translationObservables.push(this.translate.get('DateRangeValidationMessage_LC'));
+                        break;
+                    case 'password':
+                        translationObservables.push(this.translate.get('PasswordValidationMessage_LC'));
+                        break;
+                    // Custom validator from the TextboxComponent
+                    case 'textbox':
+                        translationObservables.push(this.getTextBoxValidationMessages(error));
+                        break;
+                    case 'notUnique':
+                        translationObservables.push(this.translate.get('MustBeUnique_LC'));
+                        break;
+                    case 'json':
+                        translationObservables.push(this.translate.get('JsonValidationMessage_SC'));
+                        break;
+                    case 'passwordInvalid':
+                        translationObservables.push(this.translate.get('PasswordInvalidValidationMessage_LC'));
+                        break;
+                    case 'domain':
+                        translationObservables.push(this.translate.get('DomainValidationMessage_SC'));
+                        break;
+                    case 'invalidFile':
+                    case 'invalidFormula':
+                        translationObservables.push(this.translate.get('is invalid'));
+                        break;
+                    default:
+                        break;
+                }
+            }
+            if (translationObservables.length > 0) {
+                // forkJoin returns an Observable that emits when all its observables complete.
+                // When forkjoin emits, it emits an array containing the last value returned from
+                // each of its observables.
+                // @see https://www.learnrxjs.io/operators/combination/forkjoin.html
+                // We convert this to a promise so the form controls can display the error messages
+                // asynchronously.
+                return lastValueFrom(forkJoin(translationObservables));
+            }
+        }
+        return Promise.resolve(new Array());
+    }
+    /**
+     * Get proper validation message for @see NumericBoxComponent
+     */
+    getNumericBoxValidationMessages(error) {
+        let interpolationParameters = {};
+        let type = 'Integer';
+        if (error.decimals) {
+            interpolationParameters.precision = error.decimals;
+            type = 'Decimal';
+        }
+        if (error.min !== undefined && error.max !== undefined) {
+            interpolationParameters.minValue = error.min;
+            interpolationParameters.maxValue = error.max;
+            return this.translate.get(`${type}BetweenValidationMessage_LC`, interpolationParameters);
+        }
+        if (error.min !== undefined) {
+            interpolationParameters.minValue = error.min;
+            return this.translate.get(`${type}MinValidationMessage_LC`, interpolationParameters);
+        }
+        if (error.max !== undefined) {
+            interpolationParameters.maxValue = error.max;
+            return this.translate.get(`${type}MaxValidationMessage_LC`, interpolationParameters);
+        }
+        if (error.maxPrecisionDigits) {
+            interpolationParameters.maxPrecisionDigits = error.maxPrecisionDigits;
+            return this.translate.get('MaxPrecisionDigitsValidationMessage_LC', interpolationParameters);
+        }
+        if (error.decimals) {
+            return this.translate.get('DecimalValidationMessage_LC', interpolationParameters);
+        }
+        return this.translate.get('IncorrectFormat_LC');
+    }
+    /**
+     * Given the advanced textbox validation params construct the error message
+     */
+    getTextBoxValidationMessages(error) {
+        if (error.unique) {
+            return this.translate.get('TextboxRequiredAndUnique_LC', { minLength: error.minLength, maxLength: error.maxLength });
+        }
+        else {
+            return this.translate.get('TextboxRequired_LC', { minLength: error.minLength, maxLength: error.maxLength });
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ValidationMessageService, deps: [{ token: i1.TranslateService }, { token: i2.DateDisplayPipe }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ValidationMessageService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ValidationMessageService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.TranslateService }, { type: i2.DateDisplayPipe }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"validation-message.service.js","sourceRoot":"","sources":["../../../../../projects/components/src/lib/core/validation-message.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\r\nimport { ValidationErrors } from '@angular/forms';\r\nimport { TranslateService } from '@ngx-translate/core';\r\nimport { forkJoin, Observable, lastValueFrom } from 'rxjs';\r\n\r\nimport { TextboxValidatorParameters } from '../controls/textbox/textbox.component';\r\nimport { DateDisplayPipe } from '../shared/display/pipes/date-display.pipe';\r\n\r\n/**\r\n * \"Weak Type\" describing interpolation parameters for NumericBox\r\n */\r\nclass NumericBoxInterpolationParameters {\r\n    public precision?: number;\r\n    public minValue?: number;\r\n    public maxValue?: number;\r\n    public minMaxRange?: string;\r\n    public maxPrecisionDigits?: number;\r\n}\r\n\r\n/**\r\n * Service to take {@link ValidationErrors} and return meaningful error messages\r\n */\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class ValidationMessageService {\r\n\r\n  constructor(\r\n      private translate: TranslateService,\r\n      private dateDisplayPipe: DateDisplayPipe\r\n  ) { }\r\n\r\n\r\n  /**\r\n   * Get meaningful error messages from {@link ValidationErrors}\r\n   */\r\n  public getErrorMessages(errors: ValidationErrors | null): Promise<Array<any>> {\r\n\r\n      /** Array of observables returned from the TranslateService. */\r\n      let translationObservables = new Array<Observable<string>>();\r\n\r\n      if (errors !== null) {\r\n\r\n          for (var errorKey in errors) {\r\n              // it would be nice to have typing on the ValidationErrors\r\n              let error = errors[errorKey];\r\n\r\n              switch (errorKey) {\r\n                  case 'email':\r\n                      translationObservables.push(this.translate.get('InvalidEmailValidationMessage_LC'));\r\n                      break;\r\n\r\n                  case 'required':\r\n                      translationObservables.push(this.translate.get('is required'));\r\n                        break;\r\n                    case 'requiredPlural':\r\n                        translationObservables.push(this.translate.get('RequiredPluralValidationMessage_LC'));\r\n                      break;\r\n\r\n                  case 'minlength':\r\n                      translationObservables.push(this.translate\r\n                          .get('MinLengthValidationMessage_LC', { minLength: error.requiredLength }));\r\n                      break;\r\n\r\n                  case 'maxlength':\r\n                      translationObservables.push(this.translate\r\n                          .get(`MaxLengthValidationMessage`, { maxLength: error.requiredLength }));\r\n                      break;\r\n\r\n                  case 'pattern':\r\n                      translationObservables.push(this.translate.get('IncorrectFormat_LC'));\r\n                      break;\r\n\r\n                  case 'min':\r\n                      translationObservables.push(this.translate\r\n                          .get('MinValueValidationMessage_LC', { minValue: error.min }));\r\n                      break;\r\n\r\n                  case 'max':\r\n                      translationObservables.push(this.translate\r\n                          .get('MaxValueValidationMessage_LC', { maxValue: error.max }));\r\n                      break;\r\n\r\n                  case 'zipCodeInvalidFormat':\r\n                      translationObservables.push(this.translate.get('must be 5–9 numbers'));\r\n                      break;\r\n\r\n                  case 'postalCodeInvalidFormat':\r\n                      translationObservables.push(this.translate\r\n                          .get('must be 6 characters, alternating letters and numbers'));\r\n                      break;\r\n\r\n                  case 'zipCodeNotFound':\r\n                      translationObservables.push(this.translate\r\n                          .get('ZipCodeNotFoundValidationMessage_LC'));\r\n                      break;\r\n\r\n                  // Custom validator from the NumericboxComponent\r\n                  case 'numericbox':\r\n                      translationObservables.push(this.getNumericBoxValidationMessages(error));\r\n                      break;\r\n\r\n                  case 'addnew':\r\n                      translationObservables.push(this.translate.get('CouldNotBeAddedValidationMessage_LC'));\r\n                      break;\r\n\r\n                  // Kendo datepicker min error\r\n                  case 'minError':\r\n                  case 'minDate':\r\n                      var value = this.dateDisplayPipe.transform(error.minValue);\r\n                      translationObservables.push(this.translate\r\n                          .get('MinValueValidationMessage_LC', { minValue: value }));\r\n                      break;\r\n\r\n                  // Kendo datepicker max error\r\n                  case 'maxError':\r\n                  case 'maxDate':\r\n                      var value = this.dateDisplayPipe.transform(error.maxValue, true);\r\n                      translationObservables.push(this.translate\r\n                          .get('MaxValueValidationMessage_LC', { maxValue: value }));\r\n                      break;\r\n\r\n                  // Custom validator for the DateRangeComponent\r\n                  case 'dateRange':\r\n                      translationObservables.push(this.translate.get('DateRangeValidationMessage_LC'));\r\n                      break;\r\n\r\n                  case 'password':\r\n                      translationObservables.push(this.translate.get('PasswordValidationMessage_LC'));\r\n                      break;\r\n\r\n                  // Custom validator from the TextboxComponent\r\n                  case 'textbox':\r\n                      translationObservables.push(this.getTextBoxValidationMessages(error));\r\n                      break;\r\n\r\n                  case 'notUnique':\r\n                      translationObservables.push(this.translate.get('MustBeUnique_LC'));\r\n                      break;\r\n\r\n                  case 'json':\r\n                      translationObservables.push(this.translate.get('JsonValidationMessage_SC'));\r\n                      break;\r\n\r\n                  case 'passwordInvalid':\r\n                      translationObservables.push(this.translate.get('PasswordInvalidValidationMessage_LC'));\r\n                      break;\r\n\r\n                  case 'domain':\r\n                      translationObservables.push(this.translate.get('DomainValidationMessage_SC'));\r\n                      break;\r\n                  case 'invalidFile':\r\n                  case 'invalidFormula':\r\n                      translationObservables.push(this.translate.get('is invalid'));\r\n                      break;\r\n                  default:\r\n                      break;\r\n              }\r\n          }\r\n\r\n          if (translationObservables.length > 0) {\r\n\r\n              // forkJoin returns an Observable that emits when all its observables complete.\r\n              // When forkjoin emits, it emits an array containing the last value returned from\r\n              // each of its observables.\r\n              // @see https://www.learnrxjs.io/operators/combination/forkjoin.html\r\n              // We convert this to a promise so the form controls can display the error messages\r\n              // asynchronously.\r\n              return lastValueFrom(forkJoin(translationObservables));\r\n          }\r\n      }\r\n\r\n      return Promise.resolve(new Array<string>());\r\n  }\r\n\r\n\r\n  /**\r\n   * Get proper validation message for @see NumericBoxComponent\r\n   */\r\n  private getNumericBoxValidationMessages(error: any): Observable<any> {\r\n      let interpolationParameters: NumericBoxInterpolationParameters = {};\r\n      let type: string = 'Integer';\r\n\r\n      if (error.decimals) {\r\n          interpolationParameters.precision = error.decimals;\r\n          type = 'Decimal';\r\n      }\r\n\r\n      if (error.min !== undefined && error.max !== undefined) {\r\n          interpolationParameters.minValue = error.min;\r\n          interpolationParameters.maxValue = error.max;\r\n          return this.translate.get(`${type}BetweenValidationMessage_LC`, interpolationParameters);\r\n      }\r\n\r\n      if (error.min !== undefined) {\r\n          interpolationParameters.minValue = error.min;\r\n          return this.translate.get(`${type}MinValidationMessage_LC`, interpolationParameters);\r\n      }\r\n\r\n      if (error.max !== undefined) {\r\n          interpolationParameters.maxValue = error.max;\r\n          return this.translate.get(`${type}MaxValidationMessage_LC`, interpolationParameters);\r\n      }\r\n\r\n      if (error.maxPrecisionDigits) {\r\n          interpolationParameters.maxPrecisionDigits = error.maxPrecisionDigits;\r\n          return this.translate.get('MaxPrecisionDigitsValidationMessage_LC', interpolationParameters);\r\n      }\r\n\r\n      if (error.decimals) {\r\n          return this.translate.get('DecimalValidationMessage_LC', interpolationParameters);\r\n      }\r\n\r\n      return this.translate.get('IncorrectFormat_LC');\r\n  }\r\n\r\n  /**\r\n   * Given the advanced textbox validation params construct the error message\r\n   */\r\n  private getTextBoxValidationMessages(error: TextboxValidatorParameters): Observable<any> {\r\n      if (error.unique) {\r\n          return this.translate.get('TextboxRequiredAndUnique_LC', { minLength: error.minLength, maxLength: error.maxLength });\r\n      } else {\r\n          return this.translate.get('TextboxRequired_LC', { minLength: error.minLength, maxLength: error.maxLength });\r\n      }\r\n  }\r\n\r\n\r\n}\r\n"]}

package/esm2022/lib/core/validation-patterns.mjs

@@ -0,0 +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;
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/core/window.service.mjs

@@ -0,0 +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();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.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: "17.3.12", ngImport: i0, type: WindowService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: WindowService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ 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/esm2022/lib/display/app-bar/app-bar.component.mjs

@@ -0,0 +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];
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: AppBarComponent, deps: [{ token: i1.AvatarService }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.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: "17.3.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: () => [{ 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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

package/esm2022/lib/display/avatar/avatar.component.mjs

@@ -0,0 +1,67 @@
+import { Component, Input } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "./avatar.service";
+export class AvatarComponent {
+    constructor(el, renderer, avatarService) {
+        this.el = el;
+        this.renderer = renderer;
+        this.avatarService = avatarService;
+        /** Color map base on the first let of the label */
+        this.colors = {
+            abcde01: 'red',
+            fghij23: 'orange',
+            klmn15: 'yellow',
+            opqr67: 'green',
+            stuv8: 'blue',
+            wxyz9: 'purple'
+        };
+        /** Label is defaulted to HI in the rare case the user does not have a first name, last name, email or username */
+        this.label = 'HI';
+        /** Track the current CSS class so we can remove it if the user changes before setting the next one */
+        this.currentCSSClass = '';
+    }
+    ngOnChanges(changes) {
+        if (!changes.user.firstChange && !this.user) {
+            console.error(`AvatarComponent expected a value for the [user] input but got ${this.user} instead.`);
+        }
+        this.updateLabel();
+        this.updateColor();
+    }
+    /**
+     * Update the Avatar label
+     *
+     */
+    updateLabel() {
+        if (this.user) {
+            this.label = this.avatarService.getAvatarLabels(this.user).abbreviation;
+        }
+    }
+    /**
+     * Sets the color of the Avatar based on the first letter of the label. If the label is HI or is not
+     * a letter, default to gray.
+     */
+    updateColor() {
+        if (this.currentCSSClass) {
+            this.renderer.removeClass(this.el.nativeElement, this.currentCSSClass);
+        }
+        let color = 'gray';
+        if (this.label !== 'HI' && this.label) {
+            for (let key in this.colors) {
+                if (key.includes(this.label[0].toLowerCase())) {
+                    color = this.colors[key];
+                }
+            }
+        }
+        this.currentCSSClass = `avatar-${color}`;
+        this.renderer.addClass(this.el.nativeElement, this.currentCSSClass);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: AvatarComponent, deps: [{ token: i0.ElementRef }, { token: i0.Renderer2 }, { token: i1.AvatarService }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: AvatarComponent, selector: "ec-avatar", inputs: { user: "user" }, usesOnChanges: true, ngImport: i0, template: '{{label}}', isInline: true, styles: [":host{display:flex;width:2.25rem;height:2.25rem;align-items:center;justify-content:center;font-size:1rem;line-height:1.25rem;border-radius:50%;color:var(--ec-color-primary-light);text-transform:uppercase}:host.avatar-red{background-color:var(--ec-avatar-background-color-red, var(--ec-color-red-5));color:var(--ec-avatar-color-red, var(--ec-color-primary-light))}:host.avatar-orange{background-color:var(--ec-avatar-background-color-orange, var(--ec-color-orange-5));color:var(--ec-avatar-color-orange, var(--ec-color-primary-light))}:host.avatar-yellow{background-color:var(--ec-avatar-background-color-yellow, var(--ec-color-yellow-5));color:var(--ec-avatar-color-yellow, var(--ec-color-secondary-dark))}:host.avatar-green{background-color:var(--ec-avatar-background-color-green, var(--ec-color-green-5));color:var(--ec-avatar-color-green, var(--ec-color-primary-light))}:host.avatar-blue{background-color:var(--ec-avatar-background-color-blue, var(--ec-color-blue-5));color:var(--ec-avatar-color-blue, var(--ec-color-primary-light))}:host.avatar-purple{background-color:var(--ec-avatar-background-color-purple, var(--ec-color-purple-5));color:var(--ec-avatar-color-purple, var(--ec-color-primary-light))}:host.avatar-gray{background-color:var(--ec-avatar-background-color-gray, var(--ec-color-gray-3));color:var(--ec-avatar-color-gray, var(--ec-color-primary-light))}\n"] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: AvatarComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'ec-avatar', template: '{{label}}', styles: [":host{display:flex;width:2.25rem;height:2.25rem;align-items:center;justify-content:center;font-size:1rem;line-height:1.25rem;border-radius:50%;color:var(--ec-color-primary-light);text-transform:uppercase}:host.avatar-red{background-color:var(--ec-avatar-background-color-red, var(--ec-color-red-5));color:var(--ec-avatar-color-red, var(--ec-color-primary-light))}:host.avatar-orange{background-color:var(--ec-avatar-background-color-orange, var(--ec-color-orange-5));color:var(--ec-avatar-color-orange, var(--ec-color-primary-light))}:host.avatar-yellow{background-color:var(--ec-avatar-background-color-yellow, var(--ec-color-yellow-5));color:var(--ec-avatar-color-yellow, var(--ec-color-secondary-dark))}:host.avatar-green{background-color:var(--ec-avatar-background-color-green, var(--ec-color-green-5));color:var(--ec-avatar-color-green, var(--ec-color-primary-light))}:host.avatar-blue{background-color:var(--ec-avatar-background-color-blue, var(--ec-color-blue-5));color:var(--ec-avatar-color-blue, var(--ec-color-primary-light))}:host.avatar-purple{background-color:var(--ec-avatar-background-color-purple, var(--ec-color-purple-5));color:var(--ec-avatar-color-purple, var(--ec-color-primary-light))}:host.avatar-gray{background-color:var(--ec-avatar-background-color-gray, var(--ec-color-gray-3));color:var(--ec-avatar-color-gray, var(--ec-color-primary-light))}\n"] }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }, { type: i0.Renderer2 }, { type: i1.AvatarService }], propDecorators: { user: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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