@energycap/components 0.41.1-ECAP-26841-date-input-features.20250108-1149 → 0.42.1

package/esm2022/lib/shared/display/pipes/row-count.pipe.mjs

@@ -0,0 +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}`;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: RowCountPipe, deps: [{ token: i1.TranslateService }], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "17.3.12", ngImport: i0, type: RowCountPipe, name: "rowCount" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: RowCountPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'rowCount'
+                }]
+        }], ctorParameters: () => [{ type: i1.TranslateService }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/shared/display/pipes/time-display.pipe.mjs

@@ -0,0 +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;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: TimeDisplayPipe, deps: [{ token: i1.UserPreferenceService }], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "17.3.12", ngImport: i0, type: TimeDisplayPipe, name: "timeDisplay" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: TimeDisplayPipe, decorators: [{
+            type: Pipe,
+            args: [{ name: 'timeDisplay' }]
+        }], ctorParameters: () => [{ 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: "17.3.12", ngImport: i0, type: FormGroupHelper, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: FormGroupHelper, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: FormGroupHelper, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

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

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

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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