@energycap/components 0.42.4-esbuild.20250131-1219 → 0.42.4-esbuild.20250131-1441

package/lib/display/tour/tour-types.d.ts

@@ -0,0 +1,70 @@
+import { TemplateRef, Type } from "@angular/core";
+import { DialogContent } from "../dialog/dialog-content";
+import { DialogOptions, DialogSize } from "../dialog/dialog-types";
+import { TooltipPosition } from "../tooltip/tooltip.component";
+export type TourCacheEntry = {
+    completed: boolean;
+};
+export declare class Tour<T = any> {
+    /** Unique identifier for the tour */
+    id: string;
+    /** List of tour steps to present to the user */
+    steps: TourStep[];
+    /** Final step to be presented to the user if defined */
+    exitStep?: TourStep;
+    /** Dialog to present to the user before the tour begins */
+    introDialog?: TourIntroDialog<T>;
+}
+export interface TourIntroDialog<T> {
+    content?: Type<DialogContent<T>> | TemplateRef<any>;
+    context?: T;
+    options?: DialogOptions;
+    size?: DialogSize;
+}
+export declare class TourStep {
+    /** Unique identifier for the tour step */
+    id: string;
+    /** Optional tour step title displayed at top of tooltip */
+    title?: string;
+    /** Optional media to display below title and above tour text. Can be a jpg, png, or gif */
+    media?: string;
+    /** HTML formatted text that contains the primary content of the tour step */
+    text: string;
+    /** The element to attach the tour step to. If undefined, step will appear centered on screen */
+    anchor?: TourAnchor;
+    helpLink?: string;
+    /** Allows the step to have a fixed width defined for the tooltip. If not defined the width will be defaulted to 400. If you would like
+     *  auto width define as 'auto'.
+     */
+    width?: number | 'auto';
+    /** Allows the step to have a max width defined for the tooltip */
+    maxWidth?: number;
+}
+export declare class TourAnchor {
+    /**
+     * Optional css selector of an element to click in order to open a menu or
+     * overlay. Should not cause a navigation. If defined but does not exist in
+     * the DOM, skip this step because it is probably hidden to the user because of permissions
+     */
+    clickBefore?: string;
+    /**
+     * CSS selector of element to click in order to close a menu or overlay
+     * before continuing to the next step. Ignored if clickBefore is undefined.
+     * Should not cause a navigation
+     */
+    clickAfter?: string;
+    /**
+     * Selector to attach the tooltip to. If defined but does not exist in the
+     * DOM skip this step because it is probably hidden to the user because of
+     * permissions.
+     */
+    selector: string;
+    /** Position of the tooltip relative to the anchor. https://energycap-components.netlify.app/tooltip#position */
+    position?: TooltipPosition;
+}
+export declare class TourEvent {
+    tours: Tour[];
+    tourAction: 'start' | 'end' | 'append';
+    isAutoStart: boolean;
+    constructor(tours: Tour[], tourAction?: 'start' | 'end' | 'append', isAutoStart?: boolean);
+}

package/lib/display/tour/tour.component.d.ts

@@ -0,0 +1,147 @@
+import { OnInit, TemplateRef } from '@angular/core';
+import { TranslateService } from '@ngx-translate/core';
+import { CacheService } from '../../core/cache.service';
+import { TelemetryService } from '../../core/telemetry.service';
+import { DialogService } from '../dialog/dialog.service';
+import { TooltipComponent } from './../tooltip/tooltip.component';
+import { TooltipService } from './../tooltip/tooltip.service';
+import { TourStep } from './tour-types';
+import { TourService } from './tour.service';
+import * as i0 from "@angular/core";
+export declare class TourComponent implements OnInit {
+    private tourService;
+    private tooltipService;
+    private telemetryService;
+    private cacheService;
+    private dialogService;
+    private translateService;
+    private document;
+    /** Current tour step being shown to the user. The custom content in the template is bound to properties on this and therefor needs to be
+    *  its own property. The exitStep is a tour step and this will hold that step at the end of the tour.
+    */
+    currentTourStep?: TourStep;
+    /** Used to tell the UI that the step being shown is an exit step. This will change the
+     *  link text and the action when clicked
+     */
+    showDoneButton: boolean;
+    /** Reference to the tooltip used for the tour steps */
+    tooltip?: TooltipComponent;
+    /** Array of tours provided when the start tour event was detected */
+    private tours;
+    private currentStepIndex;
+    private currentTourIndex;
+    /** Used to know if the restore step should be triggered when the tour is dismissed */
+    private isAutoStart;
+    private destroyed;
+    custom: TemplateRef<any>;
+    constructor(tourService: TourService, tooltipService: TooltipService, telemetryService: TelemetryService, cacheService: CacheService, dialogService: DialogService, translateService: TranslateService, document: Document);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    /**
+     * Called when a restore step has been completed
+     */
+    done(): Promise<void>;
+    /**
+     * Called when a tour begins and when the user clicks next on the current tour step. It will handle any after click actions and then
+     * find the next step and present it to the user and transition to a restore step or new tour if needed.
+     */
+    showNextStep(): Promise<void>;
+    private setupTourComponent;
+    /**
+     * Shows a tour and emits an event that it was started
+     * @param tour
+     */
+    private showNextTour;
+    private endTour;
+    /**
+     * Displays a tooltip for the current tour step
+     */
+    private showStepTooltip;
+    /**
+     * Subscribes to the tooltips onHide event emitter and reacts if the user dismisses the tooltip
+     */
+    private subscribeToTooltipOnHide;
+    /**
+     * Loops through the current tour steps starting after the current step index. It will try to find a visible
+     * selector and if so return the index.
+     * @returns
+     */
+    private getNextAvailableStepIndex;
+    /**
+     * Try to find the tour step element to know if it is visible for the user. Check for the clickBefore first if defined
+     * @param anchor
+     * @returns
+     */
+    private stepElementFound;
+    /**
+     * Some tour steps may have a click after defined. If so call the click method on the html element
+     */
+    private handleClickAfter;
+    /**
+     * Some tour steps may have a click before defined. If so call the click method on the html element
+     */
+    private handleClickBefore;
+    /**
+    * Checks for an exit step on the current tour and if found displays the step
+    */
+    private handleExitStep;
+    /**
+     * Try to find the element with the selector provided and if so click it. This is how tour steps will open/close menus to
+     * give a tour to the user
+     * @param selector
+     */
+    private clickElementIfFound;
+    /**
+     * When auto starting tours we will want to remove any that have the local storage key written as completed so
+     * they are not presented to the user again.
+     * @param tours
+     * @returns
+     */
+    private removeCompletedTours;
+    /**
+     * Writes a key to local storage so the tour will not be shown again automatically
+     */
+    private writeCompletionKey;
+    /**
+     * When dismissing a tour or one being dismissed via a navigation event, etc we will want to mark
+     * every tour in the array as completed so it doesn't resurface unless the user requests the tour.
+     * This function will loop over all and write the local storage key
+     */
+    private writeCompletionKeyForAllTours;
+    /**
+     * Cache key used to set/get the completion status of a tour
+     * @param tour
+     * @returns
+     */
+    private makeCacheKey;
+    /**
+     * Removes a tooltip from the view, used when switching tour steps and closing a tour
+     */
+    private removeTooltip;
+    /**
+     * Returns the tour based on the current index
+     */
+    private get currentTour();
+    /**
+     * The click before/after and show tooltip functions need to be wrapped in setTimeout for the UI
+     * to operate correctly but setTimeout is an action we cannot await so we're wrapping it in a promise to return
+     * so the function calls can await the action
+     * @param fn
+     * @returns
+     */
+    private waitForTimeout;
+    /**
+     * Find the "next" or "done" button and focus on it.
+     *
+     * They are mutually exclusive, so if we cannot find the next button
+     * we look for the done button.
+     */
+    private focusOnNextOrDoneButton;
+    /**
+     * Find an element with given selector and focus on it.
+     * Return false if element not found.
+     */
+    private focusOnElement;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TourComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TourComponent, "ec-tour", never, {}, {}, never, never, false, never>;
+}

package/lib/display/tour/tour.service.d.ts

@@ -0,0 +1,38 @@
+import { Observable } from 'rxjs';
+import { CacheService } from '../../core/cache.service';
+import { Tour, TourEvent } from './tour-types';
+import * as i0 from "@angular/core";
+export declare class TourService {
+    private cacheService;
+    events: Observable<TourEvent>;
+    constructor(cacheService: CacheService);
+    /**
+     * Start a tour of the application. Allows one or many tours to be sent in, each will
+     * follow the next. If multiple tours have exit steps defined only the final tour will
+     * execute the exit step.
+     * @param tours
+     */
+    start(tours: Tour[], isAutoStart?: boolean): void;
+    end(): void;
+    append(tours: Tour[], isAutoStart?: boolean): void;
+    /**
+     * Returns a formatted cache key for tours
+     * @param tour
+     * @returns
+     */
+    getCacheKey(tour: Tour): string;
+    /**
+     * Given a tour, check to see if it's been completed
+     * @param tour
+     * @returns
+     */
+    hasTourBeenViewed(tour: Tour): boolean;
+    /**
+     * Given a list of tours, check to see if any will show to the user
+     * @param tours
+     * @returns
+     */
+    haveAllToursBeenViewed(tours: Tour[]): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TourService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TourService>;
+}

package/lib/display/tree/tree.component.d.ts

@@ -0,0 +1,75 @@
+import { EventEmitter, TemplateRef } from '@angular/core';
+import { MenuComponent, MenuItem, MenuTemplateType } from '../../controls/menu/menu.component';
+import { ToggledHierarchyItem, HierarchyItem } from '../hierarchy/hierarchy-base';
+import { HierarchyTreeComponent } from '../hierarchy/hierarchy-tree/hierarchy-tree.component';
+import { Overlay } from '../view-overlay/view-overlay.component';
+import * as i0 from "@angular/core";
+export type TreeType = 'hierarchy' | 'menu';
+export declare class TreeComponent {
+    /** The value of the host elements id attribute */
+    attrId: string;
+    /**
+     * The ID of the component, bound to the host element's id attribute and passed
+     * to child components
+     */
+    set id(value: string);
+    get id(): string;
+    private _id;
+    /** The tree's title displayed in the header */
+    treeTitle: string;
+    /** Hides the tree header when set to true */
+    hideTreeHeader?: boolean;
+    /** Items to display in the tree when type is 'menu' */
+    treeItems?: MenuItem[];
+    /** Hide the root tree item when type is 'hierarchy' */
+    treeHierarchyHideRootNode?: boolean;
+    /** Items to display in the tree when type is 'hierarchy' */
+    treeHierarchy?: HierarchyItem;
+    /** Used when the tree is in menu mode to tell the menu if it should maintain the selected item
+     *  Useful in side nav components where this tree component may exist alongside other trees or menus
+     *  used for navigation. If this tree is in menu mode you would want this set to false so when you select an item
+     *  from a sibling navigation element the selection will not be maintained.
+     */
+    treeMenuMaintainSelectedItem: boolean;
+    /** Used when a custom template is needed for the menu items when the tree is in menu mode */
+    customTreeMenuTemplate?: TemplateRef<any>;
+    /** Used when a custom template is needed for the hierarchy items when the tree is in hierarchy mode */
+    customHierarchyItemTemplate?: TemplateRef<any>;
+    /** Tree overlay */
+    status?: Overlay;
+    /** Display the tree items with a MenuComponent or a HierarchyTreeComponent */
+    type?: TreeType;
+    /** Items to display in the dropdown menu */
+    menuItems?: MenuItem[];
+    /** Tree dropdown menu overlay */
+    menuStatus?: Overlay;
+    /** The menu item template */
+    menuTemplateType?: MenuTemplateType;
+    /**
+     * When true, the space for the icon is preserved for menu items that do not have icons.
+     * Only applicable for iconAndLabel menus. Not applicable to hierarchy trees.
+     */
+    preserveIconSpace: boolean;
+    /** Emits the item currently selected item in the tree */
+    treeSelection: EventEmitter<MenuItem | HierarchyItem>;
+    /** Emits when a hierarchy tree item is expanded as a hook to load the item's children */
+    getTreeItemChildren: EventEmitter<HierarchyItem>;
+    /** Emits when a hierarchy tree item is expanded or collapsed */
+    treeItemToggled: EventEmitter<ToggledHierarchyItem>;
+    /** Reference to the MenuComponent instance in the template */
+    menuComponent?: MenuComponent;
+    /** Reference to the HierarchyTreeComponent instance in the template */
+    hierarchyTreeComponent?: HierarchyTreeComponent;
+    templateType: MenuTemplateType;
+    constructor();
+    /** Emits when a tree item is selected */
+    onItemSelected(item: MenuItem | HierarchyItem): void;
+    /** Emits when a hierarchy tree item is expanded to load the item's children */
+    onHierarchyGetItemChildren(item: HierarchyItem): void;
+    /** Emits when a hierarchy tree item is expanded or collapsed */
+    onHierarchyItemToggled(item: ToggledHierarchyItem): void;
+    /** Scroll to the tree item that is currently selected. */
+    scrollToSelectedItem(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TreeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TreeComponent, "ec-tree", never, { "id": { "alias": "id"; "required": false; }; "treeTitle": { "alias": "treeTitle"; "required": false; }; "hideTreeHeader": { "alias": "hideTreeHeader"; "required": false; }; "treeItems": { "alias": "treeItems"; "required": false; }; "treeHierarchyHideRootNode": { "alias": "treeHierarchyHideRootNode"; "required": false; }; "treeHierarchy": { "alias": "treeHierarchy"; "required": false; }; "treeMenuMaintainSelectedItem": { "alias": "treeMenuMaintainSelectedItem"; "required": false; }; "customTreeMenuTemplate": { "alias": "customTreeMenuTemplate"; "required": false; }; "customHierarchyItemTemplate": { "alias": "customHierarchyItemTemplate"; "required": false; }; "status": { "alias": "status"; "required": false; }; "type": { "alias": "type"; "required": false; }; "menuItems": { "alias": "menuItems"; "required": false; }; "menuStatus": { "alias": "menuStatus"; "required": false; }; "menuTemplateType": { "alias": "menuTemplateType"; "required": false; }; "preserveIconSpace": { "alias": "preserveIconSpace"; "required": false; }; "templateType": { "alias": "templateType"; "required": false; }; }, { "treeSelection": "treeSelection"; "getTreeItemChildren": "getTreeItemChildren"; "treeItemToggled": "treeItemToggled"; }, never, never, false, never>;
+}

package/lib/display/view-overlay/view-overlay.component.d.ts

@@ -0,0 +1,38 @@
+import { TemplateRef } from '@angular/core';
+import { NavItem } from '../../controls/navigation/nav-item';
+import { DisplayStatus, ViewStatus } from '../../shared/display';
+import * as i0 from "@angular/core";
+export declare class Overlay implements DisplayStatus {
+    /**  @deprecated Deprecated due to noDataTemplate being prefered */
+    action?: NavItem;
+    noDataTemplate?: TemplateRef<any>;
+    displayAsMask?: boolean;
+    status: ViewStatus;
+    message?: string;
+    /** Addition css classes to apply to the .overlay element */
+    overlayClassList?: string;
+    constructor(status: ViewStatus, message?: string);
+    setStatus(status: ViewStatus, message?: string, action?: NavItem, noDataTemplate?: TemplateRef<any>, overlayClassList?: string): void;
+}
+/**
+ * Wraps content in order to show pending, error, and no data states with an optional message/noDataTemplate
+ */
+export declare class ViewOverlayComponent implements Overlay {
+    status: ViewStatus;
+    message?: string | undefined;
+    /**  @deprecated Deprecated due to noDataTemplate being prefered */
+    action?: NavItem | undefined;
+    noDataTemplate?: TemplateRef<any>;
+    /**
+     * Mask (not remove) the transcluded content from the dom while not hasData status.
+     */
+    displayAsMask?: boolean;
+    /**
+     * Additional css classes to apply to the .overlay element
+     */
+    overlayClassList?: string;
+    setStatus(status: ViewStatus, message?: string, action?: NavItem, noDataTemplate?: TemplateRef<any>): void;
+    actionClicked(event: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ViewOverlayComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ViewOverlayComponent, "[ecOverlay]", never, { "status": { "alias": "status"; "required": false; }; "message": { "alias": "message"; "required": false; }; "action": { "alias": "action"; "required": false; }; "noDataTemplate": { "alias": "noDataTemplate"; "required": false; }; "displayAsMask": { "alias": "displayAsMask"; "required": false; }; "overlayClassList": { "alias": "overlayClassList"; "required": false; }; }, {}, never, ["*"], false, never>;
+}

package/lib/shared/directives/click-area-for/click-area-for.directive.d.ts

@@ -0,0 +1,14 @@
+import { OnInit } from '@angular/core';
+import * as i0 from "@angular/core";
+export interface ClickableElement {
+    dispatchEvent(event: Event): void;
+}
+export declare class ClickAreaForDirective implements OnInit {
+    targetEl?: any;
+    private isTargetClickable;
+    constructor();
+    ngOnInit(): void;
+    onClick(event: Event): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClickAreaForDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ClickAreaForDirective, "[ecClickAreaFor]", never, { "targetEl": { "alias": "ecClickAreaFor"; "required": false; }; }, {}, never, never, false, never>;
+}

package/lib/shared/directives/if-viewport-width/if-viewport-width.directive.d.ts

@@ -0,0 +1,60 @@
+import { OnInit, ViewContainerRef, TemplateRef } from '@angular/core';
+import { WindowService } from '../../../core/window.service';
+import * as i0 from "@angular/core";
+/**
+ * Conditionally include content in the DOM based on the width of the viewport. Use to programmatically implement reponsive layouts and prevent duplicate markup and listeners.
+ * In most scenarios CSS media queries is sufficient to hide/show elements responsively. However, in some cases media queries would result in duplicate markup and listeners
+ * that could cause undesired side effects and it is preferred to us programmatic elements to achieve the layout.
+ */
+export declare class IfViewportWidthDirective implements OnInit {
+    private viewContainer;
+    private templateRef;
+    private windowService;
+    /**
+     * The min and, optionally, max width in pixels that the viewport must be in order to include the directive and its content in the DOM.
+     * A single number can be used to set the min width, but an object with min and max must be used to set a min and max width or just a max width.
+     *
+     * ```html
+     * <div *ecIfViewportWidth="500">Content to render if viewport width is >= 500px</div>
+     * <div *ecIfViewportWidth="{max: 800}">Content to render if the viewport width is <= 800px</div>
+     * <div *ecIfViewportWidth="{min: 500, max: 800}">Content to render if the viewport width is between 500px and 800px</div>
+     * ```
+     */
+    width: number | {
+        min?: number;
+        max?: number;
+    };
+    /**
+     * If defined, the width in pixels that the viewport must be to include the directive and its content in the DOM
+     */
+    private minWidth?;
+    /**
+     * If defined, the width in pixels that the viewport cannot be greater than to include the directive and its conten in the DOM
+     */
+    private maxWidth?;
+    /**
+     * Used to unsubscribe when the directive is removed from the DOM
+     */
+    private destroyed;
+    /**
+     * Internally tracks whether the directive and its content is included in the DOM
+     */
+    private isVisible;
+    constructor(viewContainer: ViewContainerRef, templateRef: TemplateRef<any>, windowService: WindowService);
+    ngOnInit(): void;
+    /**
+     * Get the current viewport width and determin if the directive's content should be
+     * included in the DOM based on the min and max width settings
+     */
+    private updateVisibility;
+    /**
+     * Add the directive's content to the DOM
+     */
+    private show;
+    /**
+     * Remove the directive's content from the DOM
+     */
+    private hide;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IfViewportWidthDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<IfViewportWidthDirective, "[ecIfViewportWidth]", never, { "width": { "alias": "ecIfViewportWidth"; "required": false; }; }, {}, never, never, false, never>;
+}

package/lib/shared/directives/keyboard-nav-container/keyboard-nav-container.directive.d.ts

@@ -0,0 +1,23 @@
+import { InteractivityChecker } from '@angular/cdk/a11y';
+import { AfterViewInit, ElementRef, EventEmitter, OnChanges, OnDestroy } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class KeyboardNavContainerDirective implements OnChanges, AfterViewInit, OnDestroy {
+    private hostEl;
+    private _document;
+    private interactivityChecker;
+    enabled: boolean;
+    focusOutStart: EventEmitter<any>;
+    focusOutEnd: EventEmitter<any>;
+    private startAnchor;
+    private endAnchor;
+    private destroyed;
+    constructor(hostEl: ElementRef<HTMLElement>, _document: Document, interactivityChecker: InteractivityChecker);
+    ngOnChanges(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    focus(): void;
+    private getFirstFocusableElement;
+    private toggleAnchors;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KeyboardNavContainerDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<KeyboardNavContainerDirective, "[ecKeyboardNavContainer]", ["ecKeyboardNavContainer"], { "enabled": { "alias": "ecKeyboardNavContainer"; "required": false; }; }, { "focusOutStart": "focusOutStart"; "focusOutEnd": "focusOutEnd"; }, never, never, false, never>;
+}

package/lib/shared/directives/popup/popup-container.directive.d.ts

@@ -0,0 +1,101 @@
+import { EventEmitter, OnDestroy, OnInit, Renderer2, TemplateRef, ViewContainerRef } from '@angular/core';
+import Popper from 'popper.js';
+import * as i0 from "@angular/core";
+export type PopupPlacement = 'top' | 'right' | 'bottom' | 'left' | 'top-start' | 'top-end' | 'bottom-start' | 'bottom-end';
+export type PopupStatus = 'visible' | 'hidden';
+/**
+ * Primitive directive that popups a container using PopperJS
+ *
+ * @export
+ */
+export declare class PopupContainerDirective implements OnInit, OnDestroy, OnInit {
+    private templateRef;
+    private viewContainer;
+    private document;
+    private renderer;
+    /**
+     *  Global reference to the currently displayed popup; only
+     *  one popup directive can be in `show` state at a given time.
+     *
+     * @memberof PopupContainerDirective
+     */
+    static GlobalPopupRef?: PopupContainerDirective;
+    /**
+     * TemplateRef of container to popup
+     *
+     */
+    popup: TemplateRef<any>;
+    /**
+     * Popper options
+     *
+     * @memberof PopupContainerDirective
+     */
+    popperOptions?: Popper.PopperOptions;
+    /**
+     * Template View Reference
+     *
+     * @memberof PopupContainerDirective
+     */
+    private templateViewRef;
+    /**
+     * Popup View Reference (container)
+     *
+     * @memberof PopupContainerDirective
+     */
+    private popupViewRef?;
+    /**
+     * Popper Reference
+     *
+     * @memberof PopupContainerDirective
+     */
+    private popperRef?;
+    /**
+     * Close-to-click Subscription. This allows us to close the menu when you click on the body.
+     * We attach it when the menu is open and detach it on close, to limit the lifetime of the click handler
+     * which helps with performance on a page with many popup containers
+     *
+     * @memberof PopupContainerDirective
+     */
+    private globalCloseSubscription?;
+    /**
+     * 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: TemplateRef<any>, viewContainer: ViewContainerRef, document: any, renderer: Renderer2);
+    /**
+     * Angular onInit lifecycle hook
+     * @see https://angular.io/guide/lifecycle-hooks
+     */
+    ngOnInit(): void;
+    /**
+     * Angular onDestroy lifecycle hook. Close and delete references. Unsubscribe observables
+     * @see https://angular.io/guide/lifecycle-hooks
+     */
+    ngOnDestroy(): void;
+    /**
+     * Emit the {@link PopupStatus} when it changes
+     */
+    popperStatusChange: EventEmitter<PopupStatus>;
+    /**
+     * Displays the templateRef as a popup
+     *
+     * @memberof PopupContainerDirective
+     */
+    show(): void;
+    /**
+     * Hides the templateRef
+     *
+     * @memberof PopupContainerDirective
+     */
+    hide(): void;
+    /**
+     * Updates the popup container position
+     */
+    update(): void;
+    fixPosition(minWidthNone?: boolean, appendToBody?: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PopupContainerDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<PopupContainerDirective, "[ecPopup]", never, { "popup": { "alias": "ecPopup"; "required": false; }; "popperOptions": { "alias": "options"; "required": false; }; }, {}, never, never, false, never>;
+}

package/lib/shared/display/pipes/date-display.pipe.d.ts

@@ -0,0 +1,21 @@
+import { PipeTransform } from '@angular/core';
+import { UserPreferenceService } from '../../user-preference.service';
+import moment from 'moment';
+import * as i0 from "@angular/core";
+export type DateDisplay = Date | moment.Moment | string | null;
+/**
+ * Format a date to the user's preference for display
+ */
+export declare class DateDisplayPipe implements PipeTransform {
+    private userPreferenceService;
+    constructor(userPreferenceService: UserPreferenceService);
+    private lastFormatString;
+    /**
+     * 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?: DateDisplay, showEndOfTime?: boolean, showTime?: boolean, showSeconds?: boolean): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DateDisplayPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<DateDisplayPipe, "dateDisplay", false>;
+}

package/lib/shared/display/pipes/highlight-text.pipe.d.ts

@@ -0,0 +1,9 @@
+import { PipeTransform } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class HighlightTextPipe implements PipeTransform {
+    transform(value: string, searchText: string): string;
+    private strongWrap;
+    private escapeRegex;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HighlightTextPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<HighlightTextPipe, "highlightText", false>;
+}

package/lib/shared/display/pipes/relative-date.pipe.d.ts

@@ -0,0 +1,36 @@
+import { PipeTransform } from '@angular/core';
+import { TranslateService } from '@ngx-translate/core';
+import { DateDisplayPipe } from './date-display.pipe';
+import { TimeDisplayPipe } from './time-display.pipe';
+import * as i0 from "@angular/core";
+export type RelativeDateOptions = {
+    dateOnly?: boolean;
+    showTimeForToday?: boolean;
+    todayLabel?: string;
+    yesterdayLabel?: string;
+    /** Prefix for when showing today as time for the value */
+    todayTimePrefix?: string;
+    /** Prefix for when displaying "today" as the value */
+    todayPrefix?: string;
+    /** Prefix for when displaying "yesterday" as the value */
+    yesterdayPrefix?: string;
+    /** Default prefix. Will be applied to all display options if defined and others are not */
+    defaultPrefix?: string;
+};
+export declare class RelativeDatePipe implements PipeTransform {
+    private dateDisplayPipe;
+    private timeDisplayPipe;
+    private translateService;
+    constructor(dateDisplayPipe: DateDisplayPipe, timeDisplayPipe: TimeDisplayPipe, 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: string, options?: RelativeDateOptions): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RelativeDatePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<RelativeDatePipe, "relativeDate", false>;
+}