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

package/esm2020/lib/shared/directives/popup/popup-container.directive.mjs

@@ -0,0 +1,163 @@
+import { Directive, Input, Inject, EventEmitter } from '@angular/core';
+import { DOCUMENT } from '@angular/common';
+import { fromEvent } from "rxjs";
+import Popper from 'popper.js';
+import * as i0 from "@angular/core";
+/**
+ * Primitive directive that popups a container using PopperJS
+ *
+ * @export
+ */
+export class PopupContainerDirective {
+    /**
+     * Creates an instance of PopupContainerDirective.
+     * @param templateRef Reference to the popup template
+     * @param viewContainer Reference to the view container
+     * @param document Reference to Document
+     * @memberof PopupContainerDirective
+     */
+    constructor(templateRef, viewContainer, document, renderer) {
+        this.templateRef = templateRef;
+        this.viewContainer = viewContainer;
+        this.document = document;
+        this.renderer = renderer;
+        /**
+         * Emit the {@link PopupStatus} when it changes
+         */
+        this.popperStatusChange = new EventEmitter();
+    }
+    /**
+     * Angular onInit lifecycle hook
+     * @see https://angular.io/guide/lifecycle-hooks
+     */
+    ngOnInit() {
+        this.templateViewRef = this.viewContainer.createEmbeddedView(this.templateRef);
+    }
+    /**
+     * Angular onDestroy lifecycle hook. Close and delete references. Unsubscribe observables
+     * @see https://angular.io/guide/lifecycle-hooks
+     */
+    ngOnDestroy() {
+        this.hide();
+    }
+    /**
+     * Displays the templateRef as a popup
+     *
+     * @memberof PopupContainerDirective
+     */
+    show() {
+        if (PopupContainerDirective.GlobalPopupRef) {
+            if (PopupContainerDirective.GlobalPopupRef != this) {
+                PopupContainerDirective.GlobalPopupRef.hide();
+                PopupContainerDirective.GlobalPopupRef = undefined;
+            }
+        }
+        if (!this.globalCloseSubscription) {
+            this.globalCloseSubscription = fromEvent(this.document.body, "click").subscribe((event) => {
+                this.hide();
+            });
+        }
+        if (!this.popperRef) {
+            // Add the popper template as an embedded view since PopperJS
+            // manipulates DOM elements.
+            this.popupViewRef = this.viewContainer.createEmbeddedView(this.popup);
+            // Since popper needs real DOM elements, grab the first non-comment
+            // DOM element to use as our anchor.
+            let anchorElement = this.popupViewRef.rootNodes.find(elem => { return elem.nodeName !== "#text"; });
+            // Use the parents elements as our DOM elements to Popper
+            this.popperRef = new Popper(this.templateViewRef.rootNodes[0], anchorElement, this.popperOptions);
+            PopupContainerDirective.GlobalPopupRef = this;
+            this.popperStatusChange.emit('visible');
+        }
+    }
+    /**
+     * Hides the templateRef
+     *
+     * @memberof PopupContainerDirective
+     */
+    hide() {
+        if (this.globalCloseSubscription) {
+            this.globalCloseSubscription.unsubscribe();
+            this.globalCloseSubscription = undefined;
+        }
+        if (this.popperRef && this.popupViewRef) {
+            this.popupViewRef.destroy();
+            this.popperRef.destroy();
+            this.popperRef = undefined;
+            this.popperStatusChange.emit('hidden');
+        }
+    }
+    /**
+     * Updates the popup container position
+     */
+    update() {
+        if (this.popperRef) {
+            this.popperRef.update();
+        }
+    }
+    fixPosition(minWidthNone, appendToBody = false) {
+        if (this.popperRef && this.popperRef['reference'] && this.popperRef['popper']) {
+            let popupEl = this.popperRef['popper'];
+            // Reset width style previously assigned because the content may have
+            // changed and the auto width would be different
+            this.renderer.removeStyle(popupEl, 'width');
+            this.renderer.setStyle(popupEl, 'position', 'fixed');
+            if (appendToBody) {
+                const bodyEl = this.document.querySelector('body');
+                const popupParent = this.renderer.parentNode(popupEl);
+                if (popupParent !== bodyEl) {
+                    this.renderer.appendChild(bodyEl, popupEl);
+                }
+            }
+            let toggleEl = this.popperRef['reference'];
+            let width = popupEl.offsetWidth;
+            let boundaries = popupEl.getBoundingClientRect();
+            let left = boundaries.left;
+            let coords = toggleEl.getBoundingClientRect();
+            // Set the top of our menu to the bottom of the toggle element
+            let top = coords.bottom;
+            if (this.popperOptions && this.popperOptions.placement) {
+                if (this.popperOptions.placement === 'bottom-start' || this.popperOptions.placement === 'top-start') {
+                    left = coords.left;
+                }
+                else {
+                    left = coords.right - ((minWidthNone || width > coords.width) ? width : coords.width);
+                }
+            }
+            // if it won't fit (with 10px space before hitting the window edge), flip it
+            if (boundaries.height + top + 10 > window.innerHeight) {
+                top = coords.top - boundaries.height;
+            }
+            this.renderer.setStyle(popupEl, 'transform', 'none');
+            this.renderer.setStyle(popupEl, 'left', left + 'px');
+            this.renderer.setStyle(popupEl, 'top', top + 'px');
+            this.renderer.setStyle(popupEl, 'width', width + 'px');
+            if (!minWidthNone) {
+                this.renderer.setStyle(popupEl, 'min-width', coords.width + 'px');
+            }
+        }
+    }
+}
+/**
+ *  Global reference to the currently displayed popup; only
+ *  one popup directive can be in `show` state at a given time.
+ *
+ * @memberof PopupContainerDirective
+ */
+PopupContainerDirective.GlobalPopupRef = undefined;
+PopupContainerDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: PopupContainerDirective, deps: [{ token: i0.TemplateRef }, { token: i0.ViewContainerRef }, { token: DOCUMENT }, { token: i0.Renderer2 }], target: i0.ɵɵFactoryTarget.Directive });
+PopupContainerDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.2.9", type: PopupContainerDirective, selector: "[ecPopup]", inputs: { popup: ["ecPopup", "popup"], popperOptions: ["options", "popperOptions"] }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: PopupContainerDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: '[ecPopup]' }]
+        }], ctorParameters: function () { return [{ type: i0.TemplateRef }, { type: i0.ViewContainerRef }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }, { type: i0.Renderer2 }]; }, propDecorators: { popup: [{
+                type: Input,
+                args: ['ecPopup']
+            }], popperOptions: [{
+                type: Input,
+                args: ['options']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"popup-container.directive.js","sourceRoot":"","sources":["../../../../../../../projects/components/src/lib/shared/directives/popup/popup-container.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { Directive, Input, TemplateRef, ViewContainerRef, OnInit, EmbeddedViewRef, OnDestroy, Renderer2, Inject, EventEmitter } from '@angular/core';\r\nimport { DOCUMENT } from '@angular/common';\r\nimport { Subscription, fromEvent } from \"rxjs\";\r\nimport Popper from 'popper.js'\r\n\r\nexport type PopupPlacement = 'top' | 'right' | 'bottom' | 'left' | 'top-start' | 'top-end' | 'bottom-start' | 'bottom-end';\r\nexport type PopupStatus = 'visible' | 'hidden';\r\n\r\n/**\r\n * Primitive directive that popups a container using PopperJS\r\n *\r\n * @export\r\n */\r\n@Directive({ selector: '[ecPopup]' })\r\nexport class PopupContainerDirective implements OnInit, OnDestroy, OnInit {\r\n\r\n    /**\r\n     *  Global reference to the currently displayed popup; only\r\n     *  one popup directive can be in `show` state at a given time.\r\n     *\r\n     * @memberof PopupContainerDirective\r\n     */\r\n    public static GlobalPopupRef?: PopupContainerDirective = undefined;\r\n\r\n    /**\r\n     * TemplateRef of container to popup\r\n     *\r\n     */\r\n    @Input('ecPopup') public popup!: TemplateRef<any>;\r\n\r\n    /**\r\n     * Popper options\r\n     *\r\n     * @memberof PopupContainerDirective\r\n     */\r\n    @Input('options') public popperOptions?: Popper.PopperOptions;\r\n\r\n    /**\r\n     * Template View Reference\r\n     *\r\n     * @memberof PopupContainerDirective\r\n     */\r\n    private templateViewRef!: EmbeddedViewRef<any>;\r\n\r\n    /**\r\n     * Popup View Reference (container)\r\n     *\r\n     * @memberof PopupContainerDirective\r\n     */\r\n    private popupViewRef?: EmbeddedViewRef<any>;\r\n\r\n    /**\r\n     * Popper Reference\r\n     *\r\n     * @memberof PopupContainerDirective\r\n     */\r\n    private popperRef?: Popper;\r\n\r\n    /**\r\n     * Close-to-click Subscription. This allows us to close the menu when you click on the body.\r\n     * We attach it when the menu is open and detach it on close, to limit the lifetime of the click handler\r\n     * which helps with performance on a page with many popup containers\r\n     *\r\n     * @memberof PopupContainerDirective\r\n     */\r\n    private globalCloseSubscription?: Subscription;\r\n\r\n    /**\r\n     * Creates an instance of PopupContainerDirective.\r\n     * @param templateRef Reference to the popup template\r\n     * @param viewContainer Reference to the view container\r\n     * @param document Reference to Document\r\n     * @memberof PopupContainerDirective\r\n     */\r\n    constructor(\r\n        private templateRef: TemplateRef<any>,\r\n        private viewContainer: ViewContainerRef,\r\n        @Inject(DOCUMENT) private document: any,\r\n        private renderer: Renderer2\r\n    ) {}\r\n\r\n    /**\r\n     * Angular onInit lifecycle hook\r\n     * @see https://angular.io/guide/lifecycle-hooks\r\n     */\r\n    ngOnInit(): void {\r\n        this.templateViewRef = this.viewContainer.createEmbeddedView(this.templateRef);\r\n    }\r\n\r\n\r\n    /**\r\n     * Angular onDestroy lifecycle hook. Close and delete references. Unsubscribe observables\r\n     * @see https://angular.io/guide/lifecycle-hooks\r\n     */\r\n    ngOnDestroy(): void {\r\n        this.hide();\r\n    }\r\n\r\n\r\n    /**\r\n     * Emit the {@link PopupStatus} when it changes\r\n     */\r\n    public popperStatusChange: EventEmitter<PopupStatus> = new EventEmitter<PopupStatus>();\r\n\r\n\r\n    /**\r\n     * Displays the templateRef as a popup\r\n     *\r\n     * @memberof PopupContainerDirective\r\n     */\r\n    public show(): void {\r\n        if (PopupContainerDirective.GlobalPopupRef) {\r\n            if (PopupContainerDirective.GlobalPopupRef != this) {\r\n                PopupContainerDirective.GlobalPopupRef.hide();\r\n                PopupContainerDirective.GlobalPopupRef = undefined;\r\n            }\r\n        }\r\n\r\n        if(!this.globalCloseSubscription) {\r\n            this.globalCloseSubscription = fromEvent(this.document.body, \"click\").subscribe((event) => {\r\n                this.hide();\r\n            });\r\n        }\r\n\r\n        if (!this.popperRef) {\r\n            // Add the popper template as an embedded view since PopperJS\r\n            // manipulates DOM elements.\r\n            this.popupViewRef = this.viewContainer.createEmbeddedView(this.popup);\r\n\r\n            // Since popper needs real DOM elements, grab the first non-comment\r\n            // DOM element to use as our anchor.\r\n            let anchorElement = (this.popupViewRef.rootNodes as any[]).find(elem => { return elem.nodeName !== \"#text\" });\r\n\r\n\r\n            // Use the parents elements as our DOM elements to Popper\r\n            this.popperRef = new Popper(\r\n                this.templateViewRef.rootNodes[0],\r\n                anchorElement,\r\n                this.popperOptions);\r\n\r\n\r\n            PopupContainerDirective.GlobalPopupRef = this;\r\n\r\n            this.popperStatusChange.emit('visible');\r\n        }\r\n    }\r\n\r\n\r\n    /**\r\n     * Hides the templateRef\r\n     *\r\n     * @memberof PopupContainerDirective\r\n     */\r\n    public hide(): void {\r\n        if (this.globalCloseSubscription) {\r\n            this.globalCloseSubscription.unsubscribe();\r\n            this.globalCloseSubscription = undefined;\r\n        }\r\n\r\n        if (this.popperRef && this.popupViewRef) {\r\n            this.popupViewRef.destroy();\r\n            this.popperRef.destroy();\r\n            this.popperRef = undefined;\r\n            this.popperStatusChange.emit('hidden');\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Updates the popup container position\r\n     */\r\n    public update(): void {\r\n        if (this.popperRef) {\r\n            this.popperRef.update();\r\n        }\r\n    }\r\n\r\n    public fixPosition(minWidthNone?:boolean, appendToBody=false ):void {\r\n        if(this.popperRef && this.popperRef['reference'] && this.popperRef['popper']) {\r\n            let popupEl = this.popperRef['popper'];\r\n\r\n            // Reset width style previously assigned because the content may have\r\n            // changed and the auto width would be different\r\n            this.renderer.removeStyle(popupEl, 'width');\r\n\r\n            this.renderer.setStyle(popupEl, 'position', 'fixed');\r\n\r\n            if (appendToBody) {\r\n                const bodyEl = this.document.querySelector('body');\r\n                const popupParent = this.renderer.parentNode(popupEl);\r\n                if (popupParent !== bodyEl) {\r\n                    this.renderer.appendChild(bodyEl, popupEl);\r\n                }\r\n            }\r\n\r\n            let toggleEl = this.popperRef['reference'];\r\n            let width = popupEl.offsetWidth;\r\n            let boundaries = popupEl.getBoundingClientRect();\r\n            let left:number = boundaries.left;\r\n            let coords = toggleEl.getBoundingClientRect();\r\n\r\n            // Set the top of our menu to the bottom of the toggle element\r\n            let top:number = coords.bottom;\r\n\r\n            if (this.popperOptions && this.popperOptions.placement) {\r\n                if (this.popperOptions.placement === 'bottom-start' || this.popperOptions.placement === 'top-start') {\r\n                    left = coords.left;\r\n                } else {\r\n                    left = coords.right - ((minWidthNone || width > coords.width) ? width : coords.width);\r\n                }\r\n            }\r\n\r\n            // if it won't fit (with 10px space before hitting the window edge), flip it\r\n            if (boundaries.height + top + 10 > window.innerHeight) {\r\n                top = coords.top - boundaries.height;\r\n            }\r\n\r\n            this.renderer.setStyle(popupEl, 'transform', 'none');\r\n            this.renderer.setStyle(popupEl, 'left', left + 'px');\r\n            this.renderer.setStyle(popupEl, 'top', top + 'px');\r\n            this.renderer.setStyle(popupEl, 'width', width + 'px');\r\n\r\n            if (!minWidthNone) {\r\n                this.renderer.setStyle(popupEl, 'min-width', coords.width + 'px');\r\n            }\r\n        }\r\n    }\r\n}\r\n"]}

package/esm2020/lib/shared/display/pipes/date-display.pipe.mjs

@@ -0,0 +1,50 @@
+import { Pipe } from '@angular/core';
+import { DateTimeHelper } from '../../../core/date-time-helper';
+import moment from 'moment';
+import * as i0 from "@angular/core";
+import * as i1 from "../../user-preference.service";
+/**
+ * Format a date to the user's preference for display
+ */
+export class DateDisplayPipe {
+    constructor(userPreferenceService) {
+        this.userPreferenceService = userPreferenceService;
+        this.lastFormatString = 'MM/DD/YYYY';
+    }
+    /**
+     * Format a date for display, accounting for user's display preferences.
+     *
+     * If {@see date} is null or undefined, or the end of time, returns empty string
+     */
+    transform(date, showEndOfTime, showTime, showSeconds) {
+        let display = '';
+        let formatString = '';
+        if (date && moment(date).isValid() && (showEndOfTime || !DateTimeHelper.isEndOfTime(date))) {
+            // use user-preferred formats
+            this.userPreferenceService.getPreferences().subscribe(result => {
+                //if preferences exist then format date to users preference 
+                //otherwise use the last user preference
+                if (result.preference) {
+                    formatString = result.preference.dateFormat;
+                    if (showTime) {
+                        let timeFormat = result.preference.timeFormat;
+                        if (!showSeconds) {
+                            timeFormat = timeFormat.replace(':ss', '');
+                        }
+                        formatString += ` ${timeFormat}`;
+                    }
+                    this.lastFormatString = formatString;
+                }
+            });
+            display = moment(date).format(this.lastFormatString);
+        }
+        return display;
+    }
+}
+DateDisplayPipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: DateDisplayPipe, deps: [{ token: i1.UserPreferenceService }], target: i0.ɵɵFactoryTarget.Pipe });
+DateDisplayPipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "15.2.9", ngImport: i0, type: DateDisplayPipe, name: "dateDisplay" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: DateDisplayPipe, decorators: [{
+            type: Pipe,
+            args: [{ name: 'dateDisplay' }]
+        }], ctorParameters: function () { return [{ type: i1.UserPreferenceService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/shared/display/pipes/highlight-text.pipe.mjs

@@ -0,0 +1,30 @@
+import { Pipe } from '@angular/core';
+import * as i0 from "@angular/core";
+export class HighlightTextPipe {
+    transform(value, searchText) {
+        let transformedValue = '';
+        if (value && searchText) {
+            const regex = new RegExp(this.escapeRegex(searchText), 'gi');
+            transformedValue = value.replace(regex, this.strongWrap);
+        }
+        else {
+            transformedValue = value;
+        }
+        return transformedValue;
+    }
+    strongWrap(match) {
+        return `<strong class="text-highlight">${match}</strong>`;
+    }
+    escapeRegex(value) {
+        return value.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&');
+    }
+}
+HighlightTextPipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: HighlightTextPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+HighlightTextPipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "15.2.9", ngImport: i0, type: HighlightTextPipe, name: "highlightText" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: HighlightTextPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'highlightText'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/shared/display/pipes/relative-date.pipe.mjs

@@ -0,0 +1,62 @@
+import { Pipe } from '@angular/core';
+import moment from 'moment';
+import * as i0 from "@angular/core";
+import * as i1 from "./date-display.pipe";
+import * as i2 from "./time-display.pipe";
+import * as i3 from "@ngx-translate/core";
+export class RelativeDatePipe {
+    constructor(dateDisplayPipe, timeDisplayPipe, translateService) {
+        this.dateDisplayPipe = dateDisplayPipe;
+        this.timeDisplayPipe = timeDisplayPipe;
+        this.translateService = translateService;
+    }
+    /**
+     * If dateOnly is true, returns timeSelected formatted according to the user's date preference.
+     * If dateOnly is true and showTimeForToday is false and timeSelected is today, returns 'today' or todayLabel
+     * If dateOnly and showTimeForToday is true and timeSelected is today, returns timeSelected formatted according to the user's time preference.
+     * If dateOnly is false, returns timeSelected formatted according to the user's time preference.
+     * If dateOnly is false and timeSelected is not today/yesterday, returns timeSelected formatted according to the user's date plus time preference.
+     * If any of todayLabel, yesterdayLabel is supplied, use the supplied label.
+     */
+    transform(timeSelected, options) {
+        const selected = moment(timeSelected);
+        const today = moment();
+        const yesterday = moment().subtract(1, 'day');
+        const timeDisplay = options?.dateOnly ? `` : ` ${this.timeDisplayPipe.transform(timeSelected)}`;
+        let displayValue = null;
+        let prefixValue = '';
+        if (selected.isSame(today, 'day') && !options?.showTimeForToday) {
+            displayValue = this.translateService.instant(options?.todayLabel ? options?.todayLabel : 'today');
+            prefixValue = options?.todayPrefix ?? '';
+        }
+        else if (selected.isSame(today, 'day') && options?.showTimeForToday && !timeDisplay) {
+            displayValue = this.timeDisplayPipe.transform(timeSelected);
+            prefixValue = options?.todayTimePrefix ?? '';
+        }
+        else if (selected.isSame(yesterday, 'day')) {
+            displayValue = this.translateService.instant(options?.yesterdayLabel ? options?.yesterdayLabel : 'yesterday');
+            prefixValue = options?.yesterdayPrefix ?? '';
+        }
+        else {
+            displayValue = this.dateDisplayPipe.transform(timeSelected);
+        }
+        // If we have a default prefix and no specific ones were set earlier apply the default prefix
+        if (options?.defaultPrefix && prefixValue === '') {
+            prefixValue = options.defaultPrefix;
+        }
+        // Add a space after our prefix if defined
+        if (prefixValue !== '') {
+            prefixValue = `${prefixValue} `;
+        }
+        return `${prefixValue}${displayValue}${timeDisplay}`;
+    }
+}
+RelativeDatePipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: RelativeDatePipe, deps: [{ token: i1.DateDisplayPipe }, { token: i2.TimeDisplayPipe }, { token: i3.TranslateService }], target: i0.ɵɵFactoryTarget.Pipe });
+RelativeDatePipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "15.2.9", ngImport: i0, type: RelativeDatePipe, name: "relativeDate" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: RelativeDatePipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'relativeDate'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.DateDisplayPipe }, { type: i2.TimeDisplayPipe }, { type: i3.TranslateService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/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}`;
+    }
+}
+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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

package/esm2020/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;
+    }
+}
+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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

package/esm2020/lib/shared/display.mjs

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

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

@@ -0,0 +1,67 @@
+import { Validators } from '@angular/forms';
+import { Injectable } from '@angular/core';
+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 });
+        };
+    }
+}
+FormGroupHelper.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: FormGroupHelper, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+FormGroupHelper.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: FormGroupHelper, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: FormGroupHelper, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoianNvbi1oZWxwZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9jb21wb25lbnRzL3NyYy9saWIvc2hhcmVkL2pzb24taGVscGVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE1BQU0sT0FBTyxVQUFVO0lBRXJCOzs7T0FHRztJQUNJLE1BQU0sQ0FBQyxZQUFZLENBQUMsSUFBK0I7UUFDeEQsSUFBSSxDQUFDLElBQUksRUFBRTtZQUNULE9BQU8sU0FBUyxDQUFDO1NBQ2xCO1FBRUQsSUFBSTtZQUNGLE1BQU0sTUFBTSxHQUFHLElBQUksQ0FBQyxLQUFLLENBQUMsSUFBSSxDQUFDLENBQUM7WUFDaEMsT0FBTyxNQUFNLENBQUM7U0FDZjtRQUFDLE9BQU8sR0FBRyxFQUFFO1lBQ1osT0FBTyxTQUFTLENBQUM7U0FDbEI7SUFDSCxDQUFDO0NBQ0YiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgY2xhc3MgSnNvbkhlbHBlciB7XHJcblxyXG4gIC8qKlxyXG4gICAqIFBhcnNlIGdpdmVuIEpTT04gdGV4dCBpbnRvIGFuIG9iamVjdC5cclxuICAgKiBSZXR1cm5zIHVuZGVmaW5lZCBpZiB0ZXh0IGNhbm5vdCBiZSBwYXJzZWQgYXMgSlNPTi5cclxuICAgKi9cclxuICBwdWJsaWMgc3RhdGljIHRyeVBhcnNlSlNPTih0ZXh0OiBzdHJpbmcgfCBudWxsIHwgdW5kZWZpbmVkKTogdW5rbm93biB8IHVuZGVmaW5lZCB7XHJcbiAgICBpZiAoIXRleHQpIHtcclxuICAgICAgcmV0dXJuIHVuZGVmaW5lZDtcclxuICAgIH1cclxuXHJcbiAgICB0cnkge1xyXG4gICAgICBjb25zdCByZXN1bHQgPSBKU09OLnBhcnNlKHRleHQpO1xyXG4gICAgICByZXR1cm4gcmVzdWx0O1xyXG4gICAgfSBjYXRjaCAoZXJyKSB7XHJcbiAgICAgIHJldHVybiB1bmRlZmluZWQ7XHJcbiAgICB9XHJcbiAgfVxyXG59Il19