@seniorsistemas/angular-components 17.31.2 → 18.0.0-develop-ae6477c0

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

@@ -0,0 +1,179 @@
+import { Component, HostListener } 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 TieredMenuNestedComponent {
+    tieredMenuService;
+    _tieredMenuEventService;
+    items;
+    top = 0;
+    left = 0;
+    // public maxHeight = 0;
+    // Saves the last opened item to close it when a new one is opened
+    _lastOpenItem;
+    _unsubscribe$ = new Subject();
+    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) {
+        switch (event.key) {
+            case 'Escape':
+                this._tieredMenuEventService.closeAllMenusEvent.emit();
+                break;
+            case ' ':
+            case 'Enter':
+                this._tieredMenuEventService.selectItemEvent.emit(this.tieredMenuService.currentItem);
+                break;
+            case 'ArrowLeft':
+                // When nested I need a reference to the current item's parent item, otherwise just the current item.
+                this._tieredMenuEventService.closeItemMenuEvent.emit(this.tieredMenuService.currentItem?.parent);
+                break;
+            case 'ArrowRight':
+                this._tieredMenuEventService.openItemMenuEvent.emit(this.tieredMenuService.currentItem);
+                break;
+            case 'ArrowUp':
+                this._tieredMenuEventService.decrementCurrentItemEvent.emit();
+                break;
+            case 'ArrowDown':
+                this._tieredMenuEventService.incrementCurrentItemEvent.emit();
+                break;
+        }
+    }
+    constructor(tieredMenuService, _tieredMenuEventService) {
+        this.tieredMenuService = tieredMenuService;
+        this._tieredMenuEventService = _tieredMenuEventService;
+    }
+    ngOnInit() {
+        this.tieredMenuService.currentItems = this.items;
+        this._subscribeEvents();
+        disableScroll();
+    }
+    ngOnDestroy() {
+        this._unsubscribe$.next();
+        this._unsubscribe$.complete();
+        enableScroll();
+    }
+    _incrementCurItem() {
+        if (!this.tieredMenuService.currentItem) {
+            this.tieredMenuService.currentItem = this.tieredMenuService.currentItems[0];
+            return;
+        }
+        const curIndex = this.tieredMenuService.currentItems.indexOf(this.tieredMenuService.currentItem) + 1;
+        if (curIndex < this.tieredMenuService.currentItems.length) {
+            this.tieredMenuService.currentItem = this.tieredMenuService.currentItems[curIndex];
+        }
+        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;
+        }
+        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();
+        }
+    }
+    _closeItem(item) {
+        let itemAux = this._lastOpenItem;
+        while (itemAux && itemAux != item) {
+            itemAux.isOpen = false;
+            itemAux = itemAux.parent;
+        }
+        item.isOpen = false;
+        this.tieredMenuService.currentItem = itemAux ?? this.tieredMenuService.items[0];
+        this.tieredMenuService.currentItems = itemAux?.parent?.submenu || this.tieredMenuService.items;
+    }
+    _openItem(item) {
+        if (item?.submenu) {
+            item.isOpen = true;
+            this.tieredMenuService.currentItems = item.submenu;
+            // Only has focus if there has already been interaction.
+            if (this.tieredMenuService.currentItem) {
+                this.tieredMenuService.currentItem = item.submenu[0];
+            }
+            this._lastOpenItem = item;
+        }
+    }
+    _subscribeEvents() {
+        this._tieredMenuEventService.incrementCurrentItemEvent.pipe(takeUntil(this._unsubscribe$)).subscribe(() => {
+            this._incrementCurItem();
+        });
+        this._tieredMenuEventService.decrementCurrentItemEvent.pipe(takeUntil(this._unsubscribe$)).subscribe(() => {
+            this._decrementCurItem();
+        });
+        this._tieredMenuEventService.selectItemEvent
+            .pipe(takeUntil(this._unsubscribe$))
+            .subscribe((item) => {
+            if (item && item.command) {
+                item.command();
+                // Close all menus after the item was selected.
+                this._tieredMenuEventService.closeAllMenusEvent.emit();
+            }
+        });
+        this._tieredMenuEventService.openItemMenuEvent
+            .pipe(takeUntil(this._unsubscribe$))
+            .subscribe((item) => {
+            if (item) {
+                if (!this.tieredMenuService.currentItems.includes(item)) {
+                    let itemAux = this._lastOpenItem;
+                    while (itemAux?.parent?.parent) {
+                        itemAux = itemAux.parent;
+                    }
+                    this._tieredMenuEventService.closeItemMenuEvent.emit(itemAux?.parent ?? itemAux);
+                }
+                this._lastOpenItem = item;
+                this._openItem(item);
+            }
+        });
+        this._tieredMenuEventService.closeItemMenuEvent
+            .pipe(takeUntil(this._unsubscribe$))
+            .subscribe((item) => {
+            if (item) {
+                this._closeItem(item);
+            }
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: TieredMenuNestedComponent, deps: [{ token: i1.TieredMenuService }, { token: i2.TieredMenuEventService }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.14", type: TieredMenuNestedComponent, selector: "ng-component", host: { listeners: { "window:resize": "onResize()", "document:click": "onDocumentClick($event)", "document:keydown": "onKeydownHandler($event)" } }, ngImport: i0, template: "<div\n    class=\"menu menu--nested\"\n    [ngStyle]=\"{\n        top: top + 'px',\n        left: left + 'px',\n    }\"\n>\n    <ng-container\n        *ngTemplateOutlet=\"itemsTemplate; context: { $implicit: items }\"\n    ></ng-container>\n</div>\n\n<ng-template\n    #itemsTemplate\n    let-items\n>\n    @for (item of items; track item.id) {\n        <div>\n            @if (item.visible && !item.divider) {\n                <s-tiered-menu-item\n                    [item]=\"item\"\n                    [focused]=\"item === tieredMenuService.currentItem\"\n                    [closeOnClick]=\"true\"\n                >\n                </s-tiered-menu-item>\n            }\n            @if (item.divider) {\n                <s-tiered-menu-divider></s-tiered-menu-divider>\n            }\n            @if (item.submenu && item.isOpen) {\n                <div>\n                    <div class=\"submenu\">\n                        <ng-container\n                            *ngTemplateOutlet=\"\n                                itemsTemplate;\n                                context: { $implicit: item.submenu }\n                            \"\n                        ></ng-container>\n                    </div>\n                </div>\n            }\n        </div>\n    }\n</ng-template>\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;min-width:176px;padding:4px 0;position:absolute;z-index:9999;overflow:auto;width:calc(100vw - 8px)}.menu .submenu{margin-left:24px}\n"], dependencies: [{ kind: "directive", type: i3.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }, { 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: TieredMenuNestedComponent, decorators: [{
+            type: Component,
+            args: [{ template: "<div\n    class=\"menu menu--nested\"\n    [ngStyle]=\"{\n        top: top + 'px',\n        left: left + 'px',\n    }\"\n>\n    <ng-container\n        *ngTemplateOutlet=\"itemsTemplate; context: { $implicit: items }\"\n    ></ng-container>\n</div>\n\n<ng-template\n    #itemsTemplate\n    let-items\n>\n    @for (item of items; track item.id) {\n        <div>\n            @if (item.visible && !item.divider) {\n                <s-tiered-menu-item\n                    [item]=\"item\"\n                    [focused]=\"item === tieredMenuService.currentItem\"\n                    [closeOnClick]=\"true\"\n                >\n                </s-tiered-menu-item>\n            }\n            @if (item.divider) {\n                <s-tiered-menu-divider></s-tiered-menu-divider>\n            }\n            @if (item.submenu && item.isOpen) {\n                <div>\n                    <div class=\"submenu\">\n                        <ng-container\n                            *ngTemplateOutlet=\"\n                                itemsTemplate;\n                                context: { $implicit: item.submenu }\n                            \"\n                        ></ng-container>\n                    </div>\n                </div>\n            }\n        </div>\n    }\n</ng-template>\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;min-width:176px;padding:4px 0;position:absolute;z-index:9999;overflow:auto;width:calc(100vw - 8px)}.menu .submenu{margin-left:24px}\n"] }]
+        }], ctorParameters: () => [{ type: i1.TieredMenuService }, { type: i2.TieredMenuEventService }], propDecorators: { 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-nested.component.js","sourceRoot":"","sources":["../../../../../../../projects/angular-components/tiered-menu/src/lib/tiered-menu/components/tiered-menu-nested/tiered-menu-nested.component.ts","../../../../../../../projects/angular-components/tiered-menu/src/lib/tiered-menu/components/tiered-menu-nested/tiered-menu-nested.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Component, HostListener, OnDestroy, OnInit } from '@angular/core';\n\nimport { Subject } from 'rxjs';\n\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 { takeUntil } from 'rxjs/operators';\nimport { disableScroll, enableScroll } from '@seniorsistemas/angular-components/utils';\n\n@Component({\n    templateUrl: './tiered-menu-nested.component.html',\n    styleUrls: ['./tiered-menu-nested.component.scss'],\n})\nexport class TieredMenuNestedComponent implements OnInit, OnDestroy {\n    public items!: TieredMenuItemInternalData[];\n    public top = 0;\n    public left = 0;\n    // public maxHeight = 0;\n\n    // Saves the last opened item to close it when a new one is opened\n    private _lastOpenItem?: TieredMenuItemInternalData;\n    private _unsubscribe$ = new Subject<void>();\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        switch (event.key) {\n            case 'Escape':\n                this._tieredMenuEventService.closeAllMenusEvent.emit();\n                break;\n            case ' ':\n            case 'Enter':\n                this._tieredMenuEventService.selectItemEvent.emit(this.tieredMenuService.currentItem);\n                break;\n            case 'ArrowLeft':\n                // When nested I need a reference to the current item's parent item, otherwise just the current item.\n                this._tieredMenuEventService.closeItemMenuEvent.emit(this.tieredMenuService.currentItem?.parent);\n                break;\n            case 'ArrowRight':\n                this._tieredMenuEventService.openItemMenuEvent.emit(this.tieredMenuService.currentItem);\n                break;\n            case 'ArrowUp':\n                this._tieredMenuEventService.decrementCurrentItemEvent.emit();\n                break;\n            case 'ArrowDown':\n                this._tieredMenuEventService.incrementCurrentItemEvent.emit();\n                break;\n        }\n    }\n\n    constructor(\n        public readonly tieredMenuService: TieredMenuService,\n        private readonly _tieredMenuEventService: TieredMenuEventService,\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        enableScroll();\n    }\n\n    private _incrementCurItem(): void {\n        if (!this.tieredMenuService.currentItem) {\n            this.tieredMenuService.currentItem = this.tieredMenuService.currentItems[0];\n            return;\n        }\n\n        const curIndex = this.tieredMenuService.currentItems.indexOf(this.tieredMenuService.currentItem) + 1;\n\n        if (curIndex < this.tieredMenuService.currentItems.length) {\n            this.tieredMenuService.currentItem = this.tieredMenuService.currentItems[curIndex];\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        }\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 _closeItem(item: TieredMenuItemInternalData): void {\n        let itemAux = this._lastOpenItem;\n\n        while (itemAux && itemAux != item) {\n            itemAux.isOpen = false;\n            itemAux = itemAux.parent;\n        }\n\n        item.isOpen = false;\n\n        this.tieredMenuService.currentItem = itemAux ?? this.tieredMenuService.items[0];\n        this.tieredMenuService.currentItems = itemAux?.parent?.submenu || this.tieredMenuService.items;\n    }\n\n    private _openItem(item: TieredMenuItemInternalData): void {\n        if (item?.submenu) {\n            item.isOpen = true;\n            this.tieredMenuService.currentItems = item.submenu;\n\n            // Only has focus if there has already been interaction.\n            if (this.tieredMenuService.currentItem) {\n                this.tieredMenuService.currentItem = item.submenu[0];\n            }\n\n            this._lastOpenItem = item;\n        }\n    }\n\n    private _subscribeEvents(): void {\n        this._tieredMenuEventService.incrementCurrentItemEvent.pipe(takeUntil(this._unsubscribe$)).subscribe(() => {\n            this._incrementCurItem();\n        });\n\n        this._tieredMenuEventService.decrementCurrentItemEvent.pipe(takeUntil(this._unsubscribe$)).subscribe(() => {\n            this._decrementCurItem();\n        });\n\n        this._tieredMenuEventService.selectItemEvent\n            .pipe(takeUntil(this._unsubscribe$))\n            .subscribe((item: TieredMenuItemInternalData | null) => {\n                if (item && item.command) {\n                    item.command();\n                    // Close all menus after the item was selected.\n                    this._tieredMenuEventService.closeAllMenusEvent.emit();\n                }\n            });\n\n        this._tieredMenuEventService.openItemMenuEvent\n            .pipe(takeUntil(this._unsubscribe$))\n            .subscribe((item: TieredMenuItemInternalData | null) => {\n                if (item) {\n                    if (!this.tieredMenuService.currentItems.includes(item)) {\n                        let itemAux = this._lastOpenItem;\n\n                        while (itemAux?.parent?.parent) {\n                            itemAux = itemAux.parent;\n                        }\n\n                        this._tieredMenuEventService.closeItemMenuEvent.emit(itemAux?.parent ?? itemAux);\n                    }\n\n                    this._lastOpenItem = item;\n                    this._openItem(item);\n                }\n            });\n\n        this._tieredMenuEventService.closeItemMenuEvent\n            .pipe(takeUntil(this._unsubscribe$))\n            .subscribe((item: TieredMenuItemInternalData | null) => {\n                if (item) {\n                    this._closeItem(item);\n                }\n            });\n    }\n}\n","<div\n    class=\"menu menu--nested\"\n    [ngStyle]=\"{\n        top: top + 'px',\n        left: left + 'px',\n    }\"\n>\n    <ng-container\n        *ngTemplateOutlet=\"itemsTemplate; context: { $implicit: items }\"\n    ></ng-container>\n</div>\n\n<ng-template\n    #itemsTemplate\n    let-items\n>\n    @for (item of items; track item.id) {\n        <div>\n            @if (item.visible && !item.divider) {\n                <s-tiered-menu-item\n                    [item]=\"item\"\n                    [focused]=\"item === tieredMenuService.currentItem\"\n                    [closeOnClick]=\"true\"\n                >\n                </s-tiered-menu-item>\n            }\n            @if (item.divider) {\n                <s-tiered-menu-divider></s-tiered-menu-divider>\n            }\n            @if (item.submenu && item.isOpen) {\n                <div>\n                    <div class=\"submenu\">\n                        <ng-container\n                            *ngTemplateOutlet=\"\n                                itemsTemplate;\n                                context: { $implicit: item.submenu }\n                            \"\n                        ></ng-container>\n                    </div>\n                </div>\n            }\n        </div>\n    }\n</ng-template>\n"]}

package/esm2022/tiered-menu/lib/tiered-menu/models/index.mjs

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

package/esm2022/tiered-menu/lib/tiered-menu/models/tiered-menu-item-data.mjs

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

package/esm2022/tiered-menu/lib/tiered-menu/models/tiered-menu-item-internal-data.mjs

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

package/esm2022/tiered-menu/lib/tiered-menu/services/tiered-menu.event.service.mjs

@@ -0,0 +1,17 @@
+import { Injectable, EventEmitter } from '@angular/core';
+import * as i0 from "@angular/core";
+export class TieredMenuEventService {
+    incrementCurrentItemEvent = new EventEmitter();
+    decrementCurrentItemEvent = new EventEmitter();
+    closeAllMenusEvent = new EventEmitter();
+    selectItemEvent = new EventEmitter();
+    openItemMenuEvent = new EventEmitter();
+    closeItemMenuEvent = new EventEmitter();
+    createMenuEvent = new EventEmitter();
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: TieredMenuEventService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: TieredMenuEventService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: TieredMenuEventService, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGllcmVkLW1lbnUuZXZlbnQuc2VydmljZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2FuZ3VsYXItY29tcG9uZW50cy90aWVyZWQtbWVudS9zcmMvbGliL3RpZXJlZC1tZW51L3NlcnZpY2VzL3RpZXJlZC1tZW51LmV2ZW50LnNlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFVBQVUsRUFBRSxZQUFZLEVBQUUsTUFBTSxlQUFlLENBQUM7O0FBS3pELE1BQU0sT0FBTyxzQkFBc0I7SUFDeEIseUJBQXlCLEdBQUcsSUFBSSxZQUFZLEVBQUUsQ0FBQztJQUMvQyx5QkFBeUIsR0FBRyxJQUFJLFlBQVksRUFBRSxDQUFDO0lBQy9DLGtCQUFrQixHQUFHLElBQUksWUFBWSxFQUFFLENBQUM7SUFDeEMsZUFBZSxHQUNsQixJQUFJLFlBQVksRUFBcUMsQ0FBQztJQUNuRCxpQkFBaUIsR0FDcEIsSUFBSSxZQUFZLEVBQXFDLENBQUM7SUFDbkQsa0JBQWtCLEdBQ3JCLElBQUksWUFBWSxFQUFxQyxDQUFDO0lBQ25ELGVBQWUsR0FDbEIsSUFBSSxZQUFZLEVBQXFDLENBQUM7d0dBWGpELHNCQUFzQjs0R0FBdEIsc0JBQXNCOzs0RkFBdEIsc0JBQXNCO2tCQURsQyxVQUFVIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0YWJsZSwgRXZlbnRFbWl0dGVyIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5cbmltcG9ydCB7IFRpZXJlZE1lbnVJdGVtSW50ZXJuYWxEYXRhIH0gZnJvbSAnLi4vbW9kZWxzL3RpZXJlZC1tZW51LWl0ZW0taW50ZXJuYWwtZGF0YSc7XG5cbkBJbmplY3RhYmxlKClcbmV4cG9ydCBjbGFzcyBUaWVyZWRNZW51RXZlbnRTZXJ2aWNlIHtcbiAgICBwdWJsaWMgaW5jcmVtZW50Q3VycmVudEl0ZW1FdmVudCA9IG5ldyBFdmVudEVtaXR0ZXIoKTtcbiAgICBwdWJsaWMgZGVjcmVtZW50Q3VycmVudEl0ZW1FdmVudCA9IG5ldyBFdmVudEVtaXR0ZXIoKTtcbiAgICBwdWJsaWMgY2xvc2VBbGxNZW51c0V2ZW50ID0gbmV3IEV2ZW50RW1pdHRlcigpO1xuICAgIHB1YmxpYyBzZWxlY3RJdGVtRXZlbnQgPVxuICAgICAgICBuZXcgRXZlbnRFbWl0dGVyPFRpZXJlZE1lbnVJdGVtSW50ZXJuYWxEYXRhIHwgbnVsbD4oKTtcbiAgICBwdWJsaWMgb3Blbkl0ZW1NZW51RXZlbnQgPVxuICAgICAgICBuZXcgRXZlbnRFbWl0dGVyPFRpZXJlZE1lbnVJdGVtSW50ZXJuYWxEYXRhIHwgbnVsbD4oKTtcbiAgICBwdWJsaWMgY2xvc2VJdGVtTWVudUV2ZW50ID1cbiAgICAgICAgbmV3IEV2ZW50RW1pdHRlcjxUaWVyZWRNZW51SXRlbUludGVybmFsRGF0YSB8IG51bGw+KCk7XG4gICAgcHVibGljIGNyZWF0ZU1lbnVFdmVudCA9XG4gICAgICAgIG5ldyBFdmVudEVtaXR0ZXI8VGllcmVkTWVudUl0ZW1JbnRlcm5hbERhdGEgfCBudWxsPigpO1xufVxuIl19

package/esm2022/tiered-menu/lib/tiered-menu/services/tiered-menu.global.service.mjs

@@ -0,0 +1,11 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class TieredMenuGlobalService {
+    lastInstance;
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: TieredMenuGlobalService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: TieredMenuGlobalService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: TieredMenuGlobalService, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGllcmVkLW1lbnUuZ2xvYmFsLnNlcnZpY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9hbmd1bGFyLWNvbXBvbmVudHMvdGllcmVkLW1lbnUvc3JjL2xpYi90aWVyZWQtbWVudS9zZXJ2aWNlcy90aWVyZWQtbWVudS5nbG9iYWwuc2VydmljZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sZUFBZSxDQUFDOztBQUkzQyxNQUFNLE9BQU8sdUJBQXVCO0lBQ3pCLFlBQVksQ0FBOEI7d0dBRHhDLHVCQUF1Qjs0R0FBdkIsdUJBQXVCOzs0RkFBdkIsdUJBQXVCO2tCQURuQyxVQUFVIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0YWJsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgVGllcmVkTWVudURpcmVjdGl2ZSB9IGZyb20gJy4uL3RpZXJlZC1tZW51LmRpcmVjdGl2ZSc7XG5cbkBJbmplY3RhYmxlKClcbmV4cG9ydCBjbGFzcyBUaWVyZWRNZW51R2xvYmFsU2VydmljZSB7XG4gICAgcHVibGljIGxhc3RJbnN0YW5jZT86IFRpZXJlZE1lbnVEaXJlY3RpdmUgfCBudWxsO1xufVxuIl19

package/esm2022/tiered-menu/lib/tiered-menu/services/tiered-menu.service.mjs

@@ -0,0 +1,54 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class TieredMenuService {
+    currentItem = null;
+    currentItems = [];
+    items = [];
+    normalizeData(items, parent) {
+        return items.map((i) => {
+            const item = {
+                visible: true,
+                ...i,
+            };
+            if (item.submenu) {
+                item.submenu = this.normalizeData(item.submenu, item);
+            }
+            item.id = this._generateId();
+            item.parent = parent;
+            item.isOpen = false;
+            return item;
+        });
+    }
+    markAllItemsAsClosed(items) {
+        return items.map((i) => {
+            const item = { ...i };
+            if (item.submenu) {
+                item.submenu = this.markAllItemsAsClosed(item.submenu);
+            }
+            item.isOpen = false;
+            return item;
+        });
+    }
+    searchTheHierarchy(itemA, itemB) {
+        let item = itemB;
+        while (item) {
+            if (item === itemA) {
+                return true;
+            }
+            item = item.parent ?? null;
+        }
+        return false;
+    }
+    cloneItems(items) {
+        return JSON.parse(JSON.stringify(items));
+    }
+    _generateId() {
+        return `id-${Math.random().toString(36).substring(2, 9)}-${Math.random().toString(36).substring(2, 9)}-${Math.random().toString(36).substring(2, 9)}`;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: TieredMenuService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: TieredMenuService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: TieredMenuService, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/tiered-menu/lib/tiered-menu/tiered-menu.directive.mjs

@@ -0,0 +1,234 @@
+import { Directive, HostListener, Input, } from '@angular/core';
+import { Subject } from 'rxjs';
+import { takeUntil } from 'rxjs/operators';
+import { TieredMenuNestedComponent } from './components/tiered-menu-nested/tiered-menu-nested.component';
+import { TieredMenuComponent } from './components/tiered-menu/tiered-menu.component';
+import { TieredMenuEventService } from './services/tiered-menu.event.service';
+import { TieredMenuService } from './services/tiered-menu.service';
+import { enableScroll } from '@seniorsistemas/angular-components/utils';
+import * as i0 from "@angular/core";
+import * as i1 from "./services/tiered-menu.event.service";
+import * as i2 from "./services/tiered-menu.service";
+import * as i3 from "./services/tiered-menu.global.service";
+export class TieredMenuDirective {
+    _elementRef;
+    _appRef;
+    _componentFactoryResolver;
+    _injector;
+    _tieredMenuEventService;
+    _tieredMenuService;
+    _tieredMenuGlobalService;
+    _changeDetectorRef;
+    items = [];
+    focusedItem = undefined;
+    triggerEvent = 'click';
+    _componentRef = null;
+    _showTimeout;
+    _isNested = false;
+    _isOpen = false;
+    _unsubscribe$ = new Subject();
+    _lastActiveElement;
+    _previousItems = [];
+    _itemsAreValid;
+    _resizeObserver = new ResizeObserver(() => {
+        this._setMenuPosition();
+        this._componentRef?.hostView.detectChanges();
+    });
+    constructor(_elementRef, _appRef, _componentFactoryResolver, _injector, _tieredMenuEventService, _tieredMenuService, _tieredMenuGlobalService, _changeDetectorRef) {
+        this._elementRef = _elementRef;
+        this._appRef = _appRef;
+        this._componentFactoryResolver = _componentFactoryResolver;
+        this._injector = _injector;
+        this._tieredMenuEventService = _tieredMenuEventService;
+        this._tieredMenuService = _tieredMenuService;
+        this._tieredMenuGlobalService = _tieredMenuGlobalService;
+        this._changeDetectorRef = _changeDetectorRef;
+    }
+    ngOnInit() {
+        this._itemsAreValid = !!this.items?.length;
+        if (!this._itemsAreValid)
+            return;
+        this._subscribeEvents();
+    }
+    ngOnChanges() {
+        if (!this._itemsAreValid)
+            return;
+        if (!this._previousItems) {
+            this._previousItems = this._tieredMenuService.cloneItems(this.items);
+        }
+        let hasChanges = false;
+        if (this.items.length !== this._previousItems.length) {
+            hasChanges = true;
+        }
+        else {
+            for (let i = 0; i < this.items.length; i++) {
+                if (!this._compareItems(this.items[i], this._previousItems[i])) {
+                    hasChanges = true;
+                    break;
+                }
+            }
+        }
+        if (hasChanges) {
+            this._updateServiceItems();
+            this._changeDetectorRef.detectChanges();
+            this._rebuildMenu();
+        }
+        this._previousItems = this._tieredMenuService.cloneItems(this.items);
+    }
+    ngOnDestroy() {
+        if (!this._itemsAreValid)
+            return;
+        this._unsubscribe$.next();
+        this._unsubscribe$.complete();
+        this._destroy();
+    }
+    onClick(event) {
+        if (!this._itemsAreValid)
+            return;
+        if (this.triggerEvent === 'click' && !this._isOpen) {
+            this._lastActiveElement = document.activeElement;
+            this._createMenu();
+            event.preventDefault();
+            event.stopPropagation();
+        }
+    }
+    _createMenu() {
+        this._updateServiceItems();
+        if (!this._componentRef && this._tieredMenuService.items?.length > 0) {
+            this._tieredMenuGlobalService.lastInstance?._destroy();
+            this._tieredMenuGlobalService.lastInstance = this;
+            this._lastActiveElement?.blur();
+            this._isOpen = true;
+            this._isNested = document.body.clientWidth < 600;
+            this._isNested ? this._createNestedMenu() : this._createTieredMenu();
+        }
+    }
+    _createTieredMenu() {
+        if (!this._componentRef && this._tieredMenuService.items?.length > 0) {
+            this._componentRef = this._createComponent(TieredMenuComponent);
+            this._appRef.attachView(this._componentRef.hostView);
+            const domElem = this._componentRef.location.nativeElement;
+            document.body.appendChild(domElem);
+            this._setMenuComponentProperties();
+            this._componentRef.instance.destroyRequest.pipe(takeUntil(this._unsubscribe$)).subscribe(() => {
+                this._destroy();
+            });
+            this._setMenuPosition();
+        }
+    }
+    _createNestedMenu() {
+        if (!this._componentRef && this._tieredMenuService.items?.length > 0) {
+            const componentFactory = this._componentFactoryResolver.resolveComponentFactory(TieredMenuNestedComponent);
+            this._componentRef = componentFactory.create(this._injector);
+            this._appRef.attachView(this._componentRef.hostView);
+            const domElem = this._componentRef.hostView.rootNodes[0];
+            document.body.appendChild(domElem);
+            this._setMenuComponentProperties();
+            this._setMenuPosition();
+        }
+    }
+    _createComponent(componentClass) {
+        const componentFactory = this._componentFactoryResolver.resolveComponentFactory(componentClass);
+        const _componentRef = componentFactory.create(this._injector);
+        this._resizeObserver.observe(_componentRef.location.nativeElement.querySelector('.menu'));
+        _componentRef.onDestroy(() => {
+            this._resizeObserver.disconnect();
+        });
+        return _componentRef;
+    }
+    _destroy() {
+        if (this._componentRef) {
+            this._isOpen = false;
+            window.clearTimeout(this._showTimeout);
+            this._appRef.detachView(this._componentRef.hostView);
+            this._componentRef.destroy();
+            this._componentRef = null;
+            this._tieredMenuService.currentItems = this._tieredMenuService.items;
+            this._tieredMenuService.currentItem = this._tieredMenuService.items[0];
+            this._tieredMenuEventService.closeAllMenusEvent.emit();
+        }
+    }
+    _setMenuPosition() {
+        if (!this._componentRef) {
+            return;
+        }
+        this._changeDetectorRef.detectChanges();
+        const ITEM_HEIGHT = 37;
+        const ITEM_WIDTH = this._componentRef.location.nativeElement?.querySelector('.menu')?.clientWidth || 176;
+        const DIVIDER_HEIGHT = 5;
+        const PADDING = 8;
+        const MARGIN = 4;
+        this._componentRef.instance.top = 8;
+        let { bottom, left, right } = this._elementRef.nativeElement.getBoundingClientRect();
+        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);
+        const menuHeight = itemsCount * ITEM_HEIGHT + dividersCount * DIVIDER_HEIGHT + PADDING + MARGIN;
+        const rightFreeSpace = window.innerWidth - right;
+        const bottomFreeSpace = window.innerHeight - bottom;
+        this._componentRef.instance.top = bottom;
+        this._componentRef.instance.left = left;
+        if (bottomFreeSpace <= menuHeight) {
+            this._componentRef.instance.top = Math.max(scrollY + bottom - menuHeight, 0);
+        }
+        else {
+            this._componentRef.instance.top = window.scrollY + bottom + MARGIN;
+        }
+        if (rightFreeSpace > 176) {
+            this._componentRef.instance.left = window.scrollX + left;
+        }
+        else {
+            this._componentRef.instance.left = window.scrollX + right - ITEM_WIDTH;
+        }
+        if (this._isNested) {
+            this._componentRef.instance.left = MARGIN;
+        }
+    }
+    _setMenuComponentProperties() {
+        if (this._componentRef != null) {
+            this._componentRef.instance.items = this._tieredMenuService.items;
+        }
+    }
+    _subscribeEvents() {
+        this._tieredMenuEventService.closeAllMenusEvent.pipe(takeUntil(this._unsubscribe$)).subscribe(() => {
+            this._tieredMenuService.items = this._tieredMenuService.markAllItemsAsClosed(this._tieredMenuService.items);
+            this._destroy();
+            enableScroll();
+        });
+    }
+    _compareItems(item1, item2) {
+        return JSON.stringify(item1) === JSON.stringify(item2);
+    }
+    _rebuildMenu() {
+        this._destroy();
+    }
+    _updateServiceItems() {
+        this._tieredMenuService.items = this._tieredMenuService.normalizeData(this.items);
+        this._tieredMenuService.currentItems = this._tieredMenuService.items;
+        this._tieredMenuService.currentItem =
+            this._tieredMenuService.items.find((i) => i.label === this.focusedItem?.label) ??
+                this._tieredMenuService.items[0];
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: TieredMenuDirective, deps: [{ token: i0.ElementRef }, { token: i0.ApplicationRef }, { token: i0.ComponentFactoryResolver }, { token: i0.Injector }, { token: i1.TieredMenuEventService }, { token: i2.TieredMenuService }, { token: i3.TieredMenuGlobalService }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.14", type: TieredMenuDirective, selector: "[sTieredMenu]", inputs: { items: "items", focusedItem: "focusedItem", triggerEvent: "triggerEvent" }, host: { listeners: { "click": "onClick($event)" } }, providers: [TieredMenuEventService, TieredMenuService], usesOnChanges: true, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: TieredMenuDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[sTieredMenu]',
+                    providers: [TieredMenuEventService, TieredMenuService],
+                }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }, { type: i0.ApplicationRef }, { type: i0.ComponentFactoryResolver }, { type: i0.Injector }, { type: i1.TieredMenuEventService }, { type: i2.TieredMenuService }, { type: i3.TieredMenuGlobalService }, { type: i0.ChangeDetectorRef }], propDecorators: { items: [{
+                type: Input
+            }], focusedItem: [{
+                type: Input
+            }], triggerEvent: [{
+                type: Input
+            }], onClick: [{
+                type: HostListener,
+                args: ['click', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tiered-menu.directive.js","sourceRoot":"","sources":["../../../../../projects/angular-components/tiered-menu/src/lib/tiered-menu/tiered-menu.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n    ApplicationRef,\n    ChangeDetectorRef,\n    ComponentFactoryResolver,\n    ComponentRef,\n    Directive,\n    ElementRef,\n    EmbeddedViewRef,\n    HostListener,\n    Injector,\n    Input,\n    OnChanges,\n    OnDestroy,\n    OnInit,\n    Type,\n} from '@angular/core';\n\nimport { Subject } from 'rxjs';\nimport { takeUntil } from 'rxjs/operators';\n\nimport { TieredMenuNestedComponent } from './components/tiered-menu-nested/tiered-menu-nested.component';\nimport { TieredMenuComponent } from './components/tiered-menu/tiered-menu.component';\nimport { TieredMenuItemData } from './models/tiered-menu-item-data';\nimport { TieredMenuEventService } from './services/tiered-menu.event.service';\nimport { TieredMenuGlobalService } from './services/tiered-menu.global.service';\nimport { TieredMenuService } from './services/tiered-menu.service';\nimport { TieredMenuItemInternalData } from './models';\nimport { enableScroll } from '@seniorsistemas/angular-components/utils';\n\n@Directive({\n    selector: '[sTieredMenu]',\n    providers: [TieredMenuEventService, TieredMenuService],\n})\nexport class TieredMenuDirective implements OnInit, OnChanges, OnDestroy {\n    @Input()\n    public items: TieredMenuItemData[] = [];\n\n    @Input()\n    public focusedItem: TieredMenuItemData | undefined = undefined;\n\n    @Input()\n    public triggerEvent: 'click' | 'hover' = 'click';\n\n    private _componentRef: ComponentRef<any> | null = null;\n    private _showTimeout?: number;\n    private _isNested = false;\n    private _isOpen = false;\n    private _unsubscribe$ = new Subject<void>();\n    private _lastActiveElement?: Element;\n    private _previousItems: TieredMenuItemData[] = [];\n    private _itemsAreValid?: boolean;\n    private _resizeObserver = new ResizeObserver(() => {\n        this._setMenuPosition();\n        this._componentRef?.hostView.detectChanges();\n    });\n\n    constructor(\n        private readonly _elementRef: ElementRef,\n        private readonly _appRef: ApplicationRef,\n        private readonly _componentFactoryResolver: ComponentFactoryResolver,\n        private readonly _injector: Injector,\n        private readonly _tieredMenuEventService: TieredMenuEventService,\n        private readonly _tieredMenuService: TieredMenuService,\n        private readonly _tieredMenuGlobalService: TieredMenuGlobalService,\n        private readonly _changeDetectorRef: ChangeDetectorRef,\n    ) {}\n\n    public ngOnInit(): void {\n        this._itemsAreValid = !!this.items?.length;\n\n        if (!this._itemsAreValid) return;\n\n        this._subscribeEvents();\n    }\n\n    public ngOnChanges(): void {\n        if (!this._itemsAreValid) return;\n\n        if (!this._previousItems) {\n            this._previousItems = this._tieredMenuService.cloneItems(this.items);\n        }\n\n        let hasChanges = false;\n\n        if (this.items.length !== this._previousItems.length) {\n            hasChanges = true;\n        } else {\n            for (let i = 0; i < this.items.length; i++) {\n                if (!this._compareItems(this.items[i], this._previousItems[i])) {\n                    hasChanges = true;\n                    break;\n                }\n            }\n        }\n\n        if (hasChanges) {\n            this._updateServiceItems();\n            this._changeDetectorRef.detectChanges();\n            this._rebuildMenu();\n        }\n\n        this._previousItems = this._tieredMenuService.cloneItems(this.items);\n    }\n\n    public ngOnDestroy(): void {\n        if (!this._itemsAreValid) return;\n\n        this._unsubscribe$.next();\n        this._unsubscribe$.complete();\n\n        this._destroy();\n    }\n\n    @HostListener('click', ['$event'])\n    public onClick(event: MouseEvent): void {\n        if (!this._itemsAreValid) return;\n\n        if (this.triggerEvent === 'click' && !this._isOpen) {\n            this._lastActiveElement = document.activeElement as Element;\n            this._createMenu();\n            event.preventDefault();\n            event.stopPropagation();\n        }\n    }\n\n    private _createMenu(): void {\n        this._updateServiceItems();\n\n        if (!this._componentRef && this._tieredMenuService.items?.length > 0) {\n            this._tieredMenuGlobalService.lastInstance?._destroy();\n            this._tieredMenuGlobalService.lastInstance = this;\n\n            (this._lastActiveElement as HTMLElement)?.blur();\n            this._isOpen = true;\n            this._isNested = document.body.clientWidth < 600;\n\n            this._isNested ? this._createNestedMenu() : this._createTieredMenu();\n        }\n    }\n\n    private _createTieredMenu(): void {\n        if (!this._componentRef && this._tieredMenuService.items?.length > 0) {\n            this._componentRef = this._createComponent(TieredMenuComponent);\n            this._appRef.attachView(this._componentRef.hostView);\n            const domElem = this._componentRef.location.nativeElement as HTMLElement;\n            document.body.appendChild(domElem);\n            this._setMenuComponentProperties();\n            this._componentRef.instance.destroyRequest.pipe(takeUntil(this._unsubscribe$)).subscribe(() => {\n                this._destroy();\n            });\n\n            this._setMenuPosition();\n        }\n    }\n\n    private _createNestedMenu(): void {\n        if (!this._componentRef && this._tieredMenuService.items?.length > 0) {\n            const componentFactory = this._componentFactoryResolver.resolveComponentFactory(TieredMenuNestedComponent);\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            this._setMenuComponentProperties();\n            this._setMenuPosition();\n        }\n    }\n\n    private _createComponent<T>(componentClass: Type<T>) {\n        const componentFactory = this._componentFactoryResolver.resolveComponentFactory(componentClass);\n        const _componentRef = componentFactory.create(this._injector);\n        this._resizeObserver.observe(_componentRef.location.nativeElement.querySelector('.menu'));\n        _componentRef.onDestroy(() => {\n            this._resizeObserver.disconnect();\n        });\n        return _componentRef;\n    }\n\n    private _destroy(): void {\n        if (this._componentRef) {\n            this._isOpen = false;\n            window.clearTimeout(this._showTimeout);\n            this._appRef.detachView(this._componentRef.hostView);\n            this._componentRef.destroy();\n            this._componentRef = null;\n\n            this._tieredMenuService.currentItems = this._tieredMenuService.items;\n            this._tieredMenuService.currentItem = this._tieredMenuService.items[0];\n            this._tieredMenuEventService.closeAllMenusEvent.emit();\n        }\n    }\n\n    private _setMenuPosition(): void {\n        if (!this._componentRef) {\n            return;\n        }\n        this._changeDetectorRef.detectChanges();\n        const ITEM_HEIGHT = 37;\n        const ITEM_WIDTH =\n            (this._componentRef.location.nativeElement as HTMLElement)?.querySelector('.menu')?.clientWidth || 176;\n        const DIVIDER_HEIGHT = 5;\n        const PADDING = 8;\n        const MARGIN = 4;\n        this._componentRef.instance.top = 8;\n        let { bottom, left, right } = this._elementRef.nativeElement.getBoundingClientRect();\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        const menuHeight = itemsCount * ITEM_HEIGHT + dividersCount * DIVIDER_HEIGHT + PADDING + MARGIN;\n        const rightFreeSpace = window.innerWidth - right;\n        const bottomFreeSpace = window.innerHeight - bottom;\n\n        this._componentRef.instance.top = bottom;\n        this._componentRef.instance.left = left;\n\n        if (bottomFreeSpace <= menuHeight) {\n            this._componentRef.instance.top = Math.max(scrollY + bottom - menuHeight, 0);\n        } else {\n            this._componentRef.instance.top = window.scrollY + bottom + MARGIN;\n        }\n\n        if (rightFreeSpace > 176) {\n            this._componentRef.instance.left = window.scrollX + left;\n        } else {\n            this._componentRef.instance.left = window.scrollX + right - ITEM_WIDTH;\n        }\n\n        if (this._isNested) {\n            this._componentRef.instance.left = MARGIN;\n        }\n    }\n\n    private _setMenuComponentProperties(): void {\n        if (this._componentRef != null) {\n            this._componentRef.instance.items = this._tieredMenuService.items;\n        }\n    }\n\n    private _subscribeEvents(): void {\n        this._tieredMenuEventService.closeAllMenusEvent.pipe(takeUntil(this._unsubscribe$)).subscribe(() => {\n            this._tieredMenuService.items = this._tieredMenuService.markAllItemsAsClosed(this._tieredMenuService.items);\n            this._destroy();\n            enableScroll();\n        });\n    }\n\n    private _compareItems(item1: TieredMenuItemData, item2: TieredMenuItemData): boolean {\n        return JSON.stringify(item1) === JSON.stringify(item2);\n    }\n\n    private _rebuildMenu(): void {\n        this._destroy();\n    }\n\n    private _updateServiceItems(): void {\n        this._tieredMenuService.items = this._tieredMenuService.normalizeData(this.items);\n        this._tieredMenuService.currentItems = this._tieredMenuService.items;\n\n        this._tieredMenuService.currentItem =\n            this._tieredMenuService.items.find((i) => i.label === this.focusedItem?.label) ??\n            this._tieredMenuService.items[0];\n    }\n}\n"]}