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

package/{esm2020 → esm2022}/lib/shared/directives/keyboard-nav-container/keyboard-nav-container.directive.mjs

@@ -1,100 +1,100 @@
-import { DOCUMENT } from '@angular/common';
-import { Directive, EventEmitter, Inject, Input, Output } from '@angular/core';
-import { fromEvent, Subject } from 'rxjs';
-import { takeUntil } from 'rxjs/operators';
-import * as i0 from "@angular/core";
-import * as i1 from "@angular/cdk/a11y";
-/**
- * A basic helper directive to determine when focus leaves the host element.
- *
- * NOTE: This directive utilizes hidden anchor elements. These will disrupt tab order for elements
- * within a form. It is recommended to only use this directive when you need to redirect focus when
- * focus leaves a container. Also make sure this directive is disabled when the focus out events
- * are not needed to avoid keyboard nav problems.
- */
-export class KeyboardNavContainerDirective {
-    constructor(hostEl, _document, interactivityChecker) {
-        this.hostEl = hostEl;
-        this._document = _document;
-        this.interactivityChecker = interactivityChecker;
-        this.enabled = true;
-        this.focusOutStart = new EventEmitter();
-        this.focusOutEnd = new EventEmitter();
-        this.destroyed = new Subject();
-        // Create the start and end anchors.
-        this.startAnchor = this._document.createElement('div');
-        this.endAnchor = this._document.createElement('div');
-        // Hide the anchors from screen readers.
-        this.startAnchor.setAttribute('aria-hidden', 'true');
-        this.endAnchor.setAttribute('aria-hidden', 'true');
-    }
-    ngOnChanges() {
-        this.toggleAnchors(this.enabled);
-    }
-    ngAfterViewInit() {
-        // Insert the anchors into the DOM before and after the host element.
-        this.hostEl.nativeElement.parentNode?.insertBefore(this.startAnchor, this.hostEl.nativeElement);
-        this.hostEl.nativeElement.parentNode?.insertBefore(this.endAnchor, this.hostEl.nativeElement.nextSibling);
-        // Listen for focus events on the anchors.
-        fromEvent(this.startAnchor, 'focus').pipe(takeUntil(this.destroyed)).subscribe(() => this.focusOutStart.emit());
-        fromEvent(this.endAnchor, 'focus').pipe(takeUntil(this.destroyed)).subscribe(() => this.focusOutEnd.emit());
-        this.toggleAnchors(this.enabled);
-    }
-    ngOnDestroy() {
-        this.destroyed.next();
-        this.destroyed.complete();
-        // Cleanup the anchors
-        this.startAnchor.remove();
-        this.endAnchor.remove();
-    }
-    focus() {
-        const firstFocusableElement = this.getFirstFocusableElement(this.hostEl.nativeElement);
-        firstFocusableElement?.focus();
-    }
-    getFirstFocusableElement(element) {
-        // These are only possibly focusable. Some may be disabled or not visible.
-        const elements = element.querySelectorAll('input, textarea, select, button, a, [tabindex], [contenteditable]');
-        // Use the Angular CDK interactivity checker to determine if an element is actually focusable and tabbable.
-        // This checks for disabledness among other things.
-        const first = Array.from(elements).find(el => {
-            return this.interactivityChecker.isFocusable(el) && this.interactivityChecker.isTabbable(el);
-        });
-        return first || null;
-    }
-    toggleAnchors(enabled) {
-        // Make the anchors focusable if the container is enabled and we have subscribers for the events.
-        // Otherwise, remove the tabindexes so they cannot receive focus and disrupt the tab order.
-        if (enabled && this.focusOutStart.observers.length > 0) {
-            this.startAnchor.setAttribute('tabindex', '0');
-        }
-        else {
-            this.startAnchor.removeAttribute('tabindex');
-        }
-        if (enabled && this.focusOutEnd.observers.length > 0) {
-            this.endAnchor.setAttribute('tabindex', '0');
-        }
-        else {
-            this.endAnchor.removeAttribute('tabindex');
-        }
-    }
-}
-KeyboardNavContainerDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: KeyboardNavContainerDirective, deps: [{ token: i0.ElementRef }, { token: DOCUMENT }, { token: i1.InteractivityChecker }], target: i0.ɵɵFactoryTarget.Directive });
-KeyboardNavContainerDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.2.9", type: KeyboardNavContainerDirective, selector: "[ecKeyboardNavContainer]", inputs: { enabled: ["ecKeyboardNavContainer", "enabled"] }, outputs: { focusOutStart: "focusOutStart", focusOutEnd: "focusOutEnd" }, exportAs: ["ecKeyboardNavContainer"], usesOnChanges: true, ngImport: i0 });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: KeyboardNavContainerDirective, decorators: [{
-            type: Directive,
-            args: [{
-                    selector: '[ecKeyboardNavContainer]',
-                    exportAs: 'ecKeyboardNavContainer'
-                }]
-        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: Document, decorators: [{
-                    type: Inject,
-                    args: [DOCUMENT]
-                }] }, { type: i1.InteractivityChecker }]; }, propDecorators: { enabled: [{
-                type: Input,
-                args: ['ecKeyboardNavContainer']
-            }], focusOutStart: [{
-                type: Output
-            }], focusOutEnd: [{
-                type: Output
-            }] } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"keyboard-nav-container.directive.js","sourceRoot":"","sources":["../../../../../../../projects/components/src/lib/shared/directives/keyboard-nav-container/keyboard-nav-container.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { InteractivityChecker } from '@angular/cdk/a11y';\r\nimport { DOCUMENT } from '@angular/common';\r\nimport { AfterViewInit, Directive, ElementRef, EventEmitter, Inject, Input, OnChanges, OnDestroy, Output } from '@angular/core';\r\nimport { fromEvent, Subject } from 'rxjs';\r\nimport { takeUntil } from 'rxjs/operators';\r\n\r\n@Directive({\r\n  selector: '[ecKeyboardNavContainer]',\r\n  exportAs: 'ecKeyboardNavContainer'\r\n})\r\n/**\r\n * A basic helper directive to determine when focus leaves the host element.\r\n * \r\n * NOTE: This directive utilizes hidden anchor elements. These will disrupt tab order for elements\r\n * within a form. It is recommended to only use this directive when you need to redirect focus when\r\n * focus leaves a container. Also make sure this directive is disabled when the focus out events\r\n * are not needed to avoid keyboard nav problems. \r\n */\r\nexport class KeyboardNavContainerDirective implements OnChanges, AfterViewInit, OnDestroy {\r\n\r\n  @Input('ecKeyboardNavContainer') enabled: boolean = true;\r\n\r\n  @Output() focusOutStart = new EventEmitter();\r\n  @Output() focusOutEnd = new EventEmitter();\r\n\r\n  private startAnchor: HTMLElement;\r\n  private endAnchor: HTMLElement;\r\n\r\n  private destroyed = new Subject<void>();\r\n\r\n  constructor(\r\n    private hostEl: ElementRef<HTMLElement>,\r\n    @Inject(DOCUMENT) private _document: Document,\r\n    private interactivityChecker: InteractivityChecker,\r\n  ) {\r\n    // Create the start and end anchors.\r\n    this.startAnchor = this._document.createElement('div');\r\n    this.endAnchor = this._document.createElement('div');\r\n    // Hide the anchors from screen readers.\r\n    this.startAnchor.setAttribute('aria-hidden', 'true');\r\n    this.endAnchor.setAttribute('aria-hidden', 'true');\r\n  }\r\n\r\n  ngOnChanges(): void {\r\n    this.toggleAnchors(this.enabled);\r\n  }\r\n\r\n  ngAfterViewInit(): void {\r\n    // Insert the anchors into the DOM before and after the host element.\r\n    this.hostEl.nativeElement.parentNode?.insertBefore(this.startAnchor, this.hostEl.nativeElement);\r\n    this.hostEl.nativeElement.parentNode?.insertBefore(this.endAnchor, this.hostEl.nativeElement.nextSibling);\r\n\r\n    // Listen for focus events on the anchors.\r\n    fromEvent(this.startAnchor, 'focus').pipe(\r\n      takeUntil(this.destroyed)\r\n    ).subscribe(() => this.focusOutStart.emit());\r\n\r\n    fromEvent(this.endAnchor, 'focus').pipe(\r\n      takeUntil(this.destroyed)\r\n    ).subscribe(() => this.focusOutEnd.emit());\r\n\r\n    this.toggleAnchors(this.enabled);\r\n  }\r\n\r\n  ngOnDestroy(): void {\r\n    this.destroyed.next();\r\n    this.destroyed.complete();\r\n    // Cleanup the anchors\r\n    this.startAnchor.remove();\r\n    this.endAnchor.remove();\r\n  }\r\n\r\n  public focus() {\r\n    const firstFocusableElement = this.getFirstFocusableElement(this.hostEl.nativeElement);\r\n    firstFocusableElement?.focus();\r\n  }\r\n\r\n  private getFirstFocusableElement(element: HTMLElement): HTMLElement | null {\r\n    // These are only possibly focusable. Some may be disabled or not visible.\r\n    const elements = element.querySelectorAll<HTMLElement>('input, textarea, select, button, a, [tabindex], [contenteditable]');\r\n\r\n    // Use the Angular CDK interactivity checker to determine if an element is actually focusable and tabbable.\r\n    // This checks for disabledness among other things.\r\n    const first = Array.from(elements).find(el => {\r\n      return this.interactivityChecker.isFocusable(el) && this.interactivityChecker.isTabbable(el);\r\n    });\r\n\r\n    return first || null;\r\n  }\r\n\r\n  private toggleAnchors(enabled: boolean) {\r\n    // Make the anchors focusable if the container is enabled and we have subscribers for the events.\r\n    // Otherwise, remove the tabindexes so they cannot receive focus and disrupt the tab order.\r\n    if (enabled && this.focusOutStart.observers.length > 0) {\r\n      this.startAnchor.setAttribute('tabindex', '0');\r\n    } else {\r\n      this.startAnchor.removeAttribute('tabindex');\r\n    }\r\n\r\n    if (enabled && this.focusOutEnd.observers.length > 0) {\r\n      this.endAnchor.setAttribute('tabindex', '0');\r\n    } else {\r\n      this.endAnchor.removeAttribute('tabindex');\r\n    }\r\n  }\r\n}\r\n"]}
+import { DOCUMENT } from '@angular/common';
+import { Directive, EventEmitter, Inject, Input, Output } from '@angular/core';
+import { fromEvent, Subject } from 'rxjs';
+import { takeUntil } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/cdk/a11y";
+/**
+ * A basic helper directive to determine when focus leaves the host element.
+ *
+ * NOTE: This directive utilizes hidden anchor elements. These will disrupt tab order for elements
+ * within a form. It is recommended to only use this directive when you need to redirect focus when
+ * focus leaves a container. Also make sure this directive is disabled when the focus out events
+ * are not needed to avoid keyboard nav problems.
+ */
+export class KeyboardNavContainerDirective {
+    constructor(hostEl, _document, interactivityChecker) {
+        this.hostEl = hostEl;
+        this._document = _document;
+        this.interactivityChecker = interactivityChecker;
+        this.enabled = true;
+        this.focusOutStart = new EventEmitter();
+        this.focusOutEnd = new EventEmitter();
+        this.destroyed = new Subject();
+        // Create the start and end anchors.
+        this.startAnchor = this._document.createElement('div');
+        this.endAnchor = this._document.createElement('div');
+        // Hide the anchors from screen readers.
+        this.startAnchor.setAttribute('aria-hidden', 'true');
+        this.endAnchor.setAttribute('aria-hidden', 'true');
+    }
+    ngOnChanges() {
+        this.toggleAnchors(this.enabled);
+    }
+    ngAfterViewInit() {
+        // Insert the anchors into the DOM before and after the host element.
+        this.hostEl.nativeElement.parentNode?.insertBefore(this.startAnchor, this.hostEl.nativeElement);
+        this.hostEl.nativeElement.parentNode?.insertBefore(this.endAnchor, this.hostEl.nativeElement.nextSibling);
+        // Listen for focus events on the anchors.
+        fromEvent(this.startAnchor, 'focus').pipe(takeUntil(this.destroyed)).subscribe(() => this.focusOutStart.emit());
+        fromEvent(this.endAnchor, 'focus').pipe(takeUntil(this.destroyed)).subscribe(() => this.focusOutEnd.emit());
+        this.toggleAnchors(this.enabled);
+    }
+    ngOnDestroy() {
+        this.destroyed.next();
+        this.destroyed.complete();
+        // Cleanup the anchors
+        this.startAnchor.remove();
+        this.endAnchor.remove();
+    }
+    focus() {
+        const firstFocusableElement = this.getFirstFocusableElement(this.hostEl.nativeElement);
+        firstFocusableElement?.focus();
+    }
+    getFirstFocusableElement(element) {
+        // These are only possibly focusable. Some may be disabled or not visible.
+        const elements = element.querySelectorAll('input, textarea, select, button, a, [tabindex], [contenteditable]');
+        // Use the Angular CDK interactivity checker to determine if an element is actually focusable and tabbable.
+        // This checks for disabledness among other things.
+        const first = Array.from(elements).find(el => {
+            return this.interactivityChecker.isFocusable(el) && this.interactivityChecker.isTabbable(el);
+        });
+        return first || null;
+    }
+    toggleAnchors(enabled) {
+        // Make the anchors focusable if the container is enabled and we have subscribers for the events.
+        // Otherwise, remove the tabindexes so they cannot receive focus and disrupt the tab order.
+        if (enabled && this.focusOutStart.observers.length > 0) {
+            this.startAnchor.setAttribute('tabindex', '0');
+        }
+        else {
+            this.startAnchor.removeAttribute('tabindex');
+        }
+        if (enabled && this.focusOutEnd.observers.length > 0) {
+            this.endAnchor.setAttribute('tabindex', '0');
+        }
+        else {
+            this.endAnchor.removeAttribute('tabindex');
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: KeyboardNavContainerDirective, deps: [{ token: i0.ElementRef }, { token: DOCUMENT }, { token: i1.InteractivityChecker }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.3.12", type: KeyboardNavContainerDirective, selector: "[ecKeyboardNavContainer]", inputs: { enabled: ["ecKeyboardNavContainer", "enabled"] }, outputs: { focusOutStart: "focusOutStart", focusOutEnd: "focusOutEnd" }, exportAs: ["ecKeyboardNavContainer"], usesOnChanges: true, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: KeyboardNavContainerDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[ecKeyboardNavContainer]',
+                    exportAs: 'ecKeyboardNavContainer'
+                }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }, { type: Document, decorators: [{
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }, { type: i1.InteractivityChecker }], propDecorators: { enabled: [{
+                type: Input,
+                args: ['ecKeyboardNavContainer']
+            }], focusOutStart: [{
+                type: Output
+            }], focusOutEnd: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"keyboard-nav-container.directive.js","sourceRoot":"","sources":["../../../../../../../projects/components/src/lib/shared/directives/keyboard-nav-container/keyboard-nav-container.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { InteractivityChecker } from '@angular/cdk/a11y';\r\nimport { DOCUMENT } from '@angular/common';\r\nimport { AfterViewInit, Directive, ElementRef, EventEmitter, Inject, Input, OnChanges, OnDestroy, Output } from '@angular/core';\r\nimport { fromEvent, Subject } from 'rxjs';\r\nimport { takeUntil } from 'rxjs/operators';\r\n\r\n@Directive({\r\n  selector: '[ecKeyboardNavContainer]',\r\n  exportAs: 'ecKeyboardNavContainer'\r\n})\r\n/**\r\n * A basic helper directive to determine when focus leaves the host element.\r\n * \r\n * NOTE: This directive utilizes hidden anchor elements. These will disrupt tab order for elements\r\n * within a form. It is recommended to only use this directive when you need to redirect focus when\r\n * focus leaves a container. Also make sure this directive is disabled when the focus out events\r\n * are not needed to avoid keyboard nav problems. \r\n */\r\nexport class KeyboardNavContainerDirective implements OnChanges, AfterViewInit, OnDestroy {\r\n\r\n  @Input('ecKeyboardNavContainer') enabled: boolean = true;\r\n\r\n  @Output() focusOutStart = new EventEmitter();\r\n  @Output() focusOutEnd = new EventEmitter();\r\n\r\n  private startAnchor: HTMLElement;\r\n  private endAnchor: HTMLElement;\r\n\r\n  private destroyed = new Subject<void>();\r\n\r\n  constructor(\r\n    private hostEl: ElementRef<HTMLElement>,\r\n    @Inject(DOCUMENT) private _document: Document,\r\n    private interactivityChecker: InteractivityChecker,\r\n  ) {\r\n    // Create the start and end anchors.\r\n    this.startAnchor = this._document.createElement('div');\r\n    this.endAnchor = this._document.createElement('div');\r\n    // Hide the anchors from screen readers.\r\n    this.startAnchor.setAttribute('aria-hidden', 'true');\r\n    this.endAnchor.setAttribute('aria-hidden', 'true');\r\n  }\r\n\r\n  ngOnChanges(): void {\r\n    this.toggleAnchors(this.enabled);\r\n  }\r\n\r\n  ngAfterViewInit(): void {\r\n    // Insert the anchors into the DOM before and after the host element.\r\n    this.hostEl.nativeElement.parentNode?.insertBefore(this.startAnchor, this.hostEl.nativeElement);\r\n    this.hostEl.nativeElement.parentNode?.insertBefore(this.endAnchor, this.hostEl.nativeElement.nextSibling);\r\n\r\n    // Listen for focus events on the anchors.\r\n    fromEvent(this.startAnchor, 'focus').pipe(\r\n      takeUntil(this.destroyed)\r\n    ).subscribe(() => this.focusOutStart.emit());\r\n\r\n    fromEvent(this.endAnchor, 'focus').pipe(\r\n      takeUntil(this.destroyed)\r\n    ).subscribe(() => this.focusOutEnd.emit());\r\n\r\n    this.toggleAnchors(this.enabled);\r\n  }\r\n\r\n  ngOnDestroy(): void {\r\n    this.destroyed.next();\r\n    this.destroyed.complete();\r\n    // Cleanup the anchors\r\n    this.startAnchor.remove();\r\n    this.endAnchor.remove();\r\n  }\r\n\r\n  public focus() {\r\n    const firstFocusableElement = this.getFirstFocusableElement(this.hostEl.nativeElement);\r\n    firstFocusableElement?.focus();\r\n  }\r\n\r\n  private getFirstFocusableElement(element: HTMLElement): HTMLElement | null {\r\n    // These are only possibly focusable. Some may be disabled or not visible.\r\n    const elements = element.querySelectorAll<HTMLElement>('input, textarea, select, button, a, [tabindex], [contenteditable]');\r\n\r\n    // Use the Angular CDK interactivity checker to determine if an element is actually focusable and tabbable.\r\n    // This checks for disabledness among other things.\r\n    const first = Array.from(elements).find(el => {\r\n      return this.interactivityChecker.isFocusable(el) && this.interactivityChecker.isTabbable(el);\r\n    });\r\n\r\n    return first || null;\r\n  }\r\n\r\n  private toggleAnchors(enabled: boolean) {\r\n    // Make the anchors focusable if the container is enabled and we have subscribers for the events.\r\n    // Otherwise, remove the tabindexes so they cannot receive focus and disrupt the tab order.\r\n    if (enabled && this.focusOutStart.observers.length > 0) {\r\n      this.startAnchor.setAttribute('tabindex', '0');\r\n    } else {\r\n      this.startAnchor.removeAttribute('tabindex');\r\n    }\r\n\r\n    if (enabled && this.focusOutEnd.observers.length > 0) {\r\n      this.endAnchor.setAttribute('tabindex', '0');\r\n    } else {\r\n      this.endAnchor.removeAttribute('tabindex');\r\n    }\r\n  }\r\n}\r\n"]}

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

@@ -0,0 +1,166 @@
+import { DOCUMENT } from '@angular/common';
+import { Directive, EventEmitter, Inject, Input } from '@angular/core';
+import Popper from 'popper.js';
+import { fromEvent } from "rxjs";
+import * as i0 from "@angular/core";
+/**
+ * Primitive directive that popups a container using PopperJS
+ *
+ * @export
+ */
+export class PopupContainerDirective {
+    /**
+     *  Global reference to the currently displayed popup; only
+     *  one popup directive can be in `show` state at a given time.
+     *
+     * @memberof PopupContainerDirective
+     */
+    static { this.GlobalPopupRef = undefined; }
+    /**
+     * 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) {
+        // @ts-ignore
+        if (this.popperRef && this.popperRef['reference'] && this.popperRef['popper']) {
+            // @ts-ignore
+            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);
+                }
+            }
+            // @ts-ignore
+            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');
+            }
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: PopupContainerDirective, deps: [{ token: i0.TemplateRef }, { token: i0.ViewContainerRef }, { token: DOCUMENT }, { token: i0.Renderer2 }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.3.12", type: PopupContainerDirective, selector: "[ecPopup]", inputs: { popup: ["ecPopup", "popup"], popperOptions: ["options", "popperOptions"] }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: PopupContainerDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: '[ecPopup]' }]
+        }], ctorParameters: () => [{ 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 { DOCUMENT } from '@angular/common';\r\nimport { Directive, EmbeddedViewRef, EventEmitter, Inject, Input, OnDestroy, OnInit, Renderer2, TemplateRef, ViewContainerRef } from '@angular/core';\r\nimport Popper from 'popper.js';\r\nimport { fromEvent, Subscription } from \"rxjs\";\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        // @ts-ignore\r\n        if(this.popperRef && this.popperRef['reference'] && this.popperRef['popper']) {\r\n            // @ts-ignore\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            // @ts-ignore\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/esm2022/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;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: DateDisplayPipe, deps: [{ token: i1.UserPreferenceService }], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "17.3.12", ngImport: i0, type: DateDisplayPipe, name: "dateDisplay" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: DateDisplayPipe, decorators: [{
+            type: Pipe,
+            args: [{ name: 'dateDisplay' }]
+        }], ctorParameters: () => [{ type: i1.UserPreferenceService }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/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, '\\$&');
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: HighlightTextPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "17.3.12", ngImport: i0, type: HighlightTextPipe, name: "highlightText" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: HighlightTextPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'highlightText'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

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