@energycap/components 0.41.1-ECAP-27592-angular-17.20241223-1652 → 0.41.1-ECAP-26841-date-input-features.20250106-0847

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

@@ -1,38 +1,38 @@
-import { Injectable } from '@angular/core';
-import * as i0 from "@angular/core";
-import * as i1 from "./telemetry-tracker.service";
-export class TelemetryService {
-    constructor(telemetryTrackerService) {
-        this.telemetryTrackerService = telemetryTrackerService;
-    }
-    /**
-     * Tracks a Page View / State change
-     *
-     * @param {string} pageName
-     * @param {string} url
-     * @memberof TelemetryService
-     */
-    trackPageView(pageName, url, properties) {
-        this.telemetryTrackerService.trackPageView(pageName, url, properties);
-    }
-    /**
-     * Tracks a generic event
-     *
-     * @param {string} name
-     * @param {{[key: string]:string}} [properties]
-     * @param {{[val:string]:number}} [measurements]
-     * @memberof TelemetryService
-     */
-    trackEvent(name, properties, measurements) {
-        this.telemetryTrackerService.trackEvent(name, properties, measurements);
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: TelemetryService, deps: [{ token: i1.TelemetryTrackerService }], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: TelemetryService, providedIn: 'root' }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: TelemetryService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root'
-                }]
-        }], ctorParameters: () => [{ type: i1.TelemetryTrackerService }] });
-//# sourceMappingURL=data:application/json;base64,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
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "./telemetry-tracker.service";
+export class TelemetryService {
+    constructor(telemetryTrackerService) {
+        this.telemetryTrackerService = telemetryTrackerService;
+    }
+    /**
+     * Tracks a Page View / State change
+     *
+     * @param {string} pageName
+     * @param {string} url
+     * @memberof TelemetryService
+     */
+    trackPageView(pageName, url, properties) {
+        this.telemetryTrackerService.trackPageView(pageName, url, properties);
+    }
+    /**
+     * Tracks a generic event
+     *
+     * @param {string} name
+     * @param {{[key: string]:string}} [properties]
+     * @param {{[val:string]:number}} [measurements]
+     * @memberof TelemetryService
+     */
+    trackEvent(name, properties, measurements) {
+        this.telemetryTrackerService.trackEvent(name, properties, measurements);
+    }
+}
+TelemetryService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: TelemetryService, deps: [{ token: i1.TelemetryTrackerService }], target: i0.ɵɵFactoryTarget.Injectable });
+TelemetryService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: TelemetryService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: TelemetryService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.TelemetryTrackerService }]; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGVsZW1ldHJ5LnNlcnZpY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9jb21wb25lbnRzL3NyYy9saWIvY29yZS90ZWxlbWV0cnkuc2VydmljZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sZUFBZSxDQUFDOzs7QUFNM0MsTUFBTSxPQUFPLGdCQUFnQjtJQUUzQixZQUFvQix1QkFBZ0Q7UUFBaEQsNEJBQXVCLEdBQXZCLHVCQUF1QixDQUF5QjtJQUFHLENBQUM7SUFFeEU7Ozs7OztPQU1HO0lBQ0ksYUFBYSxDQUFDLFFBQWdCLEVBQUUsR0FBVSxFQUFFLFVBQStDO1FBQ2hHLElBQUksQ0FBQyx1QkFBdUIsQ0FBQyxhQUFhLENBQUMsUUFBUSxFQUFFLEdBQUcsRUFBRSxVQUFVLENBQUMsQ0FBQztJQUN4RSxDQUFDO0lBRUQ7Ozs7Ozs7T0FPRztJQUNJLFVBQVUsQ0FBQyxJQUFZLEVBQUUsVUFBbUMsRUFBRSxZQUFvQztRQUN2RyxJQUFJLENBQUMsdUJBQXVCLENBQUMsVUFBVSxDQUFDLElBQUksRUFBRSxVQUFVLEVBQUUsWUFBWSxDQUFDLENBQUM7SUFDMUUsQ0FBQzs7NkdBekJVLGdCQUFnQjtpSEFBaEIsZ0JBQWdCLGNBRmYsTUFBTTsyRkFFUCxnQkFBZ0I7a0JBSDVCLFVBQVU7bUJBQUM7b0JBQ1YsVUFBVSxFQUFFLE1BQU07aUJBQ25CIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0YWJsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xyXG5pbXBvcnQgeyBUZWxlbWV0cnlUcmFja2VyU2VydmljZSB9IGZyb20gJy4vdGVsZW1ldHJ5LXRyYWNrZXIuc2VydmljZSc7XHJcblxyXG5ASW5qZWN0YWJsZSh7XHJcbiAgcHJvdmlkZWRJbjogJ3Jvb3QnXHJcbn0pXHJcbmV4cG9ydCBjbGFzcyBUZWxlbWV0cnlTZXJ2aWNlIHtcclxuXHJcbiAgY29uc3RydWN0b3IocHJpdmF0ZSB0ZWxlbWV0cnlUcmFja2VyU2VydmljZTogVGVsZW1ldHJ5VHJhY2tlclNlcnZpY2UpIHt9XHJcblxyXG4gIC8qKlxyXG4gICAqIFRyYWNrcyBhIFBhZ2UgVmlldyAvIFN0YXRlIGNoYW5nZSBcclxuICAgKiBcclxuICAgKiBAcGFyYW0ge3N0cmluZ30gcGFnZU5hbWUgXHJcbiAgICogQHBhcmFtIHtzdHJpbmd9IHVybCBcclxuICAgKiBAbWVtYmVyb2YgVGVsZW1ldHJ5U2VydmljZVxyXG4gICAqL1xyXG4gIHB1YmxpYyB0cmFja1BhZ2VWaWV3KHBhZ2VOYW1lOiBzdHJpbmcsIHVybDpzdHJpbmcsIHByb3BlcnRpZXM/OiB7IFtrZXk6IHN0cmluZ106IHN0cmluZyB8IG51bWJlciB9KSB7XHJcbiAgICB0aGlzLnRlbGVtZXRyeVRyYWNrZXJTZXJ2aWNlLnRyYWNrUGFnZVZpZXcocGFnZU5hbWUsIHVybCwgcHJvcGVydGllcyk7XHJcbiAgfVxyXG5cclxuICAvKipcclxuICAgKiBUcmFja3MgYSBnZW5lcmljIGV2ZW50XHJcbiAgICogXHJcbiAgICogQHBhcmFtIHtzdHJpbmd9IG5hbWUgXHJcbiAgICogQHBhcmFtIHt7W2tleTogc3RyaW5nXTpzdHJpbmd9fSBbcHJvcGVydGllc10gXHJcbiAgICogQHBhcmFtIHt7W3ZhbDpzdHJpbmddOm51bWJlcn19IFttZWFzdXJlbWVudHNdIFxyXG4gICAqIEBtZW1iZXJvZiBUZWxlbWV0cnlTZXJ2aWNlXHJcbiAgICovXHJcbiAgcHVibGljIHRyYWNrRXZlbnQobmFtZTogc3RyaW5nLCBwcm9wZXJ0aWVzPzoge1trZXk6IHN0cmluZ106c3RyaW5nfSwgbWVhc3VyZW1lbnRzPzoge1t2YWw6c3RyaW5nXTpudW1iZXJ9KSB7XHJcbiAgICB0aGlzLnRlbGVtZXRyeVRyYWNrZXJTZXJ2aWNlLnRyYWNrRXZlbnQobmFtZSwgcHJvcGVydGllcywgbWVhc3VyZW1lbnRzKTtcclxuICB9XHJcbn1cclxuIl19

package/esm2020/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 });
+        }
+    }
+}
+ValidationMessageService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: ValidationMessageService, deps: [{ token: i1.TranslateService }, { token: i2.DateDisplayPipe }], target: i0.ɵɵFactoryTarget.Injectable });
+ValidationMessageService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: ValidationMessageService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: ValidationMessageService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ 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 → esm2020}/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/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();
+    }
+}
+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"]}