@seniorsistemas/data-seniorx-core 2.3.0 → 3.0.0

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

@@ -0,0 +1,367 @@
+import { ApplicationRef, ChangeDetectionStrategy, ChangeDetectorRef, Component, HostListener, Injector, ViewEncapsulation, createComponent, inject } from '@angular/core';
+import { Subject, takeUntil } from 'rxjs';
+import { enableBodyScroll, disableBodyScroll } from '../../../../core/utils/body-scroll.util';
+import { TieredMenuEventService } from '../../services/tiered-menu.event.service';
+import { TieredMenuService } from '../../services/tiered-menu.service';
+import { TieredMenuDividerComponent } from '../tiered-menu-divider/tiered-menu-divider.component';
+import { TieredMenuItemComponent } from '../tiered-menu-item/tiered-menu-item.component';
+import * as i0 from "@angular/core";
+// Menu layout constants
+const TIERED_MENU_ITEM_HEIGHT = 37;
+const TIERED_MENU_DIVIDER_HEIGHT = 5;
+const TIERED_MENU_PADDING = 8;
+const TIERED_MENU_DEFAULT_WIDTH = 176;
+const TIERED_MENU_EXTRA_PADDING = 8;
+export class TieredMenuComponent {
+    appRef = inject(ApplicationRef);
+    injector = inject(Injector);
+    cdr = inject(ChangeDetectorRef);
+    tieredMenuService = inject(TieredMenuService);
+    eventService = inject(TieredMenuEventService);
+    ariaLabel;
+    items = [];
+    top = 0;
+    left = 0;
+    menuTriggerEvent = 'hover';
+    isSubmenu = false;
+    componentRef = null;
+    menuElement = null;
+    unsubscribe$ = new Subject();
+    onResize() {
+        this.eventService.closeAllMenusEvent.emit();
+    }
+    onDocumentClick(event) {
+        const target = event.target;
+        if (!(target instanceof Element)) {
+            this.eventService.closeAllMenusEvent.emit();
+            return;
+        }
+        const clickedInside = target.closest('sdc-tiered-menu-item') || target.closest('sdc-tiered-menu-divider');
+        if (!clickedInside) {
+            this.eventService.closeAllMenusEvent.emit();
+        }
+    }
+    onKeydownHandler(event) {
+        const currentItem = this.getCurrentNavigableItem();
+        const action = this.getKeydownAction(event, currentItem);
+        if (action) {
+            action();
+        }
+    }
+    ngOnInit() {
+        this.subscribeEvents();
+        if (!this.isSubmenu) {
+            this.tieredMenuService.items = this.items;
+            this.tieredMenuService.currentItems = this.items;
+            this.tieredMenuService.currentItem = this.items[0] ?? null;
+            disableBodyScroll();
+            requestAnimationFrame(() => this.focusCurrentItem());
+        }
+    }
+    ngOnDestroy() {
+        this.unsubscribe$.next();
+        this.unsubscribe$.complete();
+    }
+    focusCurrentItem() {
+        const id = this.tieredMenuService.currentItem?.id;
+        if (!id) {
+            return;
+        }
+        document.getElementById(id)?.focus();
+    }
+    incrementCurrentItem() {
+        if (!this.tieredMenuService.currentItem) {
+            this.tieredMenuService.currentItem = this.tieredMenuService.currentItems[0] ?? null;
+            return;
+        }
+        if (!this.items.includes(this.tieredMenuService.currentItem)) {
+            return;
+        }
+        let nextItem = this.tieredMenuService.currentItem;
+        let iterations = 0;
+        const maxIterations = this.tieredMenuService.currentItems.length;
+        do {
+            const currentIndex = this.tieredMenuService.currentItems.indexOf(nextItem) + 1;
+            nextItem =
+                currentIndex < this.tieredMenuService.currentItems.length
+                    ? this.tieredMenuService.currentItems[currentIndex]
+                    : this.tieredMenuService.currentItems[0];
+            iterations++;
+        } while (nextItem?.divider && iterations < maxIterations);
+        // Only update if we found a non-divider item
+        if (!nextItem?.divider) {
+            this.tieredMenuService.currentItem = nextItem;
+        }
+    }
+    decrementCurrentItem() {
+        if (!this.tieredMenuService.currentItem) {
+            this.tieredMenuService.currentItem = this.tieredMenuService.currentItems[0] ?? null;
+            return;
+        }
+        if (!this.items.includes(this.tieredMenuService.currentItem)) {
+            return;
+        }
+        let previousItem = this.tieredMenuService.currentItem;
+        let iterations = 0;
+        const maxIterations = this.tieredMenuService.currentItems.length;
+        do {
+            const currentIndex = this.tieredMenuService.currentItems.indexOf(previousItem) - 1;
+            previousItem =
+                currentIndex >= 0
+                    ? this.tieredMenuService.currentItems[currentIndex]
+                    : this.tieredMenuService.currentItems[this.tieredMenuService.currentItems.length - 1];
+            iterations++;
+        } while (previousItem?.divider && iterations < maxIterations);
+        // Only update if we found a non-divider item
+        if (!previousItem?.divider) {
+            this.tieredMenuService.currentItem = previousItem;
+        }
+    }
+    createMenu(items, position) {
+        if (this.componentRef || !items.length) {
+            return;
+        }
+        this.componentRef = createComponent(TieredMenuComponent, {
+            environmentInjector: this.appRef.injector,
+            elementInjector: this.injector
+        });
+        this.appRef.attachView(this.componentRef.hostView);
+        const hostElement = this.componentRef.location.nativeElement;
+        document.body.appendChild(hostElement);
+        this.componentRef.instance.items = items;
+        this.componentRef.instance.isSubmenu = true;
+        this.menuElement = hostElement.querySelector('.sdc-tiered-menu');
+        this.setMenuPosition(position);
+    }
+    destroy(propagate = true) {
+        if (this.componentRef) {
+            // Recursively destroy nested submenus before destroying this component,
+            // because componentRef.destroy() cancels subscriptions (ngOnDestroy), which
+            // would prevent the child from cleaning up its own submenus.
+            this.componentRef.instance.destroy(false);
+            this.appRef.detachView(this.componentRef.hostView);
+            this.componentRef.destroy();
+            this.componentRef = null;
+            this.menuElement = null;
+        }
+        if (propagate) {
+            this.eventService.closeAllMenusEvent.emit();
+        }
+    }
+    setMenuPosition(position) {
+        if (!this.componentRef) {
+            return;
+        }
+        const { top, right, bottom, left } = position;
+        const menuWidth = this.menuElement?.getBoundingClientRect().width ?? TIERED_MENU_DEFAULT_WIDTH;
+        const itemsCount = this.countMenuItems(false);
+        const dividersCount = this.countMenuItems(true);
+        const menuHeight = itemsCount * TIERED_MENU_ITEM_HEIGHT + dividersCount * TIERED_MENU_DIVIDER_HEIGHT + TIERED_MENU_PADDING + TIERED_MENU_EXTRA_PADDING;
+        this.setMenuHorizontalPosition(left, right, menuWidth);
+        this.setMenuVerticalPosition(top, bottom, menuHeight);
+    }
+    countMenuItems(isDivider) {
+        if (!this.componentRef) {
+            return 0;
+        }
+        return this.componentRef.instance.items.reduce((count, item) => (item.divider === isDivider ? count + 1 : count), 0);
+    }
+    setMenuHorizontalPosition(left, right, menuWidth) {
+        if (!this.componentRef) {
+            return;
+        }
+        this.componentRef.instance.left = this.hasSpaceOnRight(right, menuWidth) ? right : left - menuWidth;
+    }
+    setMenuVerticalPosition(top, bottom, menuHeight) {
+        if (!this.componentRef) {
+            return;
+        }
+        const hasSpaceAtBottom = this.hasSpaceAtBottom(bottom, menuHeight);
+        this.componentRef.instance.top = hasSpaceAtBottom ? window.scrollY + top : Math.max(window.innerHeight - menuHeight, window.scrollY);
+    }
+    hasSpaceOnRight(right, menuWidth) {
+        return window.innerWidth - right > menuWidth;
+    }
+    hasSpaceAtBottom(bottom, menuHeight) {
+        return window.innerHeight - bottom > menuHeight;
+    }
+    subscribeEvents() {
+        this.eventService.incrementCurrentItemEvent.pipe(takeUntil(this.unsubscribe$)).subscribe(() => {
+            this.incrementCurrentItem();
+            this.focusCurrentItem();
+        });
+        this.eventService.decrementCurrentItemEvent.pipe(takeUntil(this.unsubscribe$)).subscribe(() => {
+            this.decrementCurrentItem();
+            this.focusCurrentItem();
+        });
+        this.eventService.selectItemEvent.pipe(takeUntil(this.unsubscribe$)).subscribe((item) => {
+            if (!item) {
+                return;
+            }
+            if (item.submenu) {
+                this.eventService.openItemMenuEvent.emit(item);
+            }
+            else if (item.command) {
+                item.command();
+                this.eventService.closeAllMenusEvent.emit();
+            }
+            else {
+                this.eventService.closeAllMenusEvent.emit();
+            }
+        });
+        this.eventService.closeAllMenusEvent.pipe(takeUntil(this.unsubscribe$)).subscribe(() => {
+            this.destroy(false);
+            this.tieredMenuService.currentItem = null;
+            this.resetCurrentItems();
+            this.items = this.tieredMenuService.markAllItemsAsClosed(this.items);
+            this.tieredMenuService.items = this.tieredMenuService.markAllItemsAsClosed(this.tieredMenuService.items);
+            enableBodyScroll();
+            this.cdr.markForCheck();
+        });
+        this.eventService.openItemMenuEvent.pipe(takeUntil(this.unsubscribe$)).subscribe((item) => {
+            if (!item) {
+                return;
+            }
+            if (this.tieredMenuService.currentItem?.parent &&
+                item.parent &&
+                !this.tieredMenuService.searchTheHierarchy(this.tieredMenuService.currentItem.parent, item)) {
+                this.closeCurrentItemAncestors(item);
+            }
+            this.openItemSubmenu(item);
+        });
+        this.eventService.closeItemMenuEvent.pipe(takeUntil(this.unsubscribe$)).subscribe((item) => {
+            if (!item) {
+                return;
+            }
+            // Only process if this item belongs to the current menu or is an ancestor item
+            const isInCurrentItems = this.items.some((entry) => entry.id === item.id);
+            const isAncestorOfCurrentItem = this.tieredMenuService.currentItem &&
+                this.tieredMenuService.searchTheHierarchy(item, this.tieredMenuService.currentItem);
+            if (!isInCurrentItems && !isAncestorOfCurrentItem) {
+                return;
+            }
+            if (item.parent) {
+                item.parent.isOpen = false;
+            }
+            this.tieredMenuService.currentItems =
+                item.parent?.parent?.submenu ?? this.tieredMenuService.items;
+            this.tieredMenuService.currentItem = item.parent ?? null;
+            this.destroy(false);
+            requestAnimationFrame(() => this.focusCurrentItem());
+        });
+    }
+    closeCurrentItemAncestors(targetItem) {
+        let current = this.tieredMenuService.currentItem;
+        if (!current) {
+            return;
+        }
+        // Close ancestors by direct state mutation instead of emitting events to avoid re-entrancy
+        while (current && current.parent !== targetItem.parent) {
+            current.isOpen = false;
+            current = current.parent ?? null;
+        }
+        if (current) {
+            current.isOpen = false;
+        }
+        // Single change detection run after closing all ancestors
+        this.cdr.detectChanges();
+    }
+    openItemSubmenu(item) {
+        if (!item.submenu || item.isOpen || !this.items.includes(item)) {
+            return;
+        }
+        const itemElement = document.getElementById(item.id ?? '');
+        if (!itemElement) {
+            return;
+        }
+        this.createMenu(item.submenu, itemElement.getBoundingClientRect());
+        this.tieredMenuService.currentItems = item.submenu;
+        this.tieredMenuService.currentItem = item.submenu[0] ?? null;
+        item.isOpen = true;
+        requestAnimationFrame(() => this.focusCurrentItem());
+    }
+    getCurrentNavigableItem() {
+        const currentItem = this.tieredMenuService.currentItem;
+        if (!currentItem || !this.items.includes(currentItem)) {
+            return null;
+        }
+        return currentItem;
+    }
+    getKeydownAction(event, currentItem) {
+        switch (event.key) {
+            case 'Escape':
+                return () => this.closeAllMenus(event, true);
+            case 'Tab':
+                return () => this.closeAllMenus(event, false);
+            case ' ':
+            case 'Enter':
+                return () => this.selectCurrentItem(event, currentItem);
+            case 'ArrowUp':
+                return () => this.moveCurrentItem(event, false);
+            case 'ArrowDown':
+                return () => this.moveCurrentItem(event, true);
+            case 'ArrowLeft':
+                return () => this.closeCurrentItemMenu(event, currentItem);
+            case 'ArrowRight':
+                return () => this.openCurrentItemMenu(event, currentItem);
+            default:
+                return null;
+        }
+    }
+    resetCurrentItems() {
+        this.tieredMenuService.currentItems = this.tieredMenuService.items;
+    }
+    closeAllMenus(event, preventDefault) {
+        this.eventService.closeAllMenusEvent.emit();
+        if (preventDefault) {
+            event.preventDefault();
+        }
+    }
+    selectCurrentItem(event, currentItem) {
+        if (!currentItem || currentItem.disabled) {
+            return;
+        }
+        this.eventService.selectItemEvent.emit(currentItem);
+        event.preventDefault();
+    }
+    moveCurrentItem(event, increment) {
+        if (increment) {
+            this.eventService.incrementCurrentItemEvent.emit();
+        }
+        else {
+            this.eventService.decrementCurrentItemEvent.emit();
+        }
+        event.preventDefault();
+    }
+    closeCurrentItemMenu(event, currentItem) {
+        if (!currentItem) {
+            return;
+        }
+        this.eventService.closeItemMenuEvent.emit(currentItem);
+        this.cdr.detectChanges();
+        event.preventDefault();
+    }
+    openCurrentItemMenu(event, currentItem) {
+        if (!currentItem || currentItem.disabled) {
+            return;
+        }
+        this.eventService.openItemMenuEvent.emit(currentItem);
+        event.preventDefault();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: TieredMenuComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.14", type: TieredMenuComponent, isStandalone: true, selector: "sdc-tiered-menu", host: { listeners: { "window:resize": "onResize()", "document:click": "onDocumentClick($event)", "document:keydown": "onKeydownHandler($event)" } }, ngImport: i0, template: "<div\n  class=\"sdc-tiered-menu\"\n  role=\"menu\"\n  [attr.aria-label]=\"ariaLabel\"\n  [style.left.px]=\"left\"\n  [style.top.px]=\"top\"\n>\n  @for (item of items; track item.id) {\n  @if (item.visible && !item.divider) {\n  <sdc-tiered-menu-item\n    [item]=\"item\"\n    [focused]=\"item === tieredMenuService.currentItem\"\n    [highlight]=\"item.isOpen === true\"\n    [triggerEvent]=\"menuTriggerEvent\"\n    [closeOnClick]=\"false\"\n  ></sdc-tiered-menu-item>\n  }\n  @if (item.divider) {\n  <sdc-tiered-menu-divider></sdc-tiered-menu-divider>\n  }\n  }\n</div>\n", styles: [".sdc-tiered-menu{position:absolute;z-index:9999;display:inline-flex;flex-direction:column;min-width:11rem;max-height:100vh;padding:.25rem 0;overflow-y:auto;border:1px solid #ccc;border-radius:.375rem;background:#fff;box-shadow:0 2px 12px #0000001a}\n"], dependencies: [{ kind: "component", type: TieredMenuItemComponent, selector: "sdc-tiered-menu-item", inputs: ["item", "focused", "highlight", "triggerEvent", "closeOnClick"] }, { kind: "component", type: TieredMenuDividerComponent, selector: "sdc-tiered-menu-divider" }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: TieredMenuComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'sdc-tiered-menu', standalone: true, imports: [TieredMenuItemComponent, TieredMenuDividerComponent], changeDetection: ChangeDetectionStrategy.OnPush, encapsulation: ViewEncapsulation.Emulated, template: "<div\n  class=\"sdc-tiered-menu\"\n  role=\"menu\"\n  [attr.aria-label]=\"ariaLabel\"\n  [style.left.px]=\"left\"\n  [style.top.px]=\"top\"\n>\n  @for (item of items; track item.id) {\n  @if (item.visible && !item.divider) {\n  <sdc-tiered-menu-item\n    [item]=\"item\"\n    [focused]=\"item === tieredMenuService.currentItem\"\n    [highlight]=\"item.isOpen === true\"\n    [triggerEvent]=\"menuTriggerEvent\"\n    [closeOnClick]=\"false\"\n  ></sdc-tiered-menu-item>\n  }\n  @if (item.divider) {\n  <sdc-tiered-menu-divider></sdc-tiered-menu-divider>\n  }\n  }\n</div>\n", styles: [".sdc-tiered-menu{position:absolute;z-index:9999;display:inline-flex;flex-direction:column;min-width:11rem;max-height:100vh;padding:.25rem 0;overflow-y:auto;border:1px solid #ccc;border-radius:.375rem;background:#fff;box-shadow:0 2px 12px #0000001a}\n"] }]
+        }], 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.component.js","sourceRoot":"","sources":["../../../../../../../lib/src/features/tiered-menu/components/tiered-menu/tiered-menu.component.ts","../../../../../../../lib/src/features/tiered-menu/components/tiered-menu/tiered-menu.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\n  ApplicationRef,\n  ChangeDetectionStrategy,\n  ChangeDetectorRef,\n  Component,\n  ComponentRef,\n  HostListener,\n  Injector,\n  OnDestroy,\n  OnInit,\n  ViewEncapsulation,\n  createComponent,\n  inject\n} from '@angular/core';\nimport { Subject, takeUntil } from 'rxjs';\n\nimport { enableBodyScroll, disableBodyScroll } from '../../../../core/utils/body-scroll.util';\nimport type { TieredMenuItemInternalData, TieredMenuTriggerEvent } from '../../../../core/types/tiered-menu.type';\nimport { TieredMenuEventService } from '../../services/tiered-menu.event.service';\nimport { TieredMenuService } from '../../services/tiered-menu.service';\nimport { TieredMenuDividerComponent } from '../tiered-menu-divider/tiered-menu-divider.component';\nimport { TieredMenuItemComponent } from '../tiered-menu-item/tiered-menu-item.component';\n\n// Menu layout constants\nconst TIERED_MENU_ITEM_HEIGHT = 37;\nconst TIERED_MENU_DIVIDER_HEIGHT = 5;\nconst TIERED_MENU_PADDING = 8;\nconst TIERED_MENU_DEFAULT_WIDTH = 176;\nconst TIERED_MENU_EXTRA_PADDING = 8;\n\n@Component({\n  selector: 'sdc-tiered-menu',\n  standalone: true,\n  imports: [TieredMenuItemComponent, TieredMenuDividerComponent],\n  templateUrl: './tiered-menu.component.html',\n  styleUrls: ['./tiered-menu.component.scss'],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  encapsulation: ViewEncapsulation.Emulated\n})\nexport class TieredMenuComponent implements OnInit, OnDestroy {\n  private readonly appRef = inject(ApplicationRef);\n  private readonly injector = inject(Injector);\n  private readonly cdr = inject(ChangeDetectorRef);\n  readonly tieredMenuService = inject(TieredMenuService);\n  private readonly eventService = inject(TieredMenuEventService);\n\n  public ariaLabel?: string;\n  public items: TieredMenuItemInternalData[] = [];\n  public top = 0;\n  public left = 0;\n  public menuTriggerEvent: TieredMenuTriggerEvent = 'hover';\n  public isSubmenu = false;\n\n  private componentRef: ComponentRef<TieredMenuComponent> | null = null;\n  private menuElement: HTMLElement | null = null;\n  private readonly unsubscribe$ = new Subject<void>();\n\n  @HostListener('window:resize')\n  protected onResize(): void {\n    this.eventService.closeAllMenusEvent.emit();\n  }\n\n  @HostListener('document:click', ['$event'])\n  protected onDocumentClick(event: MouseEvent): void {\n    const target = event.target;\n\n    if (!(target instanceof Element)) {\n      this.eventService.closeAllMenusEvent.emit();\n      return;\n    }\n\n    const clickedInside = target.closest('sdc-tiered-menu-item') || target.closest('sdc-tiered-menu-divider');\n\n    if (!clickedInside) {\n      this.eventService.closeAllMenusEvent.emit();\n    }\n  }\n\n  @HostListener('document:keydown', ['$event'])\n  protected onKeydownHandler(event: KeyboardEvent): void {\n    const currentItem = this.getCurrentNavigableItem();\n\n    const action = this.getKeydownAction(event, currentItem);\n\n    if (action) {\n      action();\n    }\n  }\n\n  ngOnInit(): void {\n    this.subscribeEvents();\n\n    if (!this.isSubmenu) {\n      this.tieredMenuService.items = this.items;\n      this.tieredMenuService.currentItems = this.items;\n      this.tieredMenuService.currentItem = this.items[0] ?? null;\n      disableBodyScroll();\n      requestAnimationFrame(() => this.focusCurrentItem());\n    }\n  }\n\n  ngOnDestroy(): void {\n    this.unsubscribe$.next();\n    this.unsubscribe$.complete();\n  }\n\n  private focusCurrentItem(): void {\n    const id = this.tieredMenuService.currentItem?.id;\n    if (!id) {\n      return;\n    }\n\n    document.getElementById(id)?.focus();\n  }\n\n  private incrementCurrentItem(): void {\n    if (!this.tieredMenuService.currentItem) {\n      this.tieredMenuService.currentItem = this.tieredMenuService.currentItems[0] ?? null;\n      return;\n    }\n\n    if (!this.items.includes(this.tieredMenuService.currentItem)) {\n      return;\n    }\n\n    let nextItem = this.tieredMenuService.currentItem;\n    let iterations = 0;\n    const maxIterations = this.tieredMenuService.currentItems.length;\n\n    do {\n      const currentIndex = this.tieredMenuService.currentItems.indexOf(nextItem) + 1;\n      nextItem =\n        currentIndex < this.tieredMenuService.currentItems.length\n          ? this.tieredMenuService.currentItems[currentIndex]\n          : this.tieredMenuService.currentItems[0];\n      iterations++;\n    } while (nextItem?.divider && iterations < maxIterations);\n\n    // Only update if we found a non-divider item\n    if (!nextItem?.divider) {\n      this.tieredMenuService.currentItem = nextItem;\n    }\n  }\n\n  private decrementCurrentItem(): void {\n    if (!this.tieredMenuService.currentItem) {\n      this.tieredMenuService.currentItem = this.tieredMenuService.currentItems[0] ?? null;\n      return;\n    }\n\n    if (!this.items.includes(this.tieredMenuService.currentItem)) {\n      return;\n    }\n\n    let previousItem = this.tieredMenuService.currentItem;\n    let iterations = 0;\n    const maxIterations = this.tieredMenuService.currentItems.length;\n\n    do {\n      const currentIndex = this.tieredMenuService.currentItems.indexOf(previousItem) - 1;\n      previousItem =\n        currentIndex >= 0\n          ? this.tieredMenuService.currentItems[currentIndex]\n          : this.tieredMenuService.currentItems[this.tieredMenuService.currentItems.length - 1];\n      iterations++;\n    } while (previousItem?.divider && iterations < maxIterations);\n\n    // Only update if we found a non-divider item\n    if (!previousItem?.divider) {\n      this.tieredMenuService.currentItem = previousItem;\n    }\n  }\n\n  private createMenu(items: TieredMenuItemInternalData[], position: DOMRect): void {\n    if (this.componentRef || !items.length) {\n      return;\n    }\n\n    this.componentRef = createComponent(TieredMenuComponent, {\n      environmentInjector: this.appRef.injector,\n      elementInjector: this.injector\n    });\n    this.appRef.attachView(this.componentRef.hostView);\n\n    const hostElement = this.componentRef.location.nativeElement as HTMLElement;\n    document.body.appendChild(hostElement);\n\n    this.componentRef.instance.items = items;\n    this.componentRef.instance.isSubmenu = true;\n    this.menuElement = hostElement.querySelector('.sdc-tiered-menu');\n    this.setMenuPosition(position);\n  }\n\n  private destroy(propagate = true): void {\n    if (this.componentRef) {\n      // Recursively destroy nested submenus before destroying this component,\n      // because componentRef.destroy() cancels subscriptions (ngOnDestroy), which\n      // would prevent the child from cleaning up its own submenus.\n      this.componentRef.instance.destroy(false);\n\n      this.appRef.detachView(this.componentRef.hostView);\n      this.componentRef.destroy();\n      this.componentRef = null;\n      this.menuElement = null;\n    }\n\n    if (propagate) {\n      this.eventService.closeAllMenusEvent.emit();\n    }\n  }\n\n  private setMenuPosition(position: DOMRect): void {\n    if (!this.componentRef) {\n      return;\n    }\n\n    const { top, right, bottom, left } = position;\n    const menuWidth = this.menuElement?.getBoundingClientRect().width ?? TIERED_MENU_DEFAULT_WIDTH;\n    const itemsCount = this.countMenuItems(false);\n    const dividersCount = this.countMenuItems(true);\n    const menuHeight = itemsCount * TIERED_MENU_ITEM_HEIGHT + dividersCount * TIERED_MENU_DIVIDER_HEIGHT + TIERED_MENU_PADDING + TIERED_MENU_EXTRA_PADDING;\n\n    this.setMenuHorizontalPosition(left, right, menuWidth);\n    this.setMenuVerticalPosition(top, bottom, menuHeight);\n  }\n\n  private countMenuItems(isDivider: boolean): number {\n    if (!this.componentRef) {\n      return 0;\n    }\n\n    return this.componentRef.instance.items.reduce(\n      (count: number, item: TieredMenuItemInternalData) => (item.divider === isDivider ? count + 1 : count),\n      0\n    );\n  }\n\n  private setMenuHorizontalPosition(left: number, right: number, menuWidth: number): void {\n    if (!this.componentRef) {\n      return;\n    }\n\n    this.componentRef.instance.left = this.hasSpaceOnRight(right, menuWidth) ? right : left - menuWidth;\n  }\n\n  private setMenuVerticalPosition(top: number, bottom: number, menuHeight: number): void {\n    if (!this.componentRef) {\n      return;\n    }\n\n    const hasSpaceAtBottom = this.hasSpaceAtBottom(bottom, menuHeight);\n    this.componentRef.instance.top = hasSpaceAtBottom ? window.scrollY + top : Math.max(window.innerHeight - menuHeight, window.scrollY);\n  }\n\n  private hasSpaceOnRight(right: number, menuWidth: number): boolean {\n    return window.innerWidth - right > menuWidth;\n  }\n\n  private hasSpaceAtBottom(bottom: number, menuHeight: number): boolean {\n    return window.innerHeight - bottom > menuHeight;\n  }\n\n  private subscribeEvents(): void {\n    this.eventService.incrementCurrentItemEvent.pipe(takeUntil(this.unsubscribe$)).subscribe(() => {\n      this.incrementCurrentItem();\n      this.focusCurrentItem();\n    });\n\n    this.eventService.decrementCurrentItemEvent.pipe(takeUntil(this.unsubscribe$)).subscribe(() => {\n      this.decrementCurrentItem();\n      this.focusCurrentItem();\n    });\n\n    this.eventService.selectItemEvent.pipe(takeUntil(this.unsubscribe$)).subscribe((item) => {\n      if (!item) {\n        return;\n      }\n\n      if (item.submenu) {\n        this.eventService.openItemMenuEvent.emit(item);\n      } else if (item.command) {\n        item.command();\n        this.eventService.closeAllMenusEvent.emit();\n      } else {\n        this.eventService.closeAllMenusEvent.emit();\n      }\n    });\n\n    this.eventService.closeAllMenusEvent.pipe(takeUntil(this.unsubscribe$)).subscribe(() => {\n      this.destroy(false);\n      this.tieredMenuService.currentItem = null;\n      this.resetCurrentItems();\n      this.items = this.tieredMenuService.markAllItemsAsClosed(this.items);\n      this.tieredMenuService.items = this.tieredMenuService.markAllItemsAsClosed(\n        this.tieredMenuService.items\n      );\n      enableBodyScroll();\n      this.cdr.markForCheck();\n    });\n\n    this.eventService.openItemMenuEvent.pipe(takeUntil(this.unsubscribe$)).subscribe((item) => {\n      if (!item) {\n        return;\n      }\n\n      if (\n        this.tieredMenuService.currentItem?.parent &&\n        item.parent &&\n        !this.tieredMenuService.searchTheHierarchy(this.tieredMenuService.currentItem.parent, item)\n      ) {\n        this.closeCurrentItemAncestors(item);\n      }\n\n      this.openItemSubmenu(item);\n    });\n\n    this.eventService.closeItemMenuEvent.pipe(takeUntil(this.unsubscribe$)).subscribe((item) => {\n      if (!item) {\n        return;\n      }\n\n      // Only process if this item belongs to the current menu or is an ancestor item\n      const isInCurrentItems = this.items.some((entry) => entry.id === item.id);\n      const isAncestorOfCurrentItem = this.tieredMenuService.currentItem && \n        this.tieredMenuService.searchTheHierarchy(item, this.tieredMenuService.currentItem);\n\n      if (!isInCurrentItems && !isAncestorOfCurrentItem) {\n        return;\n      }\n\n      if (item.parent) {\n        item.parent.isOpen = false;\n      }\n\n      this.tieredMenuService.currentItems =\n        item.parent?.parent?.submenu ?? this.tieredMenuService.items;\n      this.tieredMenuService.currentItem = item.parent ?? null;\n      this.destroy(false);\n      requestAnimationFrame(() => this.focusCurrentItem());\n    });\n  }\n\n  private closeCurrentItemAncestors(targetItem: TieredMenuItemInternalData): void {\n    let current: TieredMenuItemInternalData | null = this.tieredMenuService.currentItem;\n    if (!current) {\n      return;\n    }\n\n    // Close ancestors by direct state mutation instead of emitting events to avoid re-entrancy\n    while (current && current.parent !== targetItem.parent) {\n      current.isOpen = false;\n      current = current.parent ?? null;\n    }\n\n    if (current) {\n      current.isOpen = false;\n    }\n\n    // Single change detection run after closing all ancestors\n    this.cdr.detectChanges();\n  }\n\n  private openItemSubmenu(item: TieredMenuItemInternalData): void {\n    if (!item.submenu || item.isOpen || !this.items.includes(item)) {\n      return;\n    }\n\n    const itemElement = document.getElementById(item.id ?? '');\n\n    if (!itemElement) {\n      return;\n    }\n\n    this.createMenu(item.submenu, itemElement.getBoundingClientRect());\n    this.tieredMenuService.currentItems = item.submenu;\n    this.tieredMenuService.currentItem = item.submenu[0] ?? null;\n    item.isOpen = true;\n    requestAnimationFrame(() => this.focusCurrentItem());\n  }\n\n  private getCurrentNavigableItem(): TieredMenuItemInternalData | null {\n    const currentItem = this.tieredMenuService.currentItem;\n\n    if (!currentItem || !this.items.includes(currentItem)) {\n      return null;\n    }\n\n    return currentItem;\n  }\n\n  private getKeydownAction(\n    event: KeyboardEvent,\n    currentItem: TieredMenuItemInternalData | null\n  ): (() => void) | null {\n    switch (event.key) {\n      case 'Escape':\n        return () => this.closeAllMenus(event, true);\n      case 'Tab':\n        return () => this.closeAllMenus(event, false);\n      case ' ':\n      case 'Enter':\n        return () => this.selectCurrentItem(event, currentItem);\n      case 'ArrowUp':\n        return () => this.moveCurrentItem(event, false);\n      case 'ArrowDown':\n        return () => this.moveCurrentItem(event, true);\n      case 'ArrowLeft':\n        return () => this.closeCurrentItemMenu(event, currentItem);\n      case 'ArrowRight':\n        return () => this.openCurrentItemMenu(event, currentItem);\n      default:\n        return null;\n    }\n  }\n\n  private resetCurrentItems(): void {\n    this.tieredMenuService.currentItems = this.tieredMenuService.items;\n  }\n\n  private closeAllMenus(event: KeyboardEvent, preventDefault: boolean): void {\n    this.eventService.closeAllMenusEvent.emit();\n\n    if (preventDefault) {\n      event.preventDefault();\n    }\n  }\n\n  private selectCurrentItem(\n    event: KeyboardEvent,\n    currentItem: TieredMenuItemInternalData | null\n  ): void {\n    if (!currentItem || currentItem.disabled) {\n      return;\n    }\n\n    this.eventService.selectItemEvent.emit(currentItem);\n    event.preventDefault();\n  }\n\n  private moveCurrentItem(event: KeyboardEvent, increment: boolean): void {\n    if (increment) {\n      this.eventService.incrementCurrentItemEvent.emit();\n    } else {\n      this.eventService.decrementCurrentItemEvent.emit();\n    }\n\n    event.preventDefault();\n  }\n\n  private closeCurrentItemMenu(\n    event: KeyboardEvent,\n    currentItem: TieredMenuItemInternalData | null\n  ): void {\n    if (!currentItem) {\n      return;\n    }\n\n    this.eventService.closeItemMenuEvent.emit(currentItem);\n    this.cdr.detectChanges();\n    event.preventDefault();\n  }\n\n  private openCurrentItemMenu(\n    event: KeyboardEvent,\n    currentItem: TieredMenuItemInternalData | null\n  ): void {\n    if (!currentItem || currentItem.disabled) {\n      return;\n    }\n\n    this.eventService.openItemMenuEvent.emit(currentItem);\n    event.preventDefault();\n  }\n}\n","<div\n  class=\"sdc-tiered-menu\"\n  role=\"menu\"\n  [attr.aria-label]=\"ariaLabel\"\n  [style.left.px]=\"left\"\n  [style.top.px]=\"top\"\n>\n  @for (item of items; track item.id) {\n  @if (item.visible && !item.divider) {\n  <sdc-tiered-menu-item\n    [item]=\"item\"\n    [focused]=\"item === tieredMenuService.currentItem\"\n    [highlight]=\"item.isOpen === true\"\n    [triggerEvent]=\"menuTriggerEvent\"\n    [closeOnClick]=\"false\"\n  ></sdc-tiered-menu-item>\n  }\n  @if (item.divider) {\n  <sdc-tiered-menu-divider></sdc-tiered-menu-divider>\n  }\n  }\n</div>\n"]}

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

@@ -0,0 +1,11 @@
+import { ChangeDetectionStrategy, Component, ViewEncapsulation } 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, isStandalone: true, selector: "sdc-tiered-menu-divider", ngImport: i0, template: "<div class=\"sdc-tiered-menu-divider\"></div>\n", styles: [".sdc-tiered-menu-divider{height:1px;margin:.125rem 0;background:#ccc}\n"], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: TieredMenuDividerComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'sdc-tiered-menu-divider', standalone: true, changeDetection: ChangeDetectionStrategy.OnPush, encapsulation: ViewEncapsulation.Emulated, template: "<div class=\"sdc-tiered-menu-divider\"></div>\n", styles: [".sdc-tiered-menu-divider{height:1px;margin:.125rem 0;background:#ccc}\n"] }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGllcmVkLW1lbnUtZGl2aWRlci5jb21wb25lbnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9saWIvc3JjL2ZlYXR1cmVzL3RpZXJlZC1tZW51L2NvbXBvbmVudHMvdGllcmVkLW1lbnUtZGl2aWRlci90aWVyZWQtbWVudS1kaXZpZGVyLmNvbXBvbmVudC50cyIsIi4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYi9zcmMvZmVhdHVyZXMvdGllcmVkLW1lbnUvY29tcG9uZW50cy90aWVyZWQtbWVudS1kaXZpZGVyL3RpZXJlZC1tZW51LWRpdmlkZXIuY29tcG9uZW50Lmh0bWwiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLHVCQUF1QixFQUFFLFNBQVMsRUFBRSxpQkFBaUIsRUFBRSxNQUFNLGVBQWUsQ0FBQzs7QUFVdEYsTUFBTSxPQUFPLDBCQUEwQjt3R0FBMUIsMEJBQTBCOzRGQUExQiwwQkFBMEIsbUZDVnZDLGlEQUNBOzs0RkRTYSwwQkFBMEI7a0JBUnRDLFNBQVM7K0JBQ0UseUJBQXlCLGNBQ3ZCLElBQUksbUJBR0MsdUJBQXVCLENBQUMsTUFBTSxpQkFDaEMsaUJBQWlCLENBQUMsUUFBUSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IENoYW5nZURldGVjdGlvblN0cmF0ZWd5LCBDb21wb25lbnQsIFZpZXdFbmNhcHN1bGF0aW9uIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5cbkBDb21wb25lbnQoe1xuICBzZWxlY3RvcjogJ3NkYy10aWVyZWQtbWVudS1kaXZpZGVyJyxcbiAgc3RhbmRhbG9uZTogdHJ1ZSxcbiAgdGVtcGxhdGVVcmw6ICcuL3RpZXJlZC1tZW51LWRpdmlkZXIuY29tcG9uZW50Lmh0bWwnLFxuICBzdHlsZVVybHM6IFsnLi90aWVyZWQtbWVudS1kaXZpZGVyLmNvbXBvbmVudC5zY3NzJ10sXG4gIGNoYW5nZURldGVjdGlvbjogQ2hhbmdlRGV0ZWN0aW9uU3RyYXRlZ3kuT25QdXNoLFxuICBlbmNhcHN1bGF0aW9uOiBWaWV3RW5jYXBzdWxhdGlvbi5FbXVsYXRlZFxufSlcbmV4cG9ydCBjbGFzcyBUaWVyZWRNZW51RGl2aWRlckNvbXBvbmVudCB7fVxuIiwiPGRpdiBjbGFzcz1cInNkYy10aWVyZWQtbWVudS1kaXZpZGVyXCI+PC9kaXY+XG4iXX0=

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

@@ -0,0 +1,97 @@
+import { CommonModule } from '@angular/common';
+import { ChangeDetectionStrategy, Component, HostListener, Input, ViewEncapsulation, inject } from '@angular/core';
+import { TIERED_MENU_SUBMENU_OPEN_DELAY_MS } from '../../../../core/constants/tiered-menu.const';
+import { TieredMenuEventService } from '../../services/tiered-menu.event.service';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+export class TieredMenuItemComponent {
+    eventService = inject(TieredMenuEventService);
+    item;
+    focused = false;
+    highlight = false;
+    triggerEvent = 'click';
+    closeOnClick = false;
+    showTimeoutId;
+    ngOnDestroy() {
+        window.clearTimeout(this.showTimeoutId);
+    }
+    onClick() {
+        if (this.item.disabled) {
+            return;
+        }
+        if (this.item.submenu) {
+            if (!this.item.isOpen) {
+                this.eventService.openItemMenuEvent.emit(this.item);
+            }
+            else if (this.closeOnClick) {
+                this.eventService.closeItemMenuEvent.emit(this.item);
+            }
+            else {
+                // submenu is open and closeOnClick is false, do nothing
+            }
+            return;
+        }
+        this.eventService.selectItemEvent.emit(this.item);
+    }
+    onTouchEnd(event) {
+        // Prevent synthetic click event from firing after touchend
+        event.preventDefault();
+        if (this.item.disabled) {
+            return;
+        }
+        if (this.item.submenu) {
+            if (!this.item.isOpen) {
+                this.eventService.openItemMenuEvent.emit(this.item);
+            }
+            else if (this.closeOnClick) {
+                this.eventService.closeItemMenuEvent.emit(this.item);
+            }
+            else {
+                // submenu is open and closeOnClick is false, do nothing
+            }
+            return;
+        }
+        this.eventService.selectItemEvent.emit(this.item);
+    }
+    onMouseEnter() {
+        if (this.item.disabled || this.triggerEvent !== 'hover' || this.item.isOpen) {
+            return;
+        }
+        this.showTimeoutId = window.setTimeout(() => {
+            this.eventService.openItemMenuEvent.emit(this.item);
+        }, TIERED_MENU_SUBMENU_OPEN_DELAY_MS);
+    }
+    onMouseLeave() {
+        window.clearTimeout(this.showTimeoutId);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: TieredMenuItemComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.14", type: TieredMenuItemComponent, isStandalone: true, selector: "sdc-tiered-menu-item", inputs: { item: "item", focused: "focused", highlight: "highlight", triggerEvent: "triggerEvent", closeOnClick: "closeOnClick" }, host: { listeners: { "click": "onClick()", "touchend": "onTouchEnd($event)", "mouseenter": "onMouseEnter()", "mouseleave": "onMouseLeave()" } }, ngImport: i0, template: "<div\n  class=\"sdc-tiered-menu-item\"\n  role=\"menuitem\"\n  [attr.id]=\"item.id\"\n  [tabindex]=\"focused && !item.disabled ? 0 : -1\"\n  [attr.aria-disabled]=\"item.disabled || null\"\n  [attr.aria-haspopup]=\"item.submenu ? 'menu' : null\"\n  [attr.aria-expanded]=\"item.submenu ? item.isOpen : null\"\n  [attr.data-key]=\"item.dataKey\"\n  [class.sdc-tiered-menu-item--open]=\"item.isOpen\"\n  [class.sdc-tiered-menu-item--focused]=\"focused\"\n  [class.sdc-tiered-menu-item--disabled]=\"item.disabled\"\n>\n  <span class=\"sdc-tiered-menu-item__content\">\n    <span\n      class=\"sdc-tiered-menu-item__icon\"\n      [ngClass]=\"item.iconClass\"\n    ></span>\n    <span class=\"sdc-tiered-menu-item__label\">{{ item.label }}</span>\n  </span>\n\n  @if (item.submenu) {\n  <span class=\"sdc-tiered-menu-item__submenu-icon fas\">\n    <i class=\"fas fa-chevron-right\"></i>\n  </span>\n  }\n</div>\n", styles: [".sdc-tiered-menu-item{display:flex;align-items:center;justify-content:space-between;padding:.5rem 1rem;cursor:pointer;-webkit-user-select:none;user-select:none}.sdc-tiered-menu-item:hover{background:#e9e6e6}.sdc-tiered-menu-item--focused{background:#ccc!important}.sdc-tiered-menu-item--open{background:#e4e2e2}.sdc-tiered-menu-item--disabled{opacity:.5;cursor:default}.sdc-tiered-menu-item__content{display:inline-flex;align-items:center}.sdc-tiered-menu-item__label{margin:0 .75rem}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: TieredMenuItemComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'sdc-tiered-menu-item', standalone: true, imports: [CommonModule], changeDetection: ChangeDetectionStrategy.OnPush, encapsulation: ViewEncapsulation.Emulated, template: "<div\n  class=\"sdc-tiered-menu-item\"\n  role=\"menuitem\"\n  [attr.id]=\"item.id\"\n  [tabindex]=\"focused && !item.disabled ? 0 : -1\"\n  [attr.aria-disabled]=\"item.disabled || null\"\n  [attr.aria-haspopup]=\"item.submenu ? 'menu' : null\"\n  [attr.aria-expanded]=\"item.submenu ? item.isOpen : null\"\n  [attr.data-key]=\"item.dataKey\"\n  [class.sdc-tiered-menu-item--open]=\"item.isOpen\"\n  [class.sdc-tiered-menu-item--focused]=\"focused\"\n  [class.sdc-tiered-menu-item--disabled]=\"item.disabled\"\n>\n  <span class=\"sdc-tiered-menu-item__content\">\n    <span\n      class=\"sdc-tiered-menu-item__icon\"\n      [ngClass]=\"item.iconClass\"\n    ></span>\n    <span class=\"sdc-tiered-menu-item__label\">{{ item.label }}</span>\n  </span>\n\n  @if (item.submenu) {\n  <span class=\"sdc-tiered-menu-item__submenu-icon fas\">\n    <i class=\"fas fa-chevron-right\"></i>\n  </span>\n  }\n</div>\n", styles: [".sdc-tiered-menu-item{display:flex;align-items:center;justify-content:space-between;padding:.5rem 1rem;cursor:pointer;-webkit-user-select:none;user-select:none}.sdc-tiered-menu-item:hover{background:#e9e6e6}.sdc-tiered-menu-item--focused{background:#ccc!important}.sdc-tiered-menu-item--open{background:#e4e2e2}.sdc-tiered-menu-item--disabled{opacity:.5;cursor:default}.sdc-tiered-menu-item__content{display:inline-flex;align-items:center}.sdc-tiered-menu-item__label{margin:0 .75rem}\n"] }]
+        }], propDecorators: { item: [{
+                type: Input,
+                args: [{ required: true }]
+            }], focused: [{
+                type: Input
+            }], highlight: [{
+                type: Input
+            }], triggerEvent: [{
+                type: Input
+            }], closeOnClick: [{
+                type: Input
+            }], onClick: [{
+                type: HostListener,
+                args: ['click']
+            }], onTouchEnd: [{
+                type: HostListener,
+                args: ['touchend', ['$event']]
+            }], onMouseEnter: [{
+                type: HostListener,
+                args: ['mouseenter']
+            }], onMouseLeave: [{
+                type: HostListener,
+                args: ['mouseleave']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tiered-menu-item.component.js","sourceRoot":"","sources":["../../../../../../../lib/src/features/tiered-menu/components/tiered-menu-item/tiered-menu-item.component.ts","../../../../../../../lib/src/features/tiered-menu/components/tiered-menu-item/tiered-menu-item.component.html"],"names":[],"mappings":"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","sourcesContent":["import { CommonModule } from '@angular/common';\nimport {\n  ChangeDetectionStrategy,\n  Component,\n  HostListener,\n  Input,\n  OnDestroy,\n  ViewEncapsulation,\n  inject\n} from '@angular/core';\n\nimport { TIERED_MENU_SUBMENU_OPEN_DELAY_MS } from '../../../../core/constants/tiered-menu.const';\nimport type {\n  TieredMenuItemInternalData,\n  TieredMenuTriggerEvent\n} from '../../../../core/types/tiered-menu.type';\nimport { TieredMenuEventService } from '../../services/tiered-menu.event.service';\n\n@Component({\n  selector: 'sdc-tiered-menu-item',\n  standalone: true,\n  imports: [CommonModule],\n  templateUrl: './tiered-menu-item.component.html',\n  styleUrls: ['./tiered-menu-item.component.scss'],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  encapsulation: ViewEncapsulation.Emulated\n})\nexport class TieredMenuItemComponent implements OnDestroy {\n  private readonly eventService = inject(TieredMenuEventService);\n\n  @Input({ required: true }) item!: TieredMenuItemInternalData;\n  @Input() focused = false;\n  @Input() highlight = false;\n  @Input() triggerEvent: TieredMenuTriggerEvent = 'click';\n  @Input() closeOnClick = false;\n\n  private showTimeoutId?: number;\n\n  ngOnDestroy(): void {\n    window.clearTimeout(this.showTimeoutId);\n  }\n\n  @HostListener('click')\n  protected onClick(): void {\n    if (this.item.disabled) {\n      return;\n    }\n\n    if (this.item.submenu) {\n      if (!this.item.isOpen) {\n        this.eventService.openItemMenuEvent.emit(this.item);\n      } else if (this.closeOnClick) {\n        this.eventService.closeItemMenuEvent.emit(this.item);\n      } else {\n        // submenu is open and closeOnClick is false, do nothing\n      }\n\n      return;\n    }\n\n    this.eventService.selectItemEvent.emit(this.item);\n  }\n\n  @HostListener('touchend', ['$event'])\n  protected onTouchEnd(event: TouchEvent): void {\n    // Prevent synthetic click event from firing after touchend\n    event.preventDefault();\n    \n    if (this.item.disabled) {\n      return;\n    }\n\n    if (this.item.submenu) {\n      if (!this.item.isOpen) {\n        this.eventService.openItemMenuEvent.emit(this.item);\n      } else if (this.closeOnClick) {\n        this.eventService.closeItemMenuEvent.emit(this.item);\n      } else {\n        // submenu is open and closeOnClick is false, do nothing\n      }\n\n      return;\n    }\n\n    this.eventService.selectItemEvent.emit(this.item);\n  }\n\n  @HostListener('mouseenter')\n  protected onMouseEnter(): void {\n    if (this.item.disabled || this.triggerEvent !== 'hover' || this.item.isOpen) {\n      return;\n    }\n\n    this.showTimeoutId = window.setTimeout(() => {\n      this.eventService.openItemMenuEvent.emit(this.item);\n    }, TIERED_MENU_SUBMENU_OPEN_DELAY_MS);\n  }\n\n  @HostListener('mouseleave')\n  protected onMouseLeave(): void {\n    window.clearTimeout(this.showTimeoutId);\n  }\n}\n","<div\n  class=\"sdc-tiered-menu-item\"\n  role=\"menuitem\"\n  [attr.id]=\"item.id\"\n  [tabindex]=\"focused && !item.disabled ? 0 : -1\"\n  [attr.aria-disabled]=\"item.disabled || null\"\n  [attr.aria-haspopup]=\"item.submenu ? 'menu' : null\"\n  [attr.aria-expanded]=\"item.submenu ? item.isOpen : null\"\n  [attr.data-key]=\"item.dataKey\"\n  [class.sdc-tiered-menu-item--open]=\"item.isOpen\"\n  [class.sdc-tiered-menu-item--focused]=\"focused\"\n  [class.sdc-tiered-menu-item--disabled]=\"item.disabled\"\n>\n  <span class=\"sdc-tiered-menu-item__content\">\n    <span\n      class=\"sdc-tiered-menu-item__icon\"\n      [ngClass]=\"item.iconClass\"\n    ></span>\n    <span class=\"sdc-tiered-menu-item__label\">{{ item.label }}</span>\n  </span>\n\n  @if (item.submenu) {\n  <span class=\"sdc-tiered-menu-item__submenu-icon fas\">\n    <i class=\"fas fa-chevron-right\"></i>\n  </span>\n  }\n</div>\n"]}