@energycap/components 0.40.2-rxjs-7-upgrade.20241219-1425 → 0.41.1-ECAP-27592-angular-17.20241219-1718

package/{esm2020 → esm2022}/lib/shared/display/pipes/row-count.pipe.mjs

@@ -1,48 +1,48 @@
-import { Pipe } from '@angular/core';
-import * as i0 from "@angular/core";
-import * as i1 from "@ngx-translate/core";
-export class RowCountPipe {
-    constructor(translateService) {
-        this.translateService = translateService;
-    }
-    /**
-     * Get the formatted row count for the results.
-     *
-     * Provide maxItemCount if the normal row count is needed.
-     * Provide pagingInfo if the paged row count is needed.
-     */
-    //Note that totalPagedItemCount is not necessarily equal to pagingInfo.pageSize since the last page could have less than pageSize rows.
-    transform(results, objectType, maxItemCount, pagingInfo) {
-        let translated = this.translateService.instant(objectType || 'results');
-        if (maxItemCount !== undefined) {
-            return this.getResultsCount(results, translated, maxItemCount);
-        }
-        else if (pagingInfo) {
-            return this.getPagedResultsCount(results, translated, pagingInfo);
-        }
-        return '';
-    }
-    getResultsCount(results, objectType, maxItemCount) {
-        // If the filtered results count of rows is greater than the maximum number
-        // of results we want to show, we have already pared the results down,
-        // so tell user we are displaying the first `maxItemCount` results out of the total
-        // count of filtered results.
-        if (results.totalItems > maxItemCount) {
-            return `${maxItemCount} ${this.translateService.instant('of')} ${results.totalItems}`;
-        }
-        return `${results.totalItems} ${objectType}`;
-    }
-    getPagedResultsCount(results, objectType, pagingInfo) {
-        let prefix = `${pagingInfo.skip + 1}` + (results.totalItems > 1 ? `-${pagingInfo.skip + results.totalItems} ` : ' ');
-        return prefix + `${this.translateService.instant('of')} ${results.totalItemsBeforePaging} ${objectType}`;
-    }
-}
-RowCountPipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: RowCountPipe, deps: [{ token: i1.TranslateService }], target: i0.ɵɵFactoryTarget.Pipe });
-RowCountPipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "15.2.9", ngImport: i0, type: RowCountPipe, name: "rowCount" });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: RowCountPipe, decorators: [{
-            type: Pipe,
-            args: [{
-                    name: 'rowCount'
-                }]
-        }], ctorParameters: function () { return [{ type: i1.TranslateService }]; } });
-//# sourceMappingURL=data:application/json;base64,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
+import { Pipe } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@ngx-translate/core";
+export class RowCountPipe {
+    constructor(translateService) {
+        this.translateService = translateService;
+    }
+    /**
+     * Get the formatted row count for the results.
+     *
+     * Provide maxItemCount if the normal row count is needed.
+     * Provide pagingInfo if the paged row count is needed.
+     */
+    //Note that totalPagedItemCount is not necessarily equal to pagingInfo.pageSize since the last page could have less than pageSize rows.
+    transform(results, objectType, maxItemCount, pagingInfo) {
+        let translated = this.translateService.instant(objectType || 'results');
+        if (maxItemCount !== undefined) {
+            return this.getResultsCount(results, translated, maxItemCount);
+        }
+        else if (pagingInfo) {
+            return this.getPagedResultsCount(results, translated, pagingInfo);
+        }
+        return '';
+    }
+    getResultsCount(results, objectType, maxItemCount) {
+        // If the filtered results count of rows is greater than the maximum number
+        // of results we want to show, we have already pared the results down,
+        // so tell user we are displaying the first `maxItemCount` results out of the total
+        // count of filtered results.
+        if (results.totalItems > maxItemCount) {
+            return `${maxItemCount} ${this.translateService.instant('of')} ${results.totalItems}`;
+        }
+        return `${results.totalItems} ${objectType}`;
+    }
+    getPagedResultsCount(results, objectType, pagingInfo) {
+        let prefix = `${pagingInfo.skip + 1}` + (results.totalItems > 1 ? `-${pagingInfo.skip + results.totalItems} ` : ' ');
+        return prefix + `${this.translateService.instant('of')} ${results.totalItemsBeforePaging} ${objectType}`;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: RowCountPipe, deps: [{ token: i1.TranslateService }], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "16.2.12", ngImport: i0, type: RowCountPipe, name: "rowCount" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: RowCountPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'rowCount'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.TranslateService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/{esm2020 → esm2022}/lib/shared/display/pipes/time-display.pipe.mjs

@@ -1,41 +1,41 @@
-import { Pipe } from '@angular/core';
-import moment from 'moment';
-import * as i0 from "@angular/core";
-import * as i1 from "../../user-preference.service";
-/**
- * Format a time to the user's preference for display
- */
-export class TimeDisplayPipe {
-    constructor(userPreferenceService) {
-        this.userPreferenceService = userPreferenceService;
-        this.lastFormatString = 'HH:mm:ss';
-    }
-    /**
-     * Format a time for display, accounting for user's display preferences.
-     */
-    transform(time, showSeconds) {
-        let display = '';
-        let formatString = '';
-        // use user-preferred formats
-        this.userPreferenceService.getPreferences().subscribe(result => {
-            //if preferences exist then format time to users preference 
-            //otherwise use the last user preference
-            if (result.preference) {
-                formatString = result.preference.timeFormat;
-                if (!showSeconds) {
-                    formatString = formatString.replace(':ss', '');
-                }
-                this.lastFormatString = formatString;
-            }
-        });
-        display = moment(time).format(this.lastFormatString);
-        return display;
-    }
-}
-TimeDisplayPipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: TimeDisplayPipe, deps: [{ token: i1.UserPreferenceService }], target: i0.ɵɵFactoryTarget.Pipe });
-TimeDisplayPipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "15.2.9", ngImport: i0, type: TimeDisplayPipe, name: "timeDisplay" });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: TimeDisplayPipe, decorators: [{
-            type: Pipe,
-            args: [{ name: 'timeDisplay' }]
-        }], ctorParameters: function () { return [{ type: i1.UserPreferenceService }]; } });
-//# sourceMappingURL=data:application/json;base64,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
+import { Pipe } from '@angular/core';
+import moment from 'moment';
+import * as i0 from "@angular/core";
+import * as i1 from "../../user-preference.service";
+/**
+ * Format a time to the user's preference for display
+ */
+export class TimeDisplayPipe {
+    constructor(userPreferenceService) {
+        this.userPreferenceService = userPreferenceService;
+        this.lastFormatString = 'HH:mm:ss';
+    }
+    /**
+     * Format a time for display, accounting for user's display preferences.
+     */
+    transform(time, showSeconds) {
+        let display = '';
+        let formatString = '';
+        // use user-preferred formats
+        this.userPreferenceService.getPreferences().subscribe(result => {
+            //if preferences exist then format time to users preference 
+            //otherwise use the last user preference
+            if (result.preference) {
+                formatString = result.preference.timeFormat;
+                if (!showSeconds) {
+                    formatString = formatString.replace(':ss', '');
+                }
+                this.lastFormatString = formatString;
+            }
+        });
+        display = moment(time).format(this.lastFormatString);
+        return display;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: TimeDisplayPipe, deps: [{ token: i1.UserPreferenceService }], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "16.2.12", ngImport: i0, type: TimeDisplayPipe, name: "timeDisplay" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: TimeDisplayPipe, decorators: [{
+            type: Pipe,
+            args: [{ name: 'timeDisplay' }]
+        }], ctorParameters: function () { return [{ type: i1.UserPreferenceService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/shared/display.mjs

@@ -0,0 +1,6 @@
+/** Common unicode strings */
+export class UnicodeStrings {
+    /** Equivalent of – */
+    static { this.ndash = '\u2013'; }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/shared/form-group.helper.mjs

@@ -0,0 +1,67 @@
+import { Injectable } from '@angular/core';
+import { Validators } from '@angular/forms';
+import * as i0 from "@angular/core";
+/**
+ * Helper for Form Groups
+ */
+export class FormGroupHelper {
+    /**
+     * Call patchValue on the formGroup with only the properties
+     * that actually have values in updates. This method will ignore
+     * any value that is either null or undefined
+     */
+    patchValueSafely(formGroup, updates) {
+        let safeUpdates = {};
+        Object.keys(updates).forEach(function (propName) {
+            let rawValue = updates[propName];
+            if (rawValue !== null && rawValue !== undefined) {
+                safeUpdates[propName] = rawValue;
+            }
+        });
+        formGroup.patchValue(safeUpdates);
+    }
+    /**
+     * Get an id for the form controls input
+     */
+    getInputId(id) {
+        return id + '_input';
+    }
+    /**
+     * Takes in a control and returns a function that sets the control's required validator based on
+     * whether the value provided is empty or not. Adds the required validator if the value provided is
+     * not empty, otherwise removes the required validator. Useful for dynamically setting the requiredness
+     * of a control based on whether another control has a value or not.
+     *
+     * @param control
+     * @param keepValidators - Array of Validators to leave configured on the control. Any existing
+     * validators on the control will be lost if this is left empty.
+     * @param isZeroEmpty - If true, a numeric zero will be considered an empty value. Default is false.
+     */
+    setRequiredFn(control, keepValidators = [], isZeroEmpty = false) {
+        return (value) => {
+            let validators = [...keepValidators];
+            // If the value is not empty, add the required validator.
+            if (value || (!isZeroEmpty ? value === 0 : false)) {
+                validators.push(Validators.required);
+            }
+            if (validators.length > 0) {
+                control.setValidators(validators);
+            }
+            else {
+                control.clearValidators();
+            }
+            // Recalculating the value is required when changing the validators, otherwise
+            // the validator won't take effect until the value is changed in the control.
+            control.updateValueAndValidity({ emitEvent: false });
+        };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: FormGroupHelper, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: FormGroupHelper, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: FormGroupHelper, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/{esm2020 → esm2022}/lib/shared/json-helper.mjs

@@ -1,19 +1,19 @@
-export class JsonHelper {
-    /**
-     * Parse given JSON text into an object.
-     * Returns undefined if text cannot be parsed as JSON.
-     */
-    static tryParseJSON(text) {
-        if (!text) {
-            return undefined;
-        }
-        try {
-            const result = JSON.parse(text);
-            return result;
-        }
-        catch (err) {
-            return undefined;
-        }
-    }
-}
+export class JsonHelper {
+    /**
+     * Parse given JSON text into an object.
+     * Returns undefined if text cannot be parsed as JSON.
+     */
+    static tryParseJSON(text) {
+        if (!text) {
+            return undefined;
+        }
+        try {
+            const result = JSON.parse(text);
+            return result;
+        }
+        catch (err) {
+            return undefined;
+        }
+    }
+}
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoianNvbi1oZWxwZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9jb21wb25lbnRzL3NyYy9saWIvc2hhcmVkL2pzb24taGVscGVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE1BQU0sT0FBTyxVQUFVO0lBRXJCOzs7T0FHRztJQUNJLE1BQU0sQ0FBQyxZQUFZLENBQUMsSUFBK0I7UUFDeEQsSUFBSSxDQUFDLElBQUksRUFBRTtZQUNULE9BQU8sU0FBUyxDQUFDO1NBQ2xCO1FBRUQsSUFBSTtZQUNGLE1BQU0sTUFBTSxHQUFHLElBQUksQ0FBQyxLQUFLLENBQUMsSUFBSSxDQUFDLENBQUM7WUFDaEMsT0FBTyxNQUFNLENBQUM7U0FDZjtRQUFDLE9BQU8sR0FBRyxFQUFFO1lBQ1osT0FBTyxTQUFTLENBQUM7U0FDbEI7SUFDSCxDQUFDO0NBQ0YiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgY2xhc3MgSnNvbkhlbHBlciB7XHJcblxyXG4gIC8qKlxyXG4gICAqIFBhcnNlIGdpdmVuIEpTT04gdGV4dCBpbnRvIGFuIG9iamVjdC5cclxuICAgKiBSZXR1cm5zIHVuZGVmaW5lZCBpZiB0ZXh0IGNhbm5vdCBiZSBwYXJzZWQgYXMgSlNPTi5cclxuICAgKi9cclxuICBwdWJsaWMgc3RhdGljIHRyeVBhcnNlSlNPTih0ZXh0OiBzdHJpbmcgfCBudWxsIHwgdW5kZWZpbmVkKTogdW5rbm93biB8IHVuZGVmaW5lZCB7XHJcbiAgICBpZiAoIXRleHQpIHtcclxuICAgICAgcmV0dXJuIHVuZGVmaW5lZDtcclxuICAgIH1cclxuXHJcbiAgICB0cnkge1xyXG4gICAgICBjb25zdCByZXN1bHQgPSBKU09OLnBhcnNlKHRleHQpO1xyXG4gICAgICByZXR1cm4gcmVzdWx0O1xyXG4gICAgfSBjYXRjaCAoZXJyKSB7XHJcbiAgICAgIHJldHVybiB1bmRlZmluZWQ7XHJcbiAgICB9XHJcbiAgfVxyXG59Il19

package/esm2022/lib/shared/lodash-helper.mjs

@@ -0,0 +1,52 @@
+import { get, orderBy, sortBy } from "lodash";
+/** A wrapper around the lodash sortBy that supports treating upper case and lower case text as the same.
+ * If the underlying property value is not a string (or is null or undefined) this function will behave just like lodash's original
+ * The original array is not modified, and the result is a newly created array to avoid any side effects (just like the lodash implementation)
+ * String properties are normalized by case for comparisons to prevent sorting AbC as ACb
+ * @param items - the set of items to sort. Expected to be a set of complex objects to sort by the given properties
+ * @param properties - a list of values, each of which can be number, date, string, etc property types.
+ *        Can be the name or path to the property to look at, passed to the lodash get function so "address.line1" works if item is
+ *        a meter object like {meterName: 'name', addres: { line1: '100 Factory Street' } }
+ * @see https://lodash.com/docs/4.17.10#get
+*/
+export function sortByIgnoreCase(items, properties) {
+    let iteratees = [];
+    iteratees = properties.map(prop => {
+        return (item) => safeToLower(item, prop);
+    });
+    return sortBy(items, iteratees);
+}
+/**
+ * A wrapper around the lodash orderBy that supports treating upper case and lower case text as the same.
+ * @param items - the set of items to sort. Expected to be a set of complex objects to sort by the given properties
+ * @param properties - a list of values, each of which can be number, date, string, etc property types.
+ * @param direction - the direction in which to sort, the pass in an array of directions to match an array of properties
+ */
+export function orderByIgnoreCase(items, properties, direction) {
+    let iteratees = [];
+    iteratees = properties.map(prop => {
+        // Treat nulls as empty string to sort them at the bottom when decending, helpful when looking at dates
+        return (item) => safeToLower(item, prop) || '';
+    });
+    return orderBy(items, iteratees, direction);
+}
+/**
+ * Convert the provided item's property to the lowercase version of it if that property
+ * has a value and the value is a string. Non-string or null/undefined values are kept exactly as they were
+ * @param item - the object on which the value will  be read and interpreted
+ * @param prop - the name or path to the property to look at, passed to the lodash get function so "address.line1" works if item is
+ * a meter object like {meterName: 'name', address: { line1: '100 Factory Street' } }
+ * @see https://lodash.com/docs/4.17.10#get
+ */
+function safeToLower(item, prop) {
+    let value = get(item, prop);
+    if (item && typeof value === 'string') {
+        return value.toLowerCase();
+    }
+    else {
+        // @ts-ignore
+        return item[prop];
+    }
+}
+;
+//# sourceMappingURL=data:application/json;base64,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