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

package/esm2022/lib/display/dialog/dialog.component.mjs

@@ -0,0 +1,281 @@
+import { DOCUMENT } from '@angular/common';
+import { Component, EventEmitter, HostBinding, HostListener, Input, Output, ViewChild, ViewContainerRef, TemplateRef, Inject } from '@angular/core';
+import { timer, lastValueFrom } from 'rxjs';
+import { take, takeUntil, tap } from 'rxjs/operators';
+import { DialogOpenEndEvent, DialogCloseEvent, DialogResult } from './dialog-types';
+import * as i0 from "@angular/core";
+import * as i1 from "../../core/window.service";
+import * as i2 from "./dialog.service";
+import * as i3 from "@angular/cdk/a11y";
+/** These values need to be kept in sync with dialog-base.scss */
+export const DialogOpenDuration = 125;
+export const DialogCloseDuration = 100;
+export const PanelOpenDuration = 250;
+export const PanelCloseDuration = 225;
+export class DialogComponent {
+    onOverlayClick(event) {
+        if (event.target.tagName === 'EC-DIALOG' && this.displayAsPanel) {
+            this.close(new DialogResult(false));
+        }
+    }
+    /**
+     * Defines the width of the dialog (height is auto). Can be a number that will be converted to pixels, or xsmall(320px), small(480px), medium(640px), or large(1024px)
+     */
+    set size(value) {
+        this._size = value;
+        // If the size is a string, set the dialog class. Otherwise, clear it.
+        if (typeof value == 'string') {
+            this.dialogSizeClass = `dialog-${value}`;
+        }
+        else {
+            this.dialogSizeClass = undefined;
+        }
+    }
+    ;
+    get size() {
+        return this._size;
+    }
+    constructor(componentFactoryResolver, windowService, dialogService, documentRef) {
+        this.componentFactoryResolver = componentFactoryResolver;
+        this.windowService = windowService;
+        this.dialogService = dialogService;
+        this.documentRef = documentRef;
+        /**
+         * Add/remove the is-open css class to the host element when the dialog is opened/closed.
+         * Styles use the is-open class to show/hide the dialog.
+         */
+        this.isOpen = false;
+        /**
+         * Add the fade-in css class to the host element when the dialog is opening. Remove when transition is complete.
+         * Styles use the fade-in class to apply a fade-in transition while the dialog is opening.
+         */
+        this.fadeIn = false;
+        /**
+         * Add the fade-out css class to the host element when the dialog is closing. Remove when transition is complete.
+         * Styles use the fade-out class to apply a fade-out transition while the dialog is closing.
+         */
+        this.fadeOut = false;
+        this.displayAsPanel = false;
+        this.alignToTop = false;
+        this.transparentMask = false;
+        this.noMask = false;
+        /**
+         * Defines the width of the dialog (height is auto). Can be a number that will be converted to pixels, or xsmall(320px), small(480px), medium(640px), or large(1024px)
+         */
+        this._size = 'small';
+        /**
+         * Bound to the host. The classes set the --ec-dialog-width variable to our default 'small', 'medium', etc. sizes.
+         * Undefined when the size is a number, which is used for custom sizes.
+         */
+        this.dialogSizeClass = `dialog-${this._size}`;
+        /**
+         * Emits an event when the dialog is opened
+         */
+        this.opened = new EventEmitter();
+        /**
+         * Emits an event when the dialog is closed
+         */
+        this.closed = new EventEmitter();
+        this.previouslyFocusedElement = null;
+    }
+    ngOnInit() {
+        if (this.content) {
+            this.open(this.content, this.context, this.options);
+        }
+    }
+    ngOnDestroy() {
+        // Restore focus to the previously focused element when the dialog is destroyed.
+        // Need to do this here and not in close() because cdkTrapFocusAutoCapture's re-focus happens in ngOnDestroy.
+        // This doesn't work for dialog implementations outside of the dialog service because ngOnDestroy isn't called when
+        // the dialog is closed in those cases.
+        if (this.previouslyFocusedElement) {
+            this.previouslyFocusedElement.focus();
+        }
+    }
+    /**
+     * Clear and previously loaded content
+     * Load the component
+     * Save a reference of the loaded component
+     * Show the dialog and fade in
+     */
+    async open(component, context, options) {
+        if (!this.isOpen) {
+            // Capture the currently focused element, also looking in the shadow dom. Focus is restored to this element once the dialog is
+            // destroyed. See ngOnDestroy(). We need to do this here in addition to the cdkTrapFocusAutoCapture because sometimes the dialog's
+            // content is drawn and grabs focus before the cdkTrapFocusAutoCapture is able to read the previously focused element.
+            const activeElement = this.documentRef?.activeElement;
+            this.previouslyFocusedElement = activeElement?.shadowRoot?.activeElement || activeElement;
+            if (options) {
+                if (options.alignToTop) {
+                    this.alignToTop = true;
+                }
+                if (options.alignToTopMargin) {
+                    this.alignToTopMargin = options.alignToTopMargin;
+                }
+                ;
+                if (options.displayAsPanel) {
+                    this.displayAsPanel = true;
+                    this.transparentMask = true;
+                }
+                if (options.transparentMask !== undefined) {
+                    this.transparentMask = options.transparentMask;
+                }
+                if (options.noMask !== undefined) {
+                    this.noMask = options.noMask;
+                }
+                if (options.canOpenDialog !== undefined) {
+                    const canOpen = await options.canOpenDialog();
+                    if (!canOpen) {
+                        this.close(new DialogResult(false));
+                        return;
+                    }
+                }
+            }
+            // set the size before opening
+            if (typeof this.size === 'number') {
+                this.width = this.size;
+            }
+            else {
+                // Reset the width if the size is not a number. This is to prevent the width property conflicting with the size.
+                this.width = undefined;
+            }
+            this.minWidth = options?.minWidth;
+            this.fadeIn = true;
+            if (component instanceof TemplateRef) {
+                this.contentContainer.createEmbeddedView(component);
+            }
+            else {
+                let componentFactory = this.componentFactoryResolver.resolveComponentFactory(component);
+                this.componentRef = this.contentContainer.createComponent(componentFactory);
+            }
+            this.isOpen = true;
+            this.openDialogComponent(context);
+            // Once the animation is complete we can remove the animation class and
+            // emit the opened event, both to the hosting component and via DialogService
+            await lastValueFrom(timer(this.displayAsPanel ? PanelOpenDuration : DialogOpenDuration).pipe(take(1), tap(() => {
+                const dialogId = this.getDialogId();
+                this.fadeIn = false;
+                this.opened.emit(dialogId);
+                this.dialogService.triggerEvent(new DialogOpenEndEvent(this.dialogOpenStartEventId, dialogId));
+            })));
+            this.handleCloseOnResize();
+        }
+    }
+    /**
+     * Fade the dialog out and hide
+     */
+    close(result) {
+        this.fadeOut = true;
+        const dialogId = this.getDialogId(); //call before wiping out the content
+        // When the fade out animation is complete we will hide the dialog
+        // and remove the animation class as well as let the world know that
+        // we're closed so they can complete any other cleanup
+        setTimeout(() => {
+            this.isOpen = false;
+            this.fadeOut = false;
+            this.contentContainer?.clear();
+            this.componentRef = undefined;
+            this.closed.emit(result);
+            this.dialogService.triggerEvent(new DialogCloseEvent(this.dialogOpenStartEventId, dialogId, result?.save, result?.context));
+            this.resetOptions();
+        }, this.displayAsPanel ? PanelCloseDuration : DialogCloseDuration);
+    }
+    /**Open the dialog and attach handlers to the cancel and save events to close it and notify the hosting page */
+    openDialogComponent(context) {
+        if (this.componentRef && this.componentRef.instance) {
+            const dialogContent = this.componentRef.instance;
+            // OnOpen is optional - create dialogs don't necessarily define it
+            if (dialogContent.onOpen) {
+                dialogContent.onOpen(context);
+            }
+            dialogContent.onDialogCancel.pipe(takeUntil(this.closed)).subscribe(() => {
+                this.close(new DialogResult(false));
+            });
+            dialogContent.onDialogSave.pipe(takeUntil(this.closed)).subscribe(val => {
+                this.close(new DialogResult(true, val));
+            });
+        }
+    }
+    /**
+     * Reset options so they don't persist next time the
+     * root dialog is opened
+     * @deprecated
+     */
+    resetOptions() {
+        this.alignToTop = false;
+        this.displayAsPanel = false;
+    }
+    /** If they turned on closeOnResize, automatically close the dialog any time somebody resizes the window.
+      * This is useful for responsive layouts to prevent having the dialogContent on the screen twice */
+    handleCloseOnResize() {
+        if (this.options && this.options.closeOnResize) {
+            this.windowService.resized.pipe(takeUntil(this.closed), take(1)).subscribe(() => {
+                this.close(new DialogResult(false));
+            });
+        }
+    }
+    /**Extract the dialogId from the dialog content, if it has one. Template-based dialogs generally don't.
+     * We fall back to empty string to allow anybody listening for dialogEvents to still record the open/close even if
+     * the dialog itself does not say what the name is.
+     */
+    getDialogId() {
+        return this.componentRef?.instance.dialogId || '';
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: DialogComponent, deps: [{ token: i0.ComponentFactoryResolver }, { token: i1.WindowService }, { token: i2.DialogService }, { token: DOCUMENT }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: DialogComponent, selector: "ec-dialog", inputs: { size: "size", content: "content", context: "context", options: "options", dialogOpenStartEventId: "dialogOpenStartEventId" }, outputs: { opened: "opened", closed: "closed" }, host: { listeners: { "click": "onOverlayClick($event)" }, properties: { "class": "dialogSizeClass", "style.--ec-dialog-width.px": "width", "class.is-open": "this.isOpen", "class.fade-in": "this.fadeIn", "class.fade-out": "this.fadeOut", "class.is-panel": "this.displayAsPanel", "class.is-top-aligned": "this.alignToTop", "style.--ec-dialog-margin-align-to-top": "this.alignToTopMargin", "class.is-transparent": "this.transparentMask", "class.no-mask": "this.noMask" } }, viewQueries: [{ propertyName: "contentContainer", first: true, predicate: ["content"], descendants: true, read: ViewContainerRef, static: true }], ngImport: i0, template: '<article [style.min-width]="minWidth" cdkTrapFocus cdkTrapFocusAutoCapture><ng-template #content></ng-template></article>', isInline: true, styles: ["@keyframes fadeIn{0%{opacity:0}to{opacity:1}}@keyframes slideIn{0%{transform:translate(100%)}to{transform:translate(0)}}@keyframes panelMaskFadeIn{0%{background-color:transparent}to{background-color:var(--ec-dialog-background-color)}}:host{--ec-dialog-background-color: var(--ec-background-color-dialog);align-items:center;background-color:var(--ec-dialog-background-color);justify-content:center;position:fixed;z-index:var(--ec-z-index-dialog);inset:0;display:none}:host.is-open{display:flex}:host.fade-in{animation-name:fadeIn;animation-duration:125ms;animation-fill-mode:forwards;animation-timing-function:ease-in-out}:host.fade-out{animation-name:fadeIn;animation-duration:.1s;animation-direction:reverse;animation-fill-mode:forwards;animation-timing-function:ease-in-out}:host.is-panel article{position:absolute;top:0;bottom:0;right:0;max-height:none;border-right:0;border-top:0;border-bottom:0;border-radius:0;box-shadow:0 0 .5rem var(--ec-color-shadow)}:host.is-panel.fade-in{animation-name:panelMaskFadeIn;animation-duration:.25s;animation-fill-mode:forwards}:host.is-panel.fade-in article{animation-name:slideIn;animation-duration:.25s;animation-fill-mode:forwards;animation-timing-function:ease-out}:host.is-panel.fade-out{animation-name:panelMaskFadeIn;animation-direction:reverse;animation-fill-mode:forwards}:host.is-panel.fade-out article{animation-name:slideIn;animation-duration:225ms;animation-direction:reverse;animation-fill-mode:forwards;animation-timing-function:ease-in}:host.is-panel.no-mask{left:auto;width:var(--ec-dialog-width)}:host.is-top-aligned{align-items:flex-start}:host.is-top-aligned article{min-height:auto;margin-top:var(--ec-dialog-margin-align-to-top, 20vh);max-height:calc(100vh - var(--ec-dialog-margin-align-to-top, 20vh) - 5vh)}:host.is-transparent{--ec-dialog-background-color: transparent}article{background-color:var(--ec-background-color-body);background-clip:padding-box;box-shadow:0 0 .625rem #1a1a2333;border-radius:var(--ec-border-radius-dialog);overflow:hidden;display:flex;flex:none;min-height:9rem;max-height:90vh;max-width:90vw;width:var(--ec-dialog-width)}:host.dialog-xsmall{--ec-dialog-width: 20rem}:host.dialog-small{--ec-dialog-width: 30rem}:host.dialog-medium{--ec-dialog-width: 40rem}:host.dialog-large{--ec-dialog-width: 50rem}:host.dialog-xlarge{--ec-dialog-width: 60rem}:host.dialog-full{--ec-dialog-width: 90vw}\n"], dependencies: [{ kind: "directive", type: i3.CdkTrapFocus, selector: "[cdkTrapFocus]", inputs: ["cdkTrapFocus", "cdkTrapFocusAutoCapture"], exportAs: ["cdkTrapFocus"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: DialogComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'ec-dialog', template: '<article [style.min-width]="minWidth" cdkTrapFocus cdkTrapFocusAutoCapture><ng-template #content></ng-template></article>', host: {
+                        '[class]': 'dialogSizeClass',
+                        '[style.--ec-dialog-width.px]': 'width'
+                    }, styles: ["@keyframes fadeIn{0%{opacity:0}to{opacity:1}}@keyframes slideIn{0%{transform:translate(100%)}to{transform:translate(0)}}@keyframes panelMaskFadeIn{0%{background-color:transparent}to{background-color:var(--ec-dialog-background-color)}}:host{--ec-dialog-background-color: var(--ec-background-color-dialog);align-items:center;background-color:var(--ec-dialog-background-color);justify-content:center;position:fixed;z-index:var(--ec-z-index-dialog);inset:0;display:none}:host.is-open{display:flex}:host.fade-in{animation-name:fadeIn;animation-duration:125ms;animation-fill-mode:forwards;animation-timing-function:ease-in-out}:host.fade-out{animation-name:fadeIn;animation-duration:.1s;animation-direction:reverse;animation-fill-mode:forwards;animation-timing-function:ease-in-out}:host.is-panel article{position:absolute;top:0;bottom:0;right:0;max-height:none;border-right:0;border-top:0;border-bottom:0;border-radius:0;box-shadow:0 0 .5rem var(--ec-color-shadow)}:host.is-panel.fade-in{animation-name:panelMaskFadeIn;animation-duration:.25s;animation-fill-mode:forwards}:host.is-panel.fade-in article{animation-name:slideIn;animation-duration:.25s;animation-fill-mode:forwards;animation-timing-function:ease-out}:host.is-panel.fade-out{animation-name:panelMaskFadeIn;animation-direction:reverse;animation-fill-mode:forwards}:host.is-panel.fade-out article{animation-name:slideIn;animation-duration:225ms;animation-direction:reverse;animation-fill-mode:forwards;animation-timing-function:ease-in}:host.is-panel.no-mask{left:auto;width:var(--ec-dialog-width)}:host.is-top-aligned{align-items:flex-start}:host.is-top-aligned article{min-height:auto;margin-top:var(--ec-dialog-margin-align-to-top, 20vh);max-height:calc(100vh - var(--ec-dialog-margin-align-to-top, 20vh) - 5vh)}:host.is-transparent{--ec-dialog-background-color: transparent}article{background-color:var(--ec-background-color-body);background-clip:padding-box;box-shadow:0 0 .625rem #1a1a2333;border-radius:var(--ec-border-radius-dialog);overflow:hidden;display:flex;flex:none;min-height:9rem;max-height:90vh;max-width:90vw;width:var(--ec-dialog-width)}:host.dialog-xsmall{--ec-dialog-width: 20rem}:host.dialog-small{--ec-dialog-width: 30rem}:host.dialog-medium{--ec-dialog-width: 40rem}:host.dialog-large{--ec-dialog-width: 50rem}:host.dialog-xlarge{--ec-dialog-width: 60rem}:host.dialog-full{--ec-dialog-width: 90vw}\n"] }]
+        }], ctorParameters: () => [{ type: i0.ComponentFactoryResolver }, { type: i1.WindowService }, { type: i2.DialogService }, { type: Document, decorators: [{
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }], propDecorators: { isOpen: [{
+                type: HostBinding,
+                args: ['class.is-open']
+            }], fadeIn: [{
+                type: HostBinding,
+                args: ['class.fade-in']
+            }], fadeOut: [{
+                type: HostBinding,
+                args: ['class.fade-out']
+            }], displayAsPanel: [{
+                type: HostBinding,
+                args: ['class.is-panel']
+            }], alignToTop: [{
+                type: HostBinding,
+                args: ['class.is-top-aligned']
+            }], alignToTopMargin: [{
+                type: HostBinding,
+                args: ['style.--ec-dialog-margin-align-to-top']
+            }], transparentMask: [{
+                type: HostBinding,
+                args: ['class.is-transparent']
+            }], noMask: [{
+                type: HostBinding,
+                args: ['class.no-mask']
+            }], onOverlayClick: [{
+                type: HostListener,
+                args: ['click', ['$event']]
+            }], size: [{
+                type: Input
+            }], content: [{
+                type: Input
+            }], context: [{
+                type: Input
+            }], options: [{
+                type: Input
+            }], dialogOpenStartEventId: [{
+                type: Input
+            }], opened: [{
+                type: Output
+            }], closed: [{
+                type: Output
+            }], contentContainer: [{
+                type: ViewChild,
+                args: ['content', { read: ViewContainerRef, static: true }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dialog.component.js","sourceRoot":"","sources":["../../../../../../projects/components/src/lib/display/dialog/dialog.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { DOCUMENT } from '@angular/common';\r\nimport { Component, ComponentFactoryResolver, ComponentRef, EventEmitter, HostBinding, HostListener, Input, Output, Type, ViewChild, ViewContainerRef, TemplateRef, Inject } from '@angular/core';\r\nimport { timer, lastValueFrom } from 'rxjs';\r\nimport { take, takeUntil, tap } from 'rxjs/operators';\r\nimport { WindowService } from '../../core/window.service';\r\nimport { DialogContent } from './dialog-content';\r\nimport { DialogOpenEndEvent, DialogCloseEvent, DialogSize, DialogOptions, DialogResult } from './dialog-types';\r\nimport { DialogService } from './dialog.service';\r\n\r\n/** These values need to be kept in sync with dialog-base.scss */\r\nexport const DialogOpenDuration: number = 125;\r\nexport const DialogCloseDuration: number = 100;\r\nexport const PanelOpenDuration: number = 250;\r\nexport const PanelCloseDuration: number = 225;\r\n\r\n@Component({\r\n  selector: 'ec-dialog',\r\n  template: '<article [style.min-width]=\"minWidth\" cdkTrapFocus cdkTrapFocusAutoCapture><ng-template #content></ng-template></article>',\r\n  styleUrls: ['./dialog.component.scss'],\r\n  host: {\r\n    '[class]': 'dialogSizeClass',\r\n    '[style.--ec-dialog-width.px]': 'width'\r\n  }\r\n})\r\nexport class DialogComponent {\r\n  /**\r\n   * Add/remove the is-open css class to the host element when the dialog is opened/closed.\r\n   * Styles use the is-open class to show/hide the dialog.\r\n   */\r\n  @HostBinding('class.is-open') public isOpen = false;\r\n\r\n  /**\r\n   * Add the fade-in css class to the host element when the dialog is opening. Remove when transition is complete.\r\n   * Styles use the fade-in class to apply a fade-in transition while the dialog is opening.\r\n   */\r\n  @HostBinding('class.fade-in') public fadeIn = false;\r\n\r\n  /**\r\n   * Add the fade-out css class to the host element when the dialog is closing. Remove when transition is complete.\r\n   * Styles use the fade-out class to apply a fade-out transition while the dialog is closing.\r\n   */\r\n  @HostBinding('class.fade-out') public fadeOut = false;\r\n\r\n  @HostBinding('class.is-panel') public displayAsPanel = false;\r\n\r\n  @HostBinding('class.is-top-aligned') public alignToTop = false;\r\n\r\n  @HostBinding('style.--ec-dialog-margin-align-to-top') public alignToTopMargin?: string;\r\n\r\n  @HostBinding('class.is-transparent') public transparentMask = false;\r\n\r\n  @HostBinding('class.no-mask') public noMask = false;\r\n\r\n  @HostListener('click', ['$event']) public onOverlayClick(event: MouseEvent) {\r\n    if ((<HTMLElement>event.target).tagName === 'EC-DIALOG' && this.displayAsPanel) {\r\n      this.close(new DialogResult(false));\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Defines the width of the dialog (height is auto). Can be a number that will be converted to pixels, or xsmall(320px), small(480px), medium(640px), or large(1024px)\r\n   */\r\n  @Input() public set size(value: DialogSize) {\r\n    this._size = value;\r\n    // If the size is a string, set the dialog class. Otherwise, clear it.\r\n    if (typeof value == 'string') {\r\n      this.dialogSizeClass = `dialog-${value}`;\r\n    } else {\r\n      this.dialogSizeClass = undefined;\r\n    }\r\n  };\r\n  public get size(): DialogSize {\r\n    return this._size;\r\n  }\r\n  /**\r\n   * Defines the width of the dialog (height is auto). Can be a number that will be converted to pixels, or xsmall(320px), small(480px), medium(640px), or large(1024px)\r\n   */\r\n  private _size: DialogSize = 'small';\r\n\r\n  /**\r\n   * Bound to the host. The classes set the --ec-dialog-width variable to our default 'small', 'medium', etc. sizes.\r\n   * Undefined when the size is a number, which is used for custom sizes.\r\n   */\r\n  dialogSizeClass?: string = `dialog-${this._size}`;\r\n\r\n  @Input() content?: Type<DialogContent<any>> | TemplateRef<any>;\r\n  @Input() context?: any;\r\n  @Input() options?: DialogOptions;\r\n\r\n  /**Only set if this particular instance of a dialog should be identified separately from others.\r\n   * If provided, this is emitted to the dialog service with OpenEnd and Close events. Direct usage\r\n   * of the DialogComponent from outside a DialogGroup does not usually require using this parameter as\r\n   * the dialog reference itself functions as the identifier\r\n   */\r\n  @Input() dialogOpenStartEventId?: string;\r\n\r\n  /**\r\n   * Emits an event when the dialog is opened\r\n   */\r\n  @Output() public opened: EventEmitter<string> = new EventEmitter();\r\n\r\n  /**\r\n   * Emits an event when the dialog is closed\r\n   */\r\n  @Output() public closed: EventEmitter<DialogResult<any>> = new EventEmitter();\r\n\r\n  /**\r\n   * The container where the component will be loaded\r\n   */\r\n  @ViewChild('content', { read: ViewContainerRef, static: true }) public contentContainer!: ViewContainerRef;\r\n\r\n  /**\r\n   * Custom width of the dialog in pixels. Set by defining the size property\r\n   * as a number value.\r\n   */\r\n  public width?: number;\r\n\r\n  /**\r\n   * Custom min-width of the dialog. Only takes effect if size is set to dynamic.\r\n   * Must include units, i.e. \"32rem\" or \"640px\"\r\n   */\r\n  public minWidth?: string;\r\n\r\n  /**\r\n   * A reference of the component once it has been loaded\r\n   */\r\n  public componentRef?: ComponentRef<any>;\r\n\r\n  private previouslyFocusedElement: HTMLElement | null = null;\r\n\r\n  constructor(\r\n    private componentFactoryResolver: ComponentFactoryResolver,\r\n    private windowService: WindowService,\r\n    private dialogService: DialogService,\r\n    @Inject(DOCUMENT) private documentRef: Document\r\n  ) { }\r\n\r\n  ngOnInit(): void {\r\n    if (this.content) {\r\n      this.open(this.content, this.context, this.options);\r\n    }\r\n  }\r\n\r\n  ngOnDestroy() {\r\n    // Restore focus to the previously focused element when the dialog is destroyed.\r\n    // Need to do this here and not in close() because cdkTrapFocusAutoCapture's re-focus happens in ngOnDestroy.\r\n    // This doesn't work for dialog implementations outside of the dialog service because ngOnDestroy isn't called when\r\n    // the dialog is closed in those cases.\r\n    if (this.previouslyFocusedElement) {\r\n      this.previouslyFocusedElement.focus();\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Clear and previously loaded content\r\n   * Load the component\r\n   * Save a reference of the loaded component\r\n   * Show the dialog and fade in\r\n   */\r\n  public async open<T>(component: Type<DialogContent<T>> | TemplateRef<any>, context?: T, options?: DialogOptions): Promise<void> {\r\n    if (!this.isOpen) {\r\n      \r\n      // Capture the currently focused element, also looking in the shadow dom. Focus is restored to this element once the dialog is\r\n      // destroyed. See ngOnDestroy(). We need to do this here in addition to the cdkTrapFocusAutoCapture because sometimes the dialog's\r\n      // content is drawn and grabs focus before the cdkTrapFocusAutoCapture is able to read the previously focused element.\r\n      const activeElement = <HTMLElement | null>this.documentRef?.activeElement;\r\n      this.previouslyFocusedElement = <HTMLElement>activeElement?.shadowRoot?.activeElement || activeElement;\r\n\r\n      if (options) {\r\n        if (options.alignToTop) {\r\n          this.alignToTop = true;\r\n        }\r\n\r\n        if (options.alignToTopMargin) {\r\n          this.alignToTopMargin = options.alignToTopMargin;\r\n        };\r\n\r\n        if (options.displayAsPanel) {\r\n          this.displayAsPanel = true;\r\n          this.transparentMask = true;\r\n        }\r\n\r\n        if (options.transparentMask !== undefined) {\r\n          this.transparentMask = options.transparentMask;\r\n        }\r\n\r\n        if (options.noMask !== undefined) {\r\n          this.noMask = options.noMask;\r\n        }\r\n\r\n        if (options.canOpenDialog !== undefined) {\r\n          const canOpen = await options.canOpenDialog();\r\n          if (!canOpen) {\r\n            this.close(new DialogResult(false));\r\n            return;\r\n          }\r\n        }\r\n      }\r\n\r\n      // set the size before opening\r\n      if (typeof this.size === 'number') {\r\n        this.width = this.size;\r\n      } else {\r\n        // Reset the width if the size is not a number. This is to prevent the width property conflicting with the size.\r\n        this.width = undefined;\r\n      }\r\n\r\n      this.minWidth = options?.minWidth;\r\n\r\n      this.fadeIn = true;\r\n      if (component instanceof TemplateRef) {\r\n        this.contentContainer.createEmbeddedView(component);\r\n      } else {\r\n        let componentFactory = this.componentFactoryResolver.resolveComponentFactory(component);\r\n        this.componentRef = this.contentContainer.createComponent(componentFactory);\r\n      }\r\n\r\n      this.isOpen = true;\r\n\r\n      this.openDialogComponent<T>(context);\r\n\r\n      // Once the animation is complete we can remove the animation class and\r\n      // emit the opened event, both to the hosting component and via DialogService\r\n      await lastValueFrom(timer(this.displayAsPanel ? PanelOpenDuration : DialogOpenDuration).pipe(take(1), tap(() => {\r\n    const dialogId = this.getDialogId();\r\n    this.fadeIn = false;\r\n    this.opened.emit(dialogId);\r\n    this.dialogService.triggerEvent(new DialogOpenEndEvent(this.dialogOpenStartEventId, dialogId));\r\n})));\r\n\r\n      this.handleCloseOnResize();\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Fade the dialog out and hide\r\n   */\r\n  public close<T>(result?: DialogResult<T>): void {\r\n    this.fadeOut = true;\r\n    const dialogId = this.getDialogId();  //call before wiping out the content\r\n\r\n    // When the fade out animation is complete we will hide the dialog\r\n    // and remove the animation class as well as let the world know that\r\n    // we're closed so they can complete any other cleanup\r\n    setTimeout(() => {\r\n      this.isOpen = false;\r\n      this.fadeOut = false;\r\n      this.contentContainer?.clear();\r\n      this.componentRef = undefined;\r\n      this.closed.emit(result);\r\n      this.dialogService.triggerEvent(new DialogCloseEvent(this.dialogOpenStartEventId, dialogId, result?.save, result?.context));\r\n      this.resetOptions();\r\n    }, this.displayAsPanel ? PanelCloseDuration : DialogCloseDuration)\r\n  }\r\n\r\n  /**Open the dialog and attach handlers to the cancel and save events to close it and notify the hosting page */\r\n  private openDialogComponent<T>(context?: T) {\r\n    if (this.componentRef && this.componentRef.instance) {\r\n      const dialogContent = this.componentRef.instance as DialogContent<T>;\r\n\r\n      // OnOpen is optional - create dialogs don't necessarily define it\r\n      if (dialogContent.onOpen) {\r\n        dialogContent.onOpen(context);\r\n      }\r\n\r\n      dialogContent.onDialogCancel.pipe(takeUntil(this.closed)).subscribe(() => {\r\n        this.close<T>(new DialogResult<T>(false));\r\n      });\r\n\r\n      dialogContent.onDialogSave.pipe(takeUntil(this.closed)).subscribe(val => {\r\n        this.close<T>(new DialogResult<T>(true, val));\r\n      });\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Reset options so they don't persist next time the\r\n   * root dialog is opened\r\n   * @deprecated\r\n   */\r\n  private resetOptions() {\r\n    this.alignToTop = false;\r\n    this.displayAsPanel = false;\r\n  }\r\n\r\n  /** If they turned on closeOnResize, automatically close the dialog any time somebody resizes the window.\r\n    * This is useful for responsive layouts to prevent having the dialogContent on the screen twice */\r\n  private handleCloseOnResize() {\r\n    if(this.options && this.options.closeOnResize){\r\n      this.windowService.resized!.pipe(takeUntil(this.closed), take(1)).subscribe(() => {\r\n        this.close(new DialogResult(false));\r\n      });\r\n    }\r\n  }\r\n\r\n  /**Extract the dialogId from the dialog content, if it has one. Template-based dialogs generally don't.\r\n   * We fall back to empty string to allow anybody listening for dialogEvents to still record the open/close even if\r\n   * the dialog itself does not say what the name is. \r\n   */\r\n  private getDialogId() {\r\n    return this.componentRef?.instance.dialogId || '';\r\n  }\r\n}\r\n"]}

package/esm2022/lib/display/dialog/dialog.service.mjs

@@ -0,0 +1,71 @@
+import { Injectable } from '@angular/core';
+import { Subject } from 'rxjs';
+import { map, skipWhile, take } from 'rxjs/operators';
+import { ConfirmComponent } from '../confirm/confirm.component';
+import { DialogCloseEvent, DialogCloseLatestEvent, DialogOpenStartEvent } from './dialog-types';
+import * as i0 from "@angular/core";
+/**
+ * Service used to communcate with ng5 dialogs from an ng1 view. Any dialogs that
+ * have been added to ng1 views must be added to the DialogCatalog in order
+ * to know which component to load inside the dialog. You can also optionally subscribe
+ * to an onClose event to do some work after the dialog closes
+ */
+export class DialogService {
+    constructor() {
+        /**
+         * Emits DialogEvents when the dialog opens or closes.
+         */
+        this.events = new Subject();
+    }
+    /**
+     * Open the root dialog.
+     * @param content - The component class to load into the dialog
+     * @param size - The size of the dialog
+     * @param context - optional context to pass to the dialog content during initialization.
+     * @param options - extra options to configure the dialog
+     * @returns Observable of a typed DialogResult which specifies if the dialog was saved and an optional context.
+     * @example
+        // From typescript
+        try {
+          const result = await lastValueFrom(this.dialogService.openDialog(MyComponent, 'small', myContext, options));
+          // do something with result
+        } catch(error) {
+          // do something with error
+        }
+     */
+    openDialog(content, size, context, options) {
+        options = options || {};
+        options.size = size;
+        const event = new DialogOpenStartEvent(content, context, options);
+        const complete = this.events.pipe(skipWhile(e => !(e instanceof DialogCloseEvent) || e.eventId !== event.eventId), map(e => e.dialogResult), take(1) //mark the observable as complete as soon as any closeEvent happens for this particular dialogOpen event, allowing lastValueFrom to work
+        );
+        this.triggerEvent(event);
+        return complete;
+    }
+    /**Close whatever dialog was most recently opened, with the provided result.
+     * The result must be in a form the caller can expect (must match the dialog) so use this carefully
+     * if you are returning any result other than cancel. It is most useful if you are opening
+     * a dialog with a template reference instead of a true dialog child component
+     */
+    closeLatestDialog(result) {
+        this.triggerEvent(new DialogCloseLatestEvent(result));
+    }
+    /**
+     * Open a Confirmation Dialog with the given context
+     */
+    confirm(context) {
+        return this.openDialog(ConfirmComponent, 'small', context);
+    }
+    triggerEvent(event) {
+        this.events.next(event);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: DialogService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: DialogService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: DialogService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/display/help/help-types.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaGVscC10eXBlcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2NvbXBvbmVudHMvc3JjL2xpYi9kaXNwbGF5L2hlbHAvaGVscC10eXBlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IHR5cGUgSGVscCA9IHtcclxuICBjb250cm9sczogSGVscENvbnRyb2xbXSxcclxuICBvdmVydmlldz86IHN0cmluZyxcclxuICBhbHdheXNWaXNpYmxlPzogYm9vbGVhbixcclxuICBpZ25vcmVVc2VyU2V0dGluZz86IGJvb2xlYW5cclxufTtcclxuXHJcbi8qKlxyXG4gKiBBIGZvcm0gY29udHJvbCBpbiB0aGUgY3VycmVudCB2aWV3IHRvIGRlZmluZSBpbiB0aGUgaGVscCBwYW5lbFxyXG4gKi9cclxuIGV4cG9ydCB0eXBlIEhlbHBDb250cm9sID0ge1xyXG4gIC8qKlxyXG4gICAqIFRoZSBjb250cm9scyBpZFxyXG4gICAqIEB0eXBlIHtzdHJpbmd9XHJcbiAgICovXHJcbiAgaWQ6IHN0cmluZyxcclxuXHJcbiAgLyoqXHJcbiAgICogVGhlIGZvcm0gY29udHJvbCBpZHMgdG8gbWF0Y2ggdGhpcyBoZWxwIGNvbnRyb2xcclxuICAgKiBJZiB0aGlzIGFycmF5IGlzIGRlZmluZWQgdGhlIGlkJ3Mgd2l0aGluIHRoaXMgd2lsbCB0YWtlIHByZWNpZGVuY2Ugb3ZlciB0aGVcclxuICAgKiBpZCBvZiB0aGUgaGVscCBjb250cm9sIHdoZW4gdHJ5aW5nIHRvIG1hdGNoIHVwIGEgY29udHJvbFxyXG4gICAqIEB0eXBlIHtzdHJpbmdbXX1cclxuICAgKi9cclxuICBpZEdyb3VwPzogQXJyYXk8c3RyaW5nPixcclxuXHJcbiAgLyoqXHJcbiAgICogVGhlIG5hbWUgb2YgdGhlIGNvbnRyb2xcclxuICAgKiBAdHlwZSB7c3RyaW5nfVxyXG4gICAqL1xyXG4gIGxhYmVsOiBzdHJpbmcsXHJcblxyXG4gIC8qKlxyXG4gICAqIFRoZSBkZWZpbml0aW9uIGZvciB0aGUgY29udHJvbFxyXG4gICAqIEB0eXBlIHtzdHJpbmd9XHJcbiAgICovXHJcbiAgZGVmaW5pdGlvbjogc3RyaW5nXHJcbn07XHJcbiJdfQ==

package/esm2022/lib/display/hierarchy/hierarchy-base.mjs

@@ -0,0 +1,111 @@
+import { Directive, EventEmitter, Input, Output } from '@angular/core';
+import { Subject } from 'rxjs';
+import { TelemetryService } from '../../core/telemetry.service';
+import * as i0 from "@angular/core";
+export class HierarchyItem {
+    constructor() {
+        this.id = '';
+        /** Label to display for the item */
+        this.label = '';
+        /** Indicates how many levels deep the item is in the parent structure */
+        this.level = 0;
+        /** Display item as a link, a heading, or with a divider line below it */
+        this.display = 'default';
+        /** Set to hide toggle, even if item has children */
+        this.hideToggle = false;
+        /** Flag to indicate whether the item has children or not, mostly drives
+         *  whether you get the expand/collapse button
+         */
+        this.hasChildren = false;
+        /** Array of children if any for the item */
+        this.children = [];
+        /** Flag to indicate if the item has been expanded */
+        this.expanded = false;
+        /** Flag to indicate if the item is selected */
+        this.selected = false;
+        /** Flag to indicate if the item can be selected */
+        this.selectable = false;
+        this.readonly = false;
+        /** Status of each item to indicate whether children lookup is pending or
+         *  if an error occurred retrieving data
+         */
+        this.status = "hasData";
+        /** Indicates if the item is a top level entity, e.g. Organization or Cost Center */
+        this.topLevel = false;
+        /**
+         * When checking the url for activeness, the url must match exactly or partially
+         * @see https://angular.io/guide/router#active-router-links
+         */
+        this.isActiveExactMatch = true;
+    }
+}
+export class HierarchyBase {
+    get destroyed() {
+        return this._destroyed;
+    }
+    constructor(injector) {
+        /** Event emitter to request children for a given item */
+        this.getItemChildren = new EventEmitter();
+        /** Event emitted when an item is toggled. */
+        this.itemToggled = new EventEmitter();
+        /**
+        * Used to unsubscribe from observables
+        */
+        this._destroyed = new Subject();
+        this.telemetryService = injector.get(TelemetryService);
+    }
+    ngOnChanges(changes) {
+        if (changes && changes.rootNode && changes.rootNode.currentValue) {
+            /** If the rootNode has children and we don't know about them yet we must be loading
+            *  the view without the new hierarchy api
+            */
+            if (this.rootNode.hasChildren && this.rootNode.children.length === 0) {
+                this.getItemChildren.emit(this.rootNode);
+            }
+        }
+    }
+    /**
+    * Function called when the component is destroyed
+    */
+    ngOnDestroy() {
+        this.destroyed.next();
+        this.destroyed.unsubscribe();
+    }
+    /** Handler for the toggle button */
+    toggleItemClicked(item, expanded) {
+        item.expanded = expanded;
+        this.telemetryService.trackEvent('toggle-tree-node', {
+            newExpandState: item.expanded ? 'expanded' : 'collapsed',
+            itemDepth: `${item.level}`,
+        });
+        this.itemToggled.emit({ item, expanded });
+        if (item.expanded && item.hasChildren && item.children.length === 0) {
+            item.status = "pending";
+            this.getItemChildren.emit(item);
+        }
+    }
+    /** Method exposed to the parent component to set the items children once they are available
+     */
+    setItemChildren(parentItem, items) {
+        parentItem.children = items;
+        parentItem.status = "hasData";
+    }
+    /** Method exposed to the parent component to indicate that something happened on the
+     *  item that caused an error, could be retrieving children
+    */
+    setItemError(parentItem) {
+        parentItem.status = "error";
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: HierarchyBase, deps: [{ token: i0.Injector }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.3.12", type: HierarchyBase, inputs: { rootNode: "rootNode" }, outputs: { getItemChildren: "getItemChildren", itemToggled: "itemToggled" }, usesOnChanges: true, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: HierarchyBase, decorators: [{
+            type: Directive
+        }], ctorParameters: () => [{ type: i0.Injector }], propDecorators: { rootNode: [{
+                type: Input
+            }], getItemChildren: [{
+                type: Output
+            }], itemToggled: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"hierarchy-base.js","sourceRoot":"","sources":["../../../../../../projects/components/src/lib/display/hierarchy/hierarchy-base.ts"],"names":[],"mappings":"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","sourcesContent":["import { Directive, EventEmitter, Injector, Input, OnChanges, OnDestroy, Output, SimpleChanges } from '@angular/core';\r\nimport { Params, QueryParamsHandling } from '@angular/router';\r\nimport { Subject } from 'rxjs';\r\nimport { LinkItem } from '../../controls/navigation/link-item';\r\nimport { TelemetryService } from '../../core/telemetry.service';\r\nimport { ViewStatus } from '../../shared/display';\r\n\r\nexport class HierarchyItem implements LinkItem {\r\n  id: string = '';\r\n\r\n  /** Label to display for the item */\r\n  label: string = '';\r\n\r\n  /** Text to be displayed in the item's tooltip. When not provided, the label will be displayed. */\r\n  tooltip?: string;\r\n\r\n  /** Text to be displayed in the item's icon tooltip. */\r\n  iconTooltip?: string;\r\n\r\n  /** Indicates how many levels deep the item is in the parent structure */\r\n  level: number = 0;\r\n\r\n  url?: string;\r\n\r\n  queryParams?: Params | null;\r\n\r\n  queryParamsHandling?: QueryParamsHandling;\r\n\r\n  icon?: string;\r\n\r\n  /** Display item as a link, a heading, or with a divider line below it */\r\n  display?: 'default' | 'heading' | 'divider' = 'default';\r\n\r\n  /** Set to hide toggle, even if item has children */\r\n  hideToggle?: boolean = false;\r\n\r\n  /** Flag to indicate whether the item has children or not, mostly drives\r\n   *  whether you get the expand/collapse button\r\n   */\r\n  hasChildren: boolean = false;\r\n\r\n  /** Array of children if any for the item */\r\n  children: Array<HierarchyItem> = [];\r\n\r\n  /** Flag to indicate if the item has been expanded */\r\n  expanded?: boolean = false;\r\n\r\n  /** Flag to indicate if the item is selected */\r\n  selected?: boolean = false;\r\n\r\n  /** Flag to indicate if the item can be selected */\r\n  selectable?: boolean = false;\r\n\r\n  readonly?: boolean = false;\r\n\r\n  /** Status of each item to indicate whether children lookup is pending or\r\n   *  if an error occurred retrieving data\r\n   */\r\n  status?: ViewStatus = \"hasData\";\r\n\r\n  /** Indicates if the item is a top level entity, e.g. Organization or Cost Center */\r\n  topLevel?: boolean = false;\r\n\r\n  /**\r\n   * When checking the url for activeness, the url must match exactly or partially\r\n   * @see https://angular.io/guide/router#active-router-links\r\n   */\r\n  isActiveExactMatch?: boolean = true;\r\n\r\n  /**\r\n   * Reference to the parent item. Useful if you need to walk the tree in reverse. An example usage\r\n   * would be to expand all parent items above a node that is the current selection.\r\n   */\r\n  parentItem?: HierarchyItem;\r\n\r\n  /**\r\n   * Set to have no level indentation for the item. Useful for top level items in a tree that is not hierarchical\r\n   */\r\n  noIndent?: boolean | undefined;\r\n}\r\n\r\n/**\r\n * Represents a HierarchyItem that has been clicked to toggle its expansion state.\r\n */\r\nexport type ToggledHierarchyItem = {\r\n  item: HierarchyItem;\r\n  expanded: boolean;\r\n};\r\n\r\n@Directive()\r\nexport abstract class HierarchyBase implements OnChanges, OnDestroy {\r\n\r\n  /** First item to start the hierarchy structure */\r\n  @Input() public rootNode!: HierarchyItem;\r\n\r\n  /** Event emitter to request children for a given item */\r\n  @Output() public getItemChildren: EventEmitter<HierarchyItem> = new EventEmitter<HierarchyItem>();\r\n\r\n  /** Event emitted when an item is toggled. */\r\n  @Output() public itemToggled: EventEmitter<ToggledHierarchyItem> = new EventEmitter<ToggledHierarchyItem>();\r\n\r\n  /**\r\n  * Used to unsubscribe from observables\r\n  */\r\n  private _destroyed: Subject<void> = new Subject<void>();\r\n  public get destroyed(): Subject<void> {\r\n    return this._destroyed;\r\n  }\r\n\r\n  protected telemetryService: TelemetryService;\r\n\r\n  constructor(injector: Injector) {\r\n    this.telemetryService = injector.get(TelemetryService);\r\n  }\r\n\r\n  public ngOnChanges(changes: SimpleChanges): void {\r\n    if (changes && changes.rootNode && changes.rootNode.currentValue) {\r\n      /** If the rootNode has children and we don't know about them yet we must be loading\r\n      *  the view without the new hierarchy api\r\n      */\r\n      if (this.rootNode.hasChildren && this.rootNode.children.length === 0) {\r\n        this.getItemChildren.emit(this.rootNode);\r\n      }\r\n    }\r\n  }\r\n\r\n  /**\r\n  * Function called when the component is destroyed\r\n  */\r\n  public ngOnDestroy(): void {\r\n    this.destroyed.next();\r\n    this.destroyed.unsubscribe();\r\n  }\r\n\r\n  /** Handler for the toggle button */\r\n  public toggleItemClicked(item: HierarchyItem, expanded: boolean) {\r\n    item.expanded = expanded;\r\n    this.telemetryService.trackEvent('toggle-tree-node', {\r\n      newExpandState: item.expanded ? 'expanded' : 'collapsed',\r\n      itemDepth: `${item.level}`,\r\n    });\r\n\r\n    this.itemToggled.emit({ item, expanded });\r\n\r\n    if (item.expanded && item.hasChildren && item.children.length === 0) {\r\n      item.status = \"pending\";\r\n      this.getItemChildren.emit(item);\r\n    }\r\n  }\r\n\r\n  /** Method exposed to the parent component to set the items children once they are available\r\n   */\r\n  public setItemChildren(parentItem: HierarchyItem, items: Array<HierarchyItem>): void {\r\n    parentItem.children = items;\r\n    parentItem.status = \"hasData\";\r\n  }\r\n\r\n  /** Method exposed to the parent component to indicate that something happened on the\r\n   *  item that caused an error, could be retrieving children\r\n  */\r\n  public setItemError(parentItem: HierarchyItem): void {\r\n    parentItem.status = \"error\";\r\n  }\r\n}\r\n"]}

package/esm2022/lib/display/hierarchy/hierarchy-mocks.spec.mjs

@@ -0,0 +1,54 @@
+export var HierarchyMocks;
+(function (HierarchyMocks) {
+    HierarchyMocks.mockRoot = () => ({
+        id: "1",
+        level: 0,
+        hasChildren: true,
+        children: [],
+        label: ''
+    });
+    HierarchyMocks.bldgWithChildren = () => {
+        return {
+            placeId: 3, parentId: 0, placeTypeId: 2, placeCode: 'HASCHILDREN_BLDG', placeInfo: 'A Cool Bldg Has Children',
+            hasChildren: true, placeChildren: [], meterChildren: [], hasActiveChildren: true
+        };
+    };
+    HierarchyMocks.bldgWithChildrenHierarchyItem = () => ({
+        id: HierarchyMocks.bldgWithChildren().placeId.toString(), icon: 'icon-building', label: `${HierarchyMocks.bldgWithChildren().placeInfo} [${HierarchyMocks.bldgWithChildren().placeCode}]`,
+        children: [], hasChildren: true, level: 1, selectable: true, topLevel: false
+    });
+    HierarchyMocks.orgWithChildren = () => {
+        return {
+            placeId: 1, parentId: 0, placeTypeId: 1, placeCode: 'HASCHILDREN_ORG', placeInfo: 'A Org Has Children',
+            hasChildren: true, placeChildren: [], meterChildren: [], hasActiveChildren: true
+        };
+    };
+    HierarchyMocks.orgWithChildrenHierarchyItem = () => ({
+        id: HierarchyMocks.orgWithChildren().placeId.toString(), icon: 'icon-organization', label: `${HierarchyMocks.orgWithChildren().placeInfo} [${HierarchyMocks.orgWithChildren().placeCode}]`,
+        children: [], hasChildren: true, level: 1, selectable: true, topLevel: true
+    });
+    HierarchyMocks.orgWithoutChildren = () => {
+        return {
+            placeId: 2, parentId: 0, placeTypeId: 1, placeCode: 'NOCHILDREN_ORG', placeInfo: 'No Children Org',
+            hasChildren: false, placeChildren: [], meterChildren: [], hasActiveChildren: false
+        };
+    };
+    HierarchyMocks.orgWithoutChildrenHierarchyItem = () => ({
+        id: HierarchyMocks.orgWithoutChildren().placeId.toString(), icon: 'icon-organization', label: `${HierarchyMocks.orgWithoutChildren().placeInfo} [${HierarchyMocks.orgWithoutChildren().placeCode}]`,
+        children: [], hasChildren: false, level: 1, selectable: true, topLevel: true
+    });
+    HierarchyMocks.bldgWithoutChildren = () => {
+        return {
+            placeId: 4, parentId: 0, placeTypeId: 2, placeCode: 'NOCHILDREN_BLDG', placeInfo: 'Zzz No Children Bldg',
+            hasChildren: false, placeChildren: [], meterChildren: [], hasActiveChildren: false
+        };
+    };
+    HierarchyMocks.bldgWithoutChildrenHierarchyItem = () => ({
+        id: HierarchyMocks.bldgWithoutChildren().placeId.toString(), icon: 'icon-building', label: `${HierarchyMocks.bldgWithoutChildren().placeInfo} [${HierarchyMocks.bldgWithoutChildren().placeCode}]`,
+        children: [], hasChildren: false, level: 1, selectable: true, topLevel: false
+    });
+    HierarchyMocks.sortedHierarchyPlaces = () => [
+        HierarchyMocks.bldgWithChildrenHierarchyItem(), HierarchyMocks.orgWithChildrenHierarchyItem(), HierarchyMocks.orgWithoutChildrenHierarchyItem(), HierarchyMocks.bldgWithoutChildrenHierarchyItem()
+    ];
+})(HierarchyMocks || (HierarchyMocks = {}));
+//# sourceMappingURL=data:application/json;base64,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