@seniorsistemas/angular-components 17.27.1-fix-interactive-content-22e06381 → 17.27.1-fixlookupteste-sds-110-c424f879

package/esm2022/tiered-menu/lib/tiered-menu/components/tiered-menu/tiered-menu.component.mjs

@@ -0,0 +1,303 @@
+import { Component, EventEmitter, HostListener, Output, } from '@angular/core';
+import { Subject } from 'rxjs';
+import { takeUntil } from 'rxjs/operators';
+import { disableScroll, enableScroll } from '@seniorsistemas/angular-components/utils';
+import * as i0 from "@angular/core";
+import * as i1 from "../../services/tiered-menu.service";
+import * as i2 from "../../services/tiered-menu.event.service";
+import * as i3 from "@angular/common";
+import * as i4 from "../tiered-menu-item/tiered-menu-item.component";
+import * as i5 from "../tiered-menu-divider/tiered-menu-divider.component";
+export class TieredMenuComponent {
+    _appRef;
+    _componentFactoryResolver;
+    _injector;
+    _changeDetectorRef;
+    tieredMenuService;
+    _tieredMenuEventService;
+    items = [];
+    top = 0;
+    left = 0;
+    menuTriggerEvent = 'hover';
+    _componentRef = null;
+    _menuDivElement = null;
+    _unsubscribe$ = new Subject();
+    destroyRequest = new EventEmitter();
+    constructor(_appRef, _componentFactoryResolver, _injector, _changeDetectorRef, tieredMenuService, _tieredMenuEventService) {
+        this._appRef = _appRef;
+        this._componentFactoryResolver = _componentFactoryResolver;
+        this._injector = _injector;
+        this._changeDetectorRef = _changeDetectorRef;
+        this.tieredMenuService = tieredMenuService;
+        this._tieredMenuEventService = _tieredMenuEventService;
+    }
+    onResize() {
+        this._tieredMenuEventService.closeAllMenusEvent.emit();
+    }
+    onDocumentClick(event) {
+        // Closing menu when clicked outside.
+        const target = event.target;
+        const clickedInside = target.closest('s-tiered-menu-item') || target.closest('s-tiered-menu-divider');
+        if (!clickedInside) {
+            this._tieredMenuEventService.closeAllMenusEvent.emit();
+        }
+    }
+    onKeydownHandler(event) {
+        if (this.tieredMenuService.currentItem) {
+            switch (event.key) {
+                case 'Escape':
+                    this._tieredMenuEventService.closeAllMenusEvent.emit();
+                    break;
+                case ' ':
+                case 'Enter':
+                    if (!this.tieredMenuService.currentItem.disabled) {
+                        this._tieredMenuEventService.selectItemEvent.emit(this.tieredMenuService.currentItem);
+                    }
+                    break;
+                case 'ArrowLeft':
+                    if (this.items.includes(this.tieredMenuService.currentItem)) {
+                        this._tieredMenuEventService.closeItemMenuEvent.emit(this.tieredMenuService.currentItem);
+                        this._changeDetectorRef.detectChanges();
+                    }
+                    break;
+                case 'ArrowRight':
+                    if (!this.tieredMenuService.currentItem.disabled &&
+                        this.items.includes(this.tieredMenuService.currentItem)) {
+                        this._tieredMenuEventService.openItemMenuEvent.emit(this.tieredMenuService.currentItem);
+                        event.stopImmediatePropagation();
+                    }
+                    break;
+            }
+        }
+        else {
+            switch (event.key) {
+                case 'ArrowUp':
+                    if (this.items.includes(this.tieredMenuService.currentItem)) {
+                        this._tieredMenuEventService.decrementCurrentItemEvent.emit();
+                        event.stopImmediatePropagation();
+                    }
+                    break;
+                case 'ArrowDown':
+                    if (this.items.includes(this.tieredMenuService.currentItem)) {
+                        this._tieredMenuEventService.incrementCurrentItemEvent.emit();
+                        event.stopImmediatePropagation();
+                    }
+                    break;
+            }
+        }
+    }
+    ngOnInit() {
+        this.tieredMenuService.currentItems = this.items;
+        this._subscribeEvents();
+        disableScroll();
+    }
+    ngOnDestroy() {
+        this._unsubscribe$.next();
+        this._unsubscribe$.complete();
+    }
+    _incrementCurItem() {
+        if (!this.tieredMenuService.currentItem) {
+            this.tieredMenuService.currentItem = this.tieredMenuService.currentItems[0];
+            return;
+        }
+        else if (!this.items.includes(this.tieredMenuService.currentItem)) {
+            // Checking if it is the current menu.
+            return;
+        }
+        const currentIndex = this.tieredMenuService.currentItems.indexOf(this.tieredMenuService.currentItem) + 1;
+        if (currentIndex < this.tieredMenuService.currentItems.length) {
+            this.tieredMenuService.currentItem = this.tieredMenuService.currentItems[currentIndex];
+        }
+        else {
+            this.tieredMenuService.currentItem = this.tieredMenuService.currentItems[0];
+        }
+        if (this.tieredMenuService.currentItem.divider) {
+            this._incrementCurItem();
+        }
+    }
+    _decrementCurItem() {
+        if (!this.tieredMenuService.currentItem) {
+            this.tieredMenuService.currentItem = this.tieredMenuService.currentItems[0];
+            return;
+            // Checking if it is the current menu.
+        }
+        else if (!this.items.includes(this.tieredMenuService.currentItem)) {
+            return;
+        }
+        const curIndex = this.tieredMenuService.currentItems.indexOf(this.tieredMenuService.currentItem) - 1;
+        if (curIndex >= 0) {
+            this.tieredMenuService.currentItem = this.tieredMenuService.currentItems[curIndex];
+        }
+        else {
+            this.tieredMenuService.currentItem =
+                this.tieredMenuService.currentItems[this.tieredMenuService.currentItems.length - 1];
+        }
+        if (this.tieredMenuService.currentItem.divider) {
+            this._decrementCurItem();
+        }
+    }
+    _createMenu(items, position) {
+        if (!this._componentRef && items) {
+            const componentFactory = this._componentFactoryResolver.resolveComponentFactory(TieredMenuComponent);
+            this._componentRef = componentFactory.create(this._injector);
+            this._appRef.attachView(this._componentRef.hostView);
+            const domElem = this._componentRef.hostView.rootNodes[0];
+            document.body.appendChild(domElem);
+            // Setting the menu items.
+            this._componentRef.instance.items = items;
+            // Subscribe menu events.
+            this._componentRef.instance.destroyRequest.subscribe((propagate) => {
+                this._destroy(propagate);
+            });
+            this._menuDivElement = domElem.querySelector('.menu');
+            this._setMenuPosition(position);
+        }
+    }
+    _destroy(propagate = true) {
+        if (this._componentRef !== null) {
+            this._appRef.detachView(this._componentRef.hostView);
+            this._componentRef.destroy();
+            this._componentRef = null;
+            this._menuDivElement = null;
+        }
+        if (propagate) {
+            this.destroyRequest.emit();
+        }
+    }
+    _setMenuPosition(position) {
+        const ITEM_HEIGHT = 37;
+        const DIVIDER_HEIGHT = 5;
+        const PADDING = 8;
+        if (this._componentRef !== null) {
+            const { top, right, bottom, left } = position;
+            const itemsCount = this._componentRef.instance.items?.reduce((count, item) => {
+                return !item.divider ? count + 1 : count;
+            }, 0);
+            const dividersCount = this._componentRef.instance.items?.reduce((count, item) => {
+                return item.divider ? count + 1 : count;
+            }, 0);
+            // I need to calculate the height of the component because the internal elements have not been created yet.
+            const menuHeight = itemsCount * ITEM_HEIGHT + dividersCount * DIVIDER_HEIGHT + PADDING + 8;
+            const menuWidth = this._menuDivElement?.getBoundingClientRect().width ?? 0;
+            const rightFreeSpace = window.innerWidth - right;
+            const bottomFreeSpace = window.innerHeight - bottom;
+            if (rightFreeSpace > menuWidth) {
+                this._componentRef.instance.left = right;
+            }
+            else {
+                this._componentRef.instance.left = left - menuWidth;
+            }
+            if (bottomFreeSpace <= menuHeight) {
+                this._componentRef.instance.top = Math.max(window.innerHeight - menuHeight, window.scrollY);
+            }
+            else {
+                this._componentRef.instance.top = window.scrollY + top;
+            }
+        }
+    }
+    _subscribeEvents() {
+        // Increment current item event.
+        this._tieredMenuEventService.incrementCurrentItemEvent.pipe(takeUntil(this._unsubscribe$)).subscribe(() => {
+            this._incrementCurItem();
+        });
+        // Decrement current item event.
+        this._tieredMenuEventService.decrementCurrentItemEvent.pipe(takeUntil(this._unsubscribe$)).subscribe(() => {
+            this._decrementCurItem();
+        });
+        // Select item event.
+        this._tieredMenuEventService.selectItemEvent
+            .pipe(takeUntil(this._unsubscribe$))
+            .subscribe((item) => {
+            if (item) {
+                if (item.submenu) {
+                    this._tieredMenuEventService.openItemMenuEvent.emit(item);
+                }
+                else if (item.command) {
+                    this._tieredMenuEventService.closeAllMenusEvent.emit();
+                    item.command();
+                }
+            }
+        });
+        // Close all menus event.
+        this._tieredMenuEventService.closeAllMenusEvent.pipe(takeUntil(this._unsubscribe$)).subscribe(() => {
+            this._destroy();
+            this.tieredMenuService.currentItem = null;
+            this.tieredMenuService.currentItems = this.tieredMenuService.items;
+            this.tieredMenuService.markAllItemsAsClosed(this.tieredMenuService.items);
+            enableScroll();
+        });
+        // Open item menu event.
+        this._tieredMenuEventService.openItemMenuEvent
+            .pipe(takeUntil(this._unsubscribe$))
+            .subscribe((item) => {
+            if (this.tieredMenuService.currentItem) {
+                if (this.tieredMenuService.currentItem.parent === item) {
+                    return;
+                }
+                if (this.tieredMenuService.currentItem?.parent) {
+                    if (!item)
+                        return;
+                    if (!this.tieredMenuService.searchTheHierarchy(this.tieredMenuService.currentItem.parent, item)) {
+                        let current = this.tieredMenuService.currentItem;
+                        current.isOpen = false;
+                        while (current?.parent !== item.parent) {
+                            this._tieredMenuEventService.closeItemMenuEvent.emit(current);
+                            this._changeDetectorRef.detectChanges();
+                            current = current?.parent;
+                        }
+                        if (current) {
+                            current.isOpen = false;
+                        }
+                    }
+                }
+            }
+            if (item?.submenu && !item?.isOpen && this.items.includes(item)) {
+                const itemEl = document.querySelector(`#${item.id}`);
+                if (!itemEl)
+                    return;
+                const { top, right, left, bottom } = itemEl.getBoundingClientRect();
+                const position = { top, right, left, bottom };
+                this._createMenu(item.submenu, position);
+                this.tieredMenuService.currentItems = item.submenu;
+                this.tieredMenuService.currentItem = item.submenu[0];
+                item.isOpen = true;
+            }
+        });
+        // Close item menu event.
+        this._tieredMenuEventService.closeItemMenuEvent
+            .pipe(takeUntil(this._unsubscribe$))
+            .subscribe((item) => {
+            if (item === null)
+                return;
+            if (this.items.some((i) => i.id === item.id)) {
+                if (item.parent) {
+                    item.parent.isOpen = false;
+                }
+                else {
+                    enableScroll();
+                }
+                this.tieredMenuService.currentItems = item?.parent?.parent?.submenu || this.tieredMenuService.items;
+                this.tieredMenuService.currentItem = item.parent;
+                this.destroyRequest.emit(false);
+            }
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: TieredMenuComponent, deps: [{ token: i0.ApplicationRef }, { token: i0.ComponentFactoryResolver }, { token: i0.Injector }, { token: i0.ChangeDetectorRef }, { token: i1.TieredMenuService }, { token: i2.TieredMenuEventService }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.14", type: TieredMenuComponent, selector: "s-tiered-menu", outputs: { destroyRequest: "destroyRequest" }, host: { listeners: { "window:resize": "onResize()", "document:click": "onDocumentClick($event)", "document:keydown": "onKeydownHandler($event)" } }, ngImport: i0, template: "<div\n    class=\"menu\"\n    [ngStyle]=\"{\n        left: left + 'px',\n        top: top + 'px',\n    }\"\n>\n    <!-- <div *ngFor=\"let item of items\">\n        <s-tiered-menu-item\n            *ngIf=\"item.visible && !item.divider\"\n            [item]=\"item\"\n            [focused]=\"item === tieredMenuService.currentItem\"\n            [highlight]=\"item.isOpen\"\n            triggerEvent=\"hover\"\n            [closeOnClick]=\"false\"\n        >\n        </s-tiered-menu-item>\n        <s-tiered-menu-divider *ngIf=\"item.divider\"></s-tiered-menu-divider>\n    </div> -->\n    @for(item of items; track $index) {\n        @if(item.visible && !item.divider) {\n            <s-tiered-menu-item\n                [item]=\"item\"\n                [focused]=\"item === tieredMenuService.currentItem\"\n                [highlight]=\"item.isOpen\"\n                triggerEvent=\"hover\"\n                [closeOnClick]=\"false\"/>\n        }\n        @if (item.divider) {\n            <s-tiered-menu-divider/>\n        }\n    }\n</div>\n", styles: [".menu{background-color:#fff;border:1px solid #ccc;border-radius:6px;box-shadow:0 2px 12px #0000001a;display:inline-flex;flex-direction:column;max-height:100vh;min-width:176px;padding:4px 0;overflow-y:auto;position:absolute;z-index:9999}\n"], dependencies: [{ kind: "directive", type: i3.NgStyle, selector: "[ngStyle]", inputs: ["ngStyle"] }, { kind: "component", type: i4.TieredMenuItemComponent, selector: "s-tiered-menu-item", inputs: ["item", "focused", "highlight", "triggerEvent", "closeOnClick"] }, { kind: "component", type: i5.TieredMenuDividerComponent, selector: "s-tiered-menu-divider" }] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: TieredMenuComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 's-tiered-menu', template: "<div\n    class=\"menu\"\n    [ngStyle]=\"{\n        left: left + 'px',\n        top: top + 'px',\n    }\"\n>\n    <!-- <div *ngFor=\"let item of items\">\n        <s-tiered-menu-item\n            *ngIf=\"item.visible && !item.divider\"\n            [item]=\"item\"\n            [focused]=\"item === tieredMenuService.currentItem\"\n            [highlight]=\"item.isOpen\"\n            triggerEvent=\"hover\"\n            [closeOnClick]=\"false\"\n        >\n        </s-tiered-menu-item>\n        <s-tiered-menu-divider *ngIf=\"item.divider\"></s-tiered-menu-divider>\n    </div> -->\n    @for(item of items; track $index) {\n        @if(item.visible && !item.divider) {\n            <s-tiered-menu-item\n                [item]=\"item\"\n                [focused]=\"item === tieredMenuService.currentItem\"\n                [highlight]=\"item.isOpen\"\n                triggerEvent=\"hover\"\n                [closeOnClick]=\"false\"/>\n        }\n        @if (item.divider) {\n            <s-tiered-menu-divider/>\n        }\n    }\n</div>\n", styles: [".menu{background-color:#fff;border:1px solid #ccc;border-radius:6px;box-shadow:0 2px 12px #0000001a;display:inline-flex;flex-direction:column;max-height:100vh;min-width:176px;padding:4px 0;overflow-y:auto;position:absolute;z-index:9999}\n"] }]
+        }], ctorParameters: () => [{ type: i0.ApplicationRef }, { type: i0.ComponentFactoryResolver }, { type: i0.Injector }, { type: i0.ChangeDetectorRef }, { type: i1.TieredMenuService }, { type: i2.TieredMenuEventService }], propDecorators: { destroyRequest: [{
+                type: Output
+            }], onResize: [{
+                type: HostListener,
+                args: ['window:resize']
+            }], onDocumentClick: [{
+                type: HostListener,
+                args: ['document:click', ['$event']]
+            }], onKeydownHandler: [{
+                type: HostListener,
+                args: ['document:keydown', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tiered-menu.component.js","sourceRoot":"","sources":["../../../../../../../projects/angular-components/tiered-menu/src/lib/tiered-menu/components/tiered-menu/tiered-menu.component.ts","../../../../../../../projects/angular-components/tiered-menu/src/lib/tiered-menu/components/tiered-menu/tiered-menu.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\n    ApplicationRef,\n    ChangeDetectorRef,\n    Component,\n    ComponentFactoryResolver,\n    ComponentRef,\n    EmbeddedViewRef,\n    EventEmitter,\n    HostListener,\n    Injector,\n    OnDestroy,\n    OnInit,\n    Output,\n} from '@angular/core';\n\nimport { Subject } from 'rxjs';\n\nimport { takeUntil } from 'rxjs/operators';\nimport { TieredMenuItemInternalData } from '../../models/tiered-menu-item-internal-data';\nimport { TieredMenuEventService } from '../../services/tiered-menu.event.service';\nimport { TieredMenuService } from '../../services/tiered-menu.service';\nimport { disableScroll, enableScroll } from '@seniorsistemas/angular-components/utils';\n\n@Component({\n    selector: 's-tiered-menu',\n    templateUrl: './tiered-menu.component.html',\n    styleUrls: ['./tiered-menu.component.scss'],\n})\nexport class TieredMenuComponent implements OnInit, OnDestroy {\n    public items: TieredMenuItemInternalData[] = [];\n    public top = 0;\n    public left = 0;\n    public menuTriggerEvent: 'click' | 'hover' = 'hover';\n\n    private _componentRef: ComponentRef<TieredMenuComponent> | null = null;\n    private _menuDivElement?: HTMLElement | null = null;\n    private _unsubscribe$ = new Subject<void>();\n\n    @Output()\n    public destroyRequest = new EventEmitter<boolean>();\n\n    constructor(\n        private readonly _appRef: ApplicationRef,\n        private readonly _componentFactoryResolver: ComponentFactoryResolver,\n        private readonly _injector: Injector,\n        private readonly _changeDetectorRef: ChangeDetectorRef,\n        public readonly tieredMenuService: TieredMenuService,\n        private readonly _tieredMenuEventService: TieredMenuEventService,\n    ) {}\n\n    @HostListener('window:resize')\n    public onResize(): void {\n        this._tieredMenuEventService.closeAllMenusEvent.emit();\n    }\n\n    @HostListener('document:click', ['$event'])\n    public onDocumentClick(event: MouseEvent): void {\n        // Closing menu when clicked outside.\n        const target = event.target as Element;\n        const clickedInside = target.closest('s-tiered-menu-item') || target.closest('s-tiered-menu-divider');\n        if (!clickedInside) {\n            this._tieredMenuEventService.closeAllMenusEvent.emit();\n        }\n    }\n\n    @HostListener('document:keydown', ['$event'])\n    public onKeydownHandler(event: KeyboardEvent) {\n        if (this.tieredMenuService.currentItem) {\n            switch (event.key) {\n                case 'Escape':\n                    this._tieredMenuEventService.closeAllMenusEvent.emit();\n                    break;\n                case ' ':\n                case 'Enter':\n                    if (!this.tieredMenuService.currentItem.disabled) {\n                        this._tieredMenuEventService.selectItemEvent.emit(this.tieredMenuService.currentItem);\n                    }\n                    break;\n                case 'ArrowLeft':\n                    if (this.items.includes(this.tieredMenuService.currentItem)) {\n                        this._tieredMenuEventService.closeItemMenuEvent.emit(this.tieredMenuService.currentItem);\n                        this._changeDetectorRef.detectChanges();\n                    }\n                    break;\n                case 'ArrowRight':\n                    if (\n                        !this.tieredMenuService.currentItem.disabled &&\n                        this.items.includes(this.tieredMenuService.currentItem)\n                    ) {\n                        this._tieredMenuEventService.openItemMenuEvent.emit(this.tieredMenuService.currentItem);\n                        event.stopImmediatePropagation();\n                    }\n                    break;\n            }\n        } else {\n            switch (event.key) {\n                case 'ArrowUp':\n                    if (this.items.includes(this.tieredMenuService.currentItem!)) {\n                        this._tieredMenuEventService.decrementCurrentItemEvent.emit();\n                        event.stopImmediatePropagation();\n                    }\n                    break;\n                case 'ArrowDown':\n                    if (this.items.includes(this.tieredMenuService.currentItem!)) {\n                        this._tieredMenuEventService.incrementCurrentItemEvent.emit();\n                        event.stopImmediatePropagation();\n                    }\n                    break;\n            }\n        }\n    }\n\n    public ngOnInit(): void {\n        this.tieredMenuService.currentItems = this.items;\n        this._subscribeEvents();\n        disableScroll();\n    }\n\n    public ngOnDestroy(): void {\n        this._unsubscribe$.next();\n        this._unsubscribe$.complete();\n    }\n\n    private _incrementCurItem(): void {\n        if (!this.tieredMenuService.currentItem) {\n            this.tieredMenuService.currentItem = this.tieredMenuService.currentItems[0];\n            return;\n        } else if (!this.items.includes(this.tieredMenuService.currentItem)) {\n            // Checking if it is the current menu.\n            return;\n        }\n\n        const currentIndex = this.tieredMenuService.currentItems.indexOf(this.tieredMenuService.currentItem) + 1;\n\n        if (currentIndex < this.tieredMenuService.currentItems.length) {\n            this.tieredMenuService.currentItem = this.tieredMenuService.currentItems[currentIndex];\n        } else {\n            this.tieredMenuService.currentItem = this.tieredMenuService.currentItems[0];\n        }\n\n        if (this.tieredMenuService.currentItem.divider) {\n            this._incrementCurItem();\n        }\n    }\n\n    private _decrementCurItem(): void {\n        if (!this.tieredMenuService.currentItem) {\n            this.tieredMenuService.currentItem = this.tieredMenuService.currentItems[0];\n            return;\n            // Checking if it is the current menu.\n        } else if (!this.items.includes(this.tieredMenuService.currentItem)) {\n            return;\n        }\n\n        const curIndex = this.tieredMenuService.currentItems.indexOf(this.tieredMenuService.currentItem) - 1;\n\n        if (curIndex >= 0) {\n            this.tieredMenuService.currentItem = this.tieredMenuService.currentItems[curIndex];\n        } else {\n            this.tieredMenuService.currentItem =\n                this.tieredMenuService.currentItems[this.tieredMenuService.currentItems.length - 1];\n        }\n\n        if (this.tieredMenuService.currentItem.divider) {\n            this._decrementCurItem();\n        }\n    }\n\n    private _createMenu(items: TieredMenuItemInternalData[], position: any): void {\n        if (!this._componentRef && items) {\n            const componentFactory = this._componentFactoryResolver.resolveComponentFactory(TieredMenuComponent);\n            this._componentRef = componentFactory.create(this._injector);\n            this._appRef.attachView(this._componentRef.hostView);\n            const domElem = (this._componentRef.hostView as EmbeddedViewRef<any>).rootNodes[0] as HTMLElement;\n            document.body.appendChild(domElem);\n\n            // Setting the menu items.\n            this._componentRef.instance.items = items;\n\n            // Subscribe menu events.\n            this._componentRef.instance.destroyRequest.subscribe((propagate: boolean) => {\n                this._destroy(propagate);\n            });\n\n            this._menuDivElement = domElem.querySelector('.menu');\n            this._setMenuPosition(position);\n        }\n    }\n\n    private _destroy(propagate = true): void {\n        if (this._componentRef !== null) {\n            this._appRef.detachView(this._componentRef.hostView);\n            this._componentRef.destroy();\n            this._componentRef = null;\n            this._menuDivElement = null;\n        }\n\n        if (propagate) {\n            this.destroyRequest.emit();\n        }\n    }\n\n    private _setMenuPosition(position: any): void {\n        const ITEM_HEIGHT = 37;\n        const DIVIDER_HEIGHT = 5;\n        const PADDING = 8;\n\n        if (this._componentRef !== null) {\n            const { top, right, bottom, left } = position;\n\n            const itemsCount = this._componentRef.instance.items?.reduce(\n                (count: number, item: TieredMenuItemInternalData) => {\n                    return !item.divider ? count + 1 : count;\n                },\n                0,\n            );\n\n            const dividersCount = this._componentRef.instance.items?.reduce(\n                (count: number, item: TieredMenuItemInternalData) => {\n                    return item.divider ? count + 1 : count;\n                },\n                0,\n            );\n\n            // I need to calculate the height of the component because the internal elements have not been created yet.\n            const menuHeight = itemsCount * ITEM_HEIGHT + dividersCount * DIVIDER_HEIGHT + PADDING + 8;\n            const menuWidth = this._menuDivElement?.getBoundingClientRect().width ?? 0;\n\n            const rightFreeSpace = window.innerWidth - right;\n            const bottomFreeSpace = window.innerHeight - bottom;\n\n            if (rightFreeSpace > menuWidth) {\n                this._componentRef.instance.left = right;\n            } else {\n                this._componentRef.instance.left = left - menuWidth;\n            }\n\n            if (bottomFreeSpace <= menuHeight) {\n                this._componentRef.instance.top = Math.max(window.innerHeight - menuHeight, window.scrollY);\n            } else {\n                this._componentRef.instance.top = window.scrollY + top;\n            }\n        }\n    }\n\n    private _subscribeEvents(): void {\n        // Increment current item event.\n        this._tieredMenuEventService.incrementCurrentItemEvent.pipe(takeUntil(this._unsubscribe$)).subscribe(() => {\n            this._incrementCurItem();\n        });\n        // Decrement current item event.\n        this._tieredMenuEventService.decrementCurrentItemEvent.pipe(takeUntil(this._unsubscribe$)).subscribe(() => {\n            this._decrementCurItem();\n        });\n        // Select item event.\n        this._tieredMenuEventService.selectItemEvent\n            .pipe(takeUntil(this._unsubscribe$))\n            .subscribe((item: TieredMenuItemInternalData | null) => {\n                if (item) {\n                    if (item.submenu) {\n                        this._tieredMenuEventService.openItemMenuEvent.emit(item);\n                    } else if (item.command) {\n                        this._tieredMenuEventService.closeAllMenusEvent.emit();\n                        item.command();\n                    }\n                }\n            });\n        // Close all menus event.\n        this._tieredMenuEventService.closeAllMenusEvent.pipe(takeUntil(this._unsubscribe$)).subscribe(() => {\n            this._destroy();\n            this.tieredMenuService.currentItem = null;\n            this.tieredMenuService.currentItems = this.tieredMenuService.items;\n            this.tieredMenuService.markAllItemsAsClosed(this.tieredMenuService.items);\n            enableScroll();\n        });\n\n        // Open item menu event.\n        this._tieredMenuEventService.openItemMenuEvent\n            .pipe(takeUntil(this._unsubscribe$))\n            .subscribe((item: TieredMenuItemInternalData | null) => {\n                if (this.tieredMenuService.currentItem) {\n                    if (this.tieredMenuService.currentItem.parent === item) {\n                        return;\n                    }\n\n                    if (this.tieredMenuService.currentItem?.parent) {\n                        if (!item) return;\n\n                        if (\n                            !this.tieredMenuService.searchTheHierarchy(this.tieredMenuService.currentItem.parent, item)\n                        ) {\n                            let current: TieredMenuItemInternalData | undefined = this.tieredMenuService.currentItem;\n\n                            current.isOpen = false;\n\n                            while (current?.parent !== item.parent) {\n                                this._tieredMenuEventService.closeItemMenuEvent.emit(current);\n                                this._changeDetectorRef.detectChanges();\n\n                                current = current?.parent;\n                            }\n\n                            if (current) {\n                                current.isOpen = false;\n                            }\n                        }\n                    }\n                }\n\n                if (item?.submenu && !item?.isOpen && this.items.includes(item)) {\n                    const itemEl = document.querySelector(`#${item.id}`);\n\n                    if (!itemEl) return;\n\n                    const { top, right, left, bottom } = itemEl.getBoundingClientRect();\n                    const position = { top, right, left, bottom };\n\n                    this._createMenu(item.submenu, position);\n                    this.tieredMenuService.currentItems = item.submenu;\n                    this.tieredMenuService.currentItem = item.submenu[0];\n                    item.isOpen = true;\n                }\n            });\n\n        // Close item menu event.\n        this._tieredMenuEventService.closeItemMenuEvent\n            .pipe(takeUntil(this._unsubscribe$))\n            .subscribe((item: TieredMenuItemInternalData | null) => {\n                if (item === null) return;\n                if (this.items.some((i) => i.id === item.id)) {\n                    if (item.parent) {\n                        item.parent.isOpen = false;\n                    } else {\n                        enableScroll();\n                    }\n                    this.tieredMenuService.currentItems = item?.parent?.parent?.submenu || this.tieredMenuService.items;\n                    this.tieredMenuService.currentItem = item.parent;\n                    this.destroyRequest.emit(false);\n                }\n            });\n    }\n}\n","<div\n    class=\"menu\"\n    [ngStyle]=\"{\n        left: left + 'px',\n        top: top + 'px',\n    }\"\n>\n    <!-- <div *ngFor=\"let item of items\">\n        <s-tiered-menu-item\n            *ngIf=\"item.visible && !item.divider\"\n            [item]=\"item\"\n            [focused]=\"item === tieredMenuService.currentItem\"\n            [highlight]=\"item.isOpen\"\n            triggerEvent=\"hover\"\n            [closeOnClick]=\"false\"\n        >\n        </s-tiered-menu-item>\n        <s-tiered-menu-divider *ngIf=\"item.divider\"></s-tiered-menu-divider>\n    </div> -->\n    @for(item of items; track $index) {\n        @if(item.visible && !item.divider) {\n            <s-tiered-menu-item\n                [item]=\"item\"\n                [focused]=\"item === tieredMenuService.currentItem\"\n                [highlight]=\"item.isOpen\"\n                triggerEvent=\"hover\"\n                [closeOnClick]=\"false\"/>\n        }\n        @if (item.divider) {\n            <s-tiered-menu-divider/>\n        }\n    }\n</div>\n"]}

package/esm2022/tiered-menu/lib/tiered-menu/components/tiered-menu-divider/tiered-menu-divider.component.mjs

@@ -0,0 +1,11 @@
+import { Component } from '@angular/core';
+import * as i0 from "@angular/core";
+export class TieredMenuDividerComponent {
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: TieredMenuDividerComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: TieredMenuDividerComponent, selector: "s-tiered-menu-divider", ngImport: i0, template: "<div class=\"divider\"></div>\n", styles: [".divider{margin:2px 0;height:1px;background-color:#ccc}\n"] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: TieredMenuDividerComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 's-tiered-menu-divider', template: "<div class=\"divider\"></div>\n", styles: [".divider{margin:2px 0;height:1px;background-color:#ccc}\n"] }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGllcmVkLW1lbnUtZGl2aWRlci5jb21wb25lbnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9hbmd1bGFyLWNvbXBvbmVudHMvdGllcmVkLW1lbnUvc3JjL2xpYi90aWVyZWQtbWVudS9jb21wb25lbnRzL3RpZXJlZC1tZW51LWRpdmlkZXIvdGllcmVkLW1lbnUtZGl2aWRlci5jb21wb25lbnQudHMiLCIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9hbmd1bGFyLWNvbXBvbmVudHMvdGllcmVkLW1lbnUvc3JjL2xpYi90aWVyZWQtbWVudS9jb21wb25lbnRzL3RpZXJlZC1tZW51LWRpdmlkZXIvdGllcmVkLW1lbnUtZGl2aWRlci5jb21wb25lbnQuaHRtbCJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsU0FBUyxFQUFFLE1BQU0sZUFBZSxDQUFDOztBQU8xQyxNQUFNLE9BQU8sMEJBQTBCO3dHQUExQiwwQkFBMEI7NEZBQTFCLDBCQUEwQiw2RENQdkMsaUNBQ0E7OzRGRE1hLDBCQUEwQjtrQkFMdEMsU0FBUzsrQkFDSSx1QkFBdUIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBDb21wb25lbnQgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuQENvbXBvbmVudCh7XG4gICAgc2VsZWN0b3I6ICdzLXRpZXJlZC1tZW51LWRpdmlkZXInLFxuICAgIHRlbXBsYXRlVXJsOiAnLi90aWVyZWQtbWVudS1kaXZpZGVyLmNvbXBvbmVudC5odG1sJyxcbiAgICBzdHlsZVVybHM6IFsnLi90aWVyZWQtbWVudS1kaXZpZGVyLmNvbXBvbmVudC5zY3NzJ10sXG59KVxuZXhwb3J0IGNsYXNzIFRpZXJlZE1lbnVEaXZpZGVyQ29tcG9uZW50IHt9XG4iLCI8ZGl2IGNsYXNzPVwiZGl2aWRlclwiPjwvZGl2PlxuIl19

package/esm2022/tiered-menu/lib/tiered-menu/components/tiered-menu-item/tiered-menu-item.component.mjs

@@ -0,0 +1,73 @@
+import { Component, HostListener, Input } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "../../services/tiered-menu.event.service";
+import * as i2 from "@angular/common";
+export class TieredMenuItemComponent {
+    _tieredMenuEventService;
+    item;
+    focused = false;
+    highlight = false;
+    triggerEvent = 'click';
+    closeOnClick = false;
+    _showTimeout;
+    constructor(_tieredMenuEventService) {
+        this._tieredMenuEventService = _tieredMenuEventService;
+    }
+    onClick() {
+        if (this.item.disabled)
+            return;
+        if (this.item.submenu) {
+            if (!this.item.isOpen) {
+                this._tieredMenuEventService.openItemMenuEvent.emit(this.item);
+            }
+            else if (this.closeOnClick) {
+                this._tieredMenuEventService.closeItemMenuEvent.emit(this.item);
+            }
+        }
+        else {
+            this._tieredMenuEventService.selectItemEvent.emit(this.item);
+        }
+    }
+    onMouseEnter() {
+        if (this.item.disabled)
+            return;
+        if (this.triggerEvent === 'hover' && !this.item.isOpen) {
+            this._showTimeout = window.setTimeout(() => {
+                this._tieredMenuEventService.openItemMenuEvent.emit(this.item);
+            }, 300);
+        }
+    }
+    onMouseLeave() {
+        window.clearTimeout(this._showTimeout);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: TieredMenuItemComponent, deps: [{ token: i1.TieredMenuEventService }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.14", type: TieredMenuItemComponent, selector: "s-tiered-menu-item", inputs: { item: "item", focused: "focused", highlight: "highlight", triggerEvent: "triggerEvent", closeOnClick: "closeOnClick" }, host: { listeners: { "click": "onClick()", "touchend": "onClick()", "mouseenter": "onMouseEnter()", "mouseleave": "onMouseLeave()" } }, ngImport: i0, template: "<div\n    [id]=\"item.id\"\n    class=\"tiered-menu-item\"\n    [attr.data-key]=\"item.dataKey\"\n    [ngClass]=\"{\n        'tiered-menu-item--open': item.isOpen,\n        'tiered-menu-item--focused': focused,\n        'tiered-menu-item--disabled': item.disabled,\n    }\"\n>\n    <div class=\"tiered-menu-item-content\">\n        <span\n            class=\"icon\"\n            [ngClass]=\"item.iconClass\"\n        ></span>\n        <span class=\"label\">{{ item.label }}</span>\n    </div>\n    @if (item.submenu) {\n        <span\n            class=\"submenu-icon fas\"\n            [class.fa-chevron-left]=\"item.isOpen\"\n            [class.fa-chevron-right]=\"!item.isOpen\"\n        >\n        </span>\n    }\n</div>\n", styles: [".tiered-menu-item{align-items:center;display:flex;justify-content:space-between;padding:8px 16px;-webkit-user-select:none;user-select:none;cursor:pointer}.tiered-menu-item .tiered-menu-item-content .label{margin:0 12px}.tiered-menu-item:hover{background-color:#e9e6e6}.tiered-menu-item--focused{background-color:#ccc!important}.tiered-menu-item--open{background-color:#e4e2e2}.tiered-menu-item--disabled{opacity:50%;cursor:default}\n"], dependencies: [{ kind: "directive", type: i2.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: TieredMenuItemComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 's-tiered-menu-item', template: "<div\n    [id]=\"item.id\"\n    class=\"tiered-menu-item\"\n    [attr.data-key]=\"item.dataKey\"\n    [ngClass]=\"{\n        'tiered-menu-item--open': item.isOpen,\n        'tiered-menu-item--focused': focused,\n        'tiered-menu-item--disabled': item.disabled,\n    }\"\n>\n    <div class=\"tiered-menu-item-content\">\n        <span\n            class=\"icon\"\n            [ngClass]=\"item.iconClass\"\n        ></span>\n        <span class=\"label\">{{ item.label }}</span>\n    </div>\n    @if (item.submenu) {\n        <span\n            class=\"submenu-icon fas\"\n            [class.fa-chevron-left]=\"item.isOpen\"\n            [class.fa-chevron-right]=\"!item.isOpen\"\n        >\n        </span>\n    }\n</div>\n", styles: [".tiered-menu-item{align-items:center;display:flex;justify-content:space-between;padding:8px 16px;-webkit-user-select:none;user-select:none;cursor:pointer}.tiered-menu-item .tiered-menu-item-content .label{margin:0 12px}.tiered-menu-item:hover{background-color:#e9e6e6}.tiered-menu-item--focused{background-color:#ccc!important}.tiered-menu-item--open{background-color:#e4e2e2}.tiered-menu-item--disabled{opacity:50%;cursor:default}\n"] }]
+        }], ctorParameters: () => [{ type: i1.TieredMenuEventService }], propDecorators: { item: [{
+                type: Input,
+                args: [{ required: true }]
+            }], focused: [{
+                type: Input
+            }], highlight: [{
+                type: Input
+            }], triggerEvent: [{
+                type: Input
+            }], closeOnClick: [{
+                type: Input
+            }], onClick: [{
+                type: HostListener,
+                args: ['click']
+            }, {
+                type: HostListener,
+                args: ['touchend']
+            }], onMouseEnter: [{
+                type: HostListener,
+                args: ['mouseenter']
+            }], onMouseLeave: [{
+                type: HostListener,
+                args: ['mouseleave']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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