@seniorsistemas/data-seniorx-core 2.3.0 → 3.0.0

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

@@ -0,0 +1,181 @@
+import { CommonModule } from '@angular/common';
+import { ChangeDetectionStrategy, Component, HostListener, ViewEncapsulation, inject } from '@angular/core';
+import { Subject, takeUntil } from 'rxjs';
+import { 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";
+import * as i1 from "@angular/common";
+export class TieredMenuNestedComponent {
+    tieredMenuService = inject(TieredMenuService);
+    eventService = inject(TieredMenuEventService);
+    ariaLabel;
+    items = [];
+    top = 0;
+    left = 0;
+    lastOpenItem;
+    unsubscribe$ = new Subject();
+    onResize() {
+        this.eventService.closeAllMenusEvent.emit();
+    }
+    onDocumentClick(event) {
+        const target = event.target;
+        const clickedInside = target.closest('sdc-tiered-menu-item') || target.closest('sdc-tiered-menu-divider');
+        if (!clickedInside) {
+            this.eventService.closeAllMenusEvent.emit();
+        }
+    }
+    onKeydownHandler(event) {
+        switch (event.key) {
+            case 'Escape':
+                this.eventService.closeAllMenusEvent.emit();
+                break;
+            case ' ':
+            case 'Enter':
+                this.eventService.selectItemEvent.emit(this.tieredMenuService.currentItem);
+                break;
+            case 'ArrowLeft':
+                this.eventService.closeItemMenuEvent.emit(this.tieredMenuService.currentItem?.parent ?? null);
+                break;
+            case 'ArrowRight':
+                this.eventService.openItemMenuEvent.emit(this.tieredMenuService.currentItem);
+                break;
+            case 'ArrowUp':
+                this.eventService.decrementCurrentItemEvent.emit();
+                break;
+            case 'ArrowDown':
+                this.eventService.incrementCurrentItemEvent.emit();
+                break;
+            default:
+                // do nothing for other keys
+                break;
+        }
+    }
+    ngOnInit() {
+        this.tieredMenuService.currentItems = this.items;
+        this.subscribeEvents();
+        disableBodyScroll();
+    }
+    ngOnDestroy() {
+        this.unsubscribe$.next();
+        this.unsubscribe$.complete();
+        // Note: enableBodyScroll() should be called by the parent component that manages
+        // the overall menu lifecycle, not here. Calling it unconditionally in ngOnDestroy
+        // breaks when multiple menus are open (desktop + nested) as the first destruction
+        // would prematurely re-enable scroll for the remaining open menus.
+    }
+    incrementCurrentItem() {
+        if (!this.tieredMenuService.currentItem) {
+            this.tieredMenuService.currentItem = this.tieredMenuService.currentItems[0] ?? null;
+            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;
+        }
+        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;
+        }
+    }
+    closeItem(item) {
+        let current = this.lastOpenItem;
+        while (current && current !== item) {
+            current.isOpen = false;
+            current = current.parent;
+        }
+        item.isOpen = false;
+        this.tieredMenuService.currentItem = current ?? this.tieredMenuService.items[0] ?? null;
+        this.tieredMenuService.currentItems = current?.parent?.submenu ?? this.tieredMenuService.items;
+    }
+    openItem(item) {
+        if (!item.submenu) {
+            return;
+        }
+        item.isOpen = true;
+        this.tieredMenuService.currentItems = item.submenu;
+        if (this.tieredMenuService.currentItem) {
+            this.tieredMenuService.currentItem = item.submenu[0] ?? null;
+        }
+        this.lastOpenItem = item;
+    }
+    subscribeEvents() {
+        this.eventService.incrementCurrentItemEvent.pipe(takeUntil(this.unsubscribe$)).subscribe(() => {
+            this.incrementCurrentItem();
+        });
+        this.eventService.decrementCurrentItemEvent.pipe(takeUntil(this.unsubscribe$)).subscribe(() => {
+            this.decrementCurrentItem();
+        });
+        this.eventService.selectItemEvent.pipe(takeUntil(this.unsubscribe$)).subscribe((item) => {
+            if (item?.command) {
+                item.command();
+                this.eventService.closeAllMenusEvent.emit();
+            }
+        });
+        this.eventService.openItemMenuEvent.pipe(takeUntil(this.unsubscribe$)).subscribe((item) => {
+            if (!item) {
+                return;
+            }
+            if (!this.tieredMenuService.currentItems.includes(item)) {
+                let current = this.lastOpenItem;
+                while (current?.parent?.parent) {
+                    current = current.parent;
+                }
+                this.eventService.closeItemMenuEvent.emit(current?.parent ?? current ?? null);
+            }
+            this.lastOpenItem = item;
+            this.openItem(item);
+        });
+        this.eventService.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: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.14", type: TieredMenuNestedComponent, isStandalone: true, selector: "sdc-tiered-menu-nested", host: { listeners: { "window:resize": "onResize()", "document:click": "onDocumentClick($event)", "document:keydown": "onKeydownHandler($event)" } }, ngImport: i0, template: "<div\n  class=\"sdc-tiered-menu sdc-tiered-menu--nested\"\n  [attr.aria-label]=\"ariaLabel\"\n  [style.top.px]=\"top\"\n  [style.left.px]=\"left\"\n>\n  <ng-container\n    [ngTemplateOutlet]=\"itemsTemplate\"\n    [ngTemplateOutletContext]=\"{ $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    <sdc-tiered-menu-item\n      [item]=\"item\"\n      [focused]=\"item === tieredMenuService.currentItem\"\n      [closeOnClick]=\"true\"\n    ></sdc-tiered-menu-item>\n    }\n    @if (item.divider) {\n    <sdc-tiered-menu-divider></sdc-tiered-menu-divider>\n    }\n    @if (item.submenu && item.isOpen) {\n    <div class=\"sdc-tiered-menu--nested__submenu\">\n      <ng-container\n        [ngTemplateOutlet]=\"itemsTemplate\"\n        [ngTemplateOutletContext]=\"{ $implicit: item.submenu }\"\n      ></ng-container>\n    </div>\n    }\n  </div>\n  }\n</ng-template>\n", styles: [".sdc-tiered-menu{position:absolute;z-index:9999;display:inline-flex;flex-direction:column;width:calc(100vw - 8px);min-width:11rem;padding:.25rem 0;overflow:auto;border:1px solid #ccc;border-radius:.375rem;background:#fff;box-shadow:0 2px 12px #0000001a}.sdc-tiered-menu--nested__submenu{margin-left:1.5rem}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }, { 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: TieredMenuNestedComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'sdc-tiered-menu-nested', standalone: true, imports: [CommonModule, TieredMenuItemComponent, TieredMenuDividerComponent], changeDetection: ChangeDetectionStrategy.OnPush, encapsulation: ViewEncapsulation.Emulated, template: "<div\n  class=\"sdc-tiered-menu sdc-tiered-menu--nested\"\n  [attr.aria-label]=\"ariaLabel\"\n  [style.top.px]=\"top\"\n  [style.left.px]=\"left\"\n>\n  <ng-container\n    [ngTemplateOutlet]=\"itemsTemplate\"\n    [ngTemplateOutletContext]=\"{ $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    <sdc-tiered-menu-item\n      [item]=\"item\"\n      [focused]=\"item === tieredMenuService.currentItem\"\n      [closeOnClick]=\"true\"\n    ></sdc-tiered-menu-item>\n    }\n    @if (item.divider) {\n    <sdc-tiered-menu-divider></sdc-tiered-menu-divider>\n    }\n    @if (item.submenu && item.isOpen) {\n    <div class=\"sdc-tiered-menu--nested__submenu\">\n      <ng-container\n        [ngTemplateOutlet]=\"itemsTemplate\"\n        [ngTemplateOutletContext]=\"{ $implicit: item.submenu }\"\n      ></ng-container>\n    </div>\n    }\n  </div>\n  }\n</ng-template>\n", styles: [".sdc-tiered-menu{position:absolute;z-index:9999;display:inline-flex;flex-direction:column;width:calc(100vw - 8px);min-width:11rem;padding:.25rem 0;overflow:auto;border:1px solid #ccc;border-radius:.375rem;background:#fff;box-shadow:0 2px 12px #0000001a}.sdc-tiered-menu--nested__submenu{margin-left:1.5rem}\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-nested.component.js","sourceRoot":"","sources":["../../../../../../../lib/src/features/tiered-menu/components/tiered-menu-nested/tiered-menu-nested.component.ts","../../../../../../../lib/src/features/tiered-menu/components/tiered-menu-nested/tiered-menu-nested.component.html"],"names":[],"mappings":"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","sourcesContent":["import { CommonModule } from '@angular/common';\nimport {\n  ChangeDetectionStrategy,\n  Component,\n  HostListener,\n  OnDestroy,\n  OnInit,\n  ViewEncapsulation,\n  inject\n} from '@angular/core';\nimport { Subject, takeUntil } from 'rxjs';\n\nimport { disableBodyScroll, enableBodyScroll } from '../../../../core/utils/body-scroll.util';\nimport type { TieredMenuItemInternalData } 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@Component({\n  selector: 'sdc-tiered-menu-nested',\n  standalone: true,\n  imports: [CommonModule, TieredMenuItemComponent, TieredMenuDividerComponent],\n  templateUrl: './tiered-menu-nested.component.html',\n  styleUrls: ['./tiered-menu-nested.component.scss'],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  encapsulation: ViewEncapsulation.Emulated\n})\nexport class TieredMenuNestedComponent implements OnInit, OnDestroy {\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\n  private lastOpenItem?: TieredMenuItemInternalData;\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 as Element;\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    switch (event.key) {\n      case 'Escape':\n        this.eventService.closeAllMenusEvent.emit();\n        break;\n      case ' ':\n      case 'Enter':\n        this.eventService.selectItemEvent.emit(this.tieredMenuService.currentItem);\n        break;\n      case 'ArrowLeft':\n        this.eventService.closeItemMenuEvent.emit(this.tieredMenuService.currentItem?.parent ?? null);\n        break;\n      case 'ArrowRight':\n        this.eventService.openItemMenuEvent.emit(this.tieredMenuService.currentItem);\n        break;\n      case 'ArrowUp':\n        this.eventService.decrementCurrentItemEvent.emit();\n        break;\n      case 'ArrowDown':\n        this.eventService.incrementCurrentItemEvent.emit();\n        break;\n      default:\n        // do nothing for other keys\n        break;\n    }\n  }\n\n  ngOnInit(): void {\n    this.tieredMenuService.currentItems = this.items;\n    this.subscribeEvents();\n    disableBodyScroll();\n  }\n\n  ngOnDestroy(): void {\n    this.unsubscribe$.next();\n    this.unsubscribe$.complete();\n    // Note: enableBodyScroll() should be called by the parent component that manages\n    // the overall menu lifecycle, not here. Calling it unconditionally in ngOnDestroy\n    // breaks when multiple menus are open (desktop + nested) as the first destruction\n    // would prematurely re-enable scroll for the remaining open menus.\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    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    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 closeItem(item: TieredMenuItemInternalData): void {\n    let current = this.lastOpenItem;\n\n    while (current && current !== item) {\n      current.isOpen = false;\n      current = current.parent;\n    }\n\n    item.isOpen = false;\n    this.tieredMenuService.currentItem = current ?? this.tieredMenuService.items[0] ?? null;\n    this.tieredMenuService.currentItems = current?.parent?.submenu ?? this.tieredMenuService.items;\n  }\n\n  private openItem(item: TieredMenuItemInternalData): void {\n    if (!item.submenu) {\n      return;\n    }\n\n    item.isOpen = true;\n    this.tieredMenuService.currentItems = item.submenu;\n\n    if (this.tieredMenuService.currentItem) {\n      this.tieredMenuService.currentItem = item.submenu[0] ?? null;\n    }\n\n    this.lastOpenItem = item;\n  }\n\n  private subscribeEvents(): void {\n    this.eventService.incrementCurrentItemEvent.pipe(takeUntil(this.unsubscribe$)).subscribe(() => {\n      this.incrementCurrentItem();\n    });\n\n    this.eventService.decrementCurrentItemEvent.pipe(takeUntil(this.unsubscribe$)).subscribe(() => {\n      this.decrementCurrentItem();\n    });\n\n    this.eventService.selectItemEvent.pipe(takeUntil(this.unsubscribe$)).subscribe((item) => {\n      if (item?.command) {\n        item.command();\n        this.eventService.closeAllMenusEvent.emit();\n      }\n    });\n\n    this.eventService.openItemMenuEvent.pipe(takeUntil(this.unsubscribe$)).subscribe((item) => {\n      if (!item) {\n        return;\n      }\n\n      if (!this.tieredMenuService.currentItems.includes(item)) {\n        let current = this.lastOpenItem;\n\n        while (current?.parent?.parent) {\n          current = current.parent;\n        }\n\n        this.eventService.closeItemMenuEvent.emit(current?.parent ?? current ?? null);\n      }\n\n      this.lastOpenItem = item;\n      this.openItem(item);\n    });\n\n    this.eventService.closeItemMenuEvent.pipe(takeUntil(this.unsubscribe$)).subscribe((item) => {\n      if (item) {\n        this.closeItem(item);\n      }\n    });\n  }\n}\n","<div\n  class=\"sdc-tiered-menu sdc-tiered-menu--nested\"\n  [attr.aria-label]=\"ariaLabel\"\n  [style.top.px]=\"top\"\n  [style.left.px]=\"left\"\n>\n  <ng-container\n    [ngTemplateOutlet]=\"itemsTemplate\"\n    [ngTemplateOutletContext]=\"{ $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    <sdc-tiered-menu-item\n      [item]=\"item\"\n      [focused]=\"item === tieredMenuService.currentItem\"\n      [closeOnClick]=\"true\"\n    ></sdc-tiered-menu-item>\n    }\n    @if (item.divider) {\n    <sdc-tiered-menu-divider></sdc-tiered-menu-divider>\n    }\n    @if (item.submenu && item.isOpen) {\n    <div class=\"sdc-tiered-menu--nested__submenu\">\n      <ng-container\n        [ngTemplateOutlet]=\"itemsTemplate\"\n        [ngTemplateOutletContext]=\"{ $implicit: item.submenu }\"\n      ></ng-container>\n    </div>\n    }\n  </div>\n  }\n</ng-template>\n"]}

package/esm2022/features/tiered-menu/directives/tiered-menu.directive.mjs

@@ -0,0 +1,246 @@
+import { ApplicationRef, ChangeDetectorRef, Directive, ElementRef, EventEmitter, HostListener, Injector, Input, Output, createComponent, inject } from '@angular/core';
+import { Subject, takeUntil } from 'rxjs';
+import { TIERED_MENU_DEFAULT_TRIGGER_EVENT, TIERED_MENU_MOBILE_BREAKPOINT_PX } from '../../../core/constants/tiered-menu.const';
+import { enableBodyScroll } from '../../../core/utils/body-scroll.util';
+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 { TieredMenuGlobalService } from '../services/tiered-menu.global.service';
+import { TieredMenuService } from '../services/tiered-menu.service';
+import * as i0 from "@angular/core";
+const TIERED_MENU_DEFAULT_WIDTH = 176;
+const TIERED_MENU_ITEM_HEIGHT_DIRECTIVE = 37;
+const TIERED_MENU_DIVIDER_HEIGHT_DIRECTIVE = 5;
+const TIERED_MENU_PADDING_DIRECTIVE = 8;
+const TIERED_MENU_MARGIN = 4;
+export class TieredMenuDirective {
+    elementRef = inject((ElementRef));
+    appRef = inject(ApplicationRef);
+    injector = inject(Injector);
+    eventService = inject(TieredMenuEventService);
+    tieredMenuService = inject(TieredMenuService);
+    globalService = inject(TieredMenuGlobalService);
+    cdr = inject(ChangeDetectorRef);
+    items = [];
+    focusedItem;
+    triggerEvent = TIERED_MENU_DEFAULT_TRIGGER_EVENT;
+    ariaLabel;
+    tieredMenuOpened = new EventEmitter();
+    tieredMenuClosed = new EventEmitter();
+    set dataCoreItems(value) {
+        this.setItems(value);
+    }
+    set legacyItems(value) {
+        this.setItems(value);
+    }
+    setItems(value) {
+        if (value) {
+            this.items = value;
+        }
+    }
+    componentRef = null;
+    isNested = false;
+    isOpen = false;
+    unsubscribe$ = new Subject();
+    lastActiveElement;
+    itemsAreValid = false;
+    resizeObserver = new ResizeObserver(() => {
+        this.setMenuPosition();
+        this.componentRef?.hostView.detectChanges();
+    });
+    ngOnInit() {
+        this.itemsAreValid = !!this.items?.length;
+        if (!this.itemsAreValid) {
+            return;
+        }
+        this.subscribeEvents();
+    }
+    ngOnChanges(changes) {
+        if (!this.itemsAreValid) {
+            this.itemsAreValid = !!this.items?.length;
+            if (this.itemsAreValid) {
+                this.subscribeEvents();
+            }
+        }
+        if (!this.itemsAreValid) {
+            return;
+        }
+        if (changes['items']) {
+            this.updateServiceItems();
+            this.cdr.detectChanges();
+            this.rebuildMenu();
+        }
+    }
+    ngOnDestroy() {
+        this.unsubscribe$.next();
+        this.unsubscribe$.complete();
+        this.destroy();
+    }
+    onClick(event) {
+        if (!this.itemsAreValid || this.triggerEvent !== 'click' || this.isOpen) {
+            return;
+        }
+        this.lastActiveElement = document.activeElement;
+        this.createMenu();
+        event.preventDefault();
+        event.stopPropagation();
+    }
+    onMouseEnter() {
+        if (!this.itemsAreValid || this.triggerEvent !== 'hover' || this.isOpen) {
+            return;
+        }
+        this.lastActiveElement = document.activeElement;
+        this.createMenu();
+    }
+    createMenu() {
+        this.updateServiceItems();
+        if (this.componentRef || !this.tieredMenuService.items.length) {
+            return;
+        }
+        this.globalService.lastInstance?.destroy();
+        this.globalService.lastInstance = this;
+        this.lastActiveElement?.blur?.();
+        this.isOpen = true;
+        this.tieredMenuOpened.emit();
+        this.isNested = document.body.clientWidth < TIERED_MENU_MOBILE_BREAKPOINT_PX;
+        if (this.isNested) {
+            this.createNestedMenu();
+        }
+        else {
+            this.createTieredMenu();
+        }
+    }
+    createTieredMenu() {
+        this.componentRef = createComponent(TieredMenuComponent, {
+            environmentInjector: this.appRef.injector,
+            elementInjector: this.injector
+        });
+        this.appRef.attachView(this.componentRef.hostView);
+        document.body.appendChild(this.componentRef.location.nativeElement);
+        this.setMenuComponentProperties();
+        const menuElement = this.componentRef.location.nativeElement.querySelector('.sdc-tiered-menu');
+        if (menuElement) {
+            this.resizeObserver.observe(menuElement);
+        }
+        this.setMenuPosition();
+    }
+    createNestedMenu() {
+        this.componentRef = createComponent(TieredMenuNestedComponent, {
+            environmentInjector: this.appRef.injector,
+            elementInjector: this.injector
+        });
+        this.appRef.attachView(this.componentRef.hostView);
+        document.body.appendChild(this.componentRef.location.nativeElement);
+        this.setMenuComponentProperties();
+        this.setMenuPosition();
+    }
+    destroy() {
+        if (!this.componentRef) {
+            return;
+        }
+        this.isOpen = false;
+        this.tieredMenuClosed.emit();
+        this.appRef.detachView(this.componentRef.hostView);
+        this.componentRef.destroy();
+        this.componentRef = null;
+        this.resizeObserver.disconnect();
+        this.tieredMenuService.currentItems = this.tieredMenuService.items;
+        this.tieredMenuService.currentItem = this.tieredMenuService.items[0] ?? null;
+        // Restore focus to the element that was focused before opening the menu
+        enableBodyScroll();
+        this.lastActiveElement?.focus?.();
+    }
+    setMenuPosition() {
+        if (!this.componentRef) {
+            return;
+        }
+        const itemHeight = TIERED_MENU_ITEM_HEIGHT_DIRECTIVE;
+        const dividerHeight = TIERED_MENU_DIVIDER_HEIGHT_DIRECTIVE;
+        const padding = TIERED_MENU_PADDING_DIRECTIVE;
+        const margin = TIERED_MENU_MARGIN;
+        const menuElement = this.componentRef.location.nativeElement.querySelector('.sdc-tiered-menu');
+        const menuWidth = menuElement?.clientWidth ?? TIERED_MENU_DEFAULT_WIDTH;
+        const { bottom, left, right } = this.elementRef.nativeElement.getBoundingClientRect();
+        const itemsCount = this.tieredMenuService.items.reduce((count, item) => (!item.divider ? count + 1 : count), 0);
+        const dividersCount = this.tieredMenuService.items.reduce((count, item) => (item.divider ? count + 1 : count), 0);
+        const menuHeight = itemsCount * itemHeight + dividersCount * dividerHeight + padding + margin;
+        const rightFreeSpace = window.innerWidth - right;
+        const bottomFreeSpace = window.innerHeight - bottom;
+        this.componentRef.instance.top =
+            bottomFreeSpace <= menuHeight ? Math.max(window.scrollY + bottom - menuHeight, 0) : window.scrollY + bottom + margin;
+        this.componentRef.instance.left =
+            this.isNested || rightFreeSpace <= menuWidth ? window.scrollX + right - menuWidth : window.scrollX + left;
+        if (this.isNested) {
+            this.componentRef.instance.left = margin;
+        }
+    }
+    setMenuComponentProperties() {
+        if (!this.componentRef) {
+            return;
+        }
+        this.componentRef.instance.items = this.tieredMenuService.items;
+        this.componentRef.instance.ariaLabel = this.ariaLabel;
+        if (this.componentRef.instance instanceof TieredMenuComponent) {
+            this.componentRef.instance.menuTriggerEvent = this.triggerEvent;
+        }
+    }
+    subscribeEvents() {
+        this.eventService.closeAllMenusEvent.pipe(takeUntil(this.unsubscribe$)).subscribe(() => {
+            this.tieredMenuService.items = this.tieredMenuService.markAllItemsAsClosed(this.tieredMenuService.items);
+            this.destroy();
+            enableBodyScroll();
+        });
+    }
+    rebuildMenu() {
+        this.destroy();
+    }
+    updateServiceItems() {
+        this.tieredMenuService.items = this.tieredMenuService.normalizeData(this.items);
+        this.tieredMenuService.currentItems = this.tieredMenuService.items;
+        // Find the focused item by matching the original object reference or label (if no match found)
+        if (this.focusedItem) {
+            const focusedIndex = this.items.indexOf(this.focusedItem);
+            this.tieredMenuService.currentItem = focusedIndex >= 0 && focusedIndex < this.tieredMenuService.items.length
+                ? this.tieredMenuService.items[focusedIndex]
+                : this.tieredMenuService.items[0] ?? null;
+        }
+        else {
+            this.tieredMenuService.currentItem = this.tieredMenuService.items[0] ?? null;
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: TieredMenuDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.14", type: TieredMenuDirective, isStandalone: true, selector: "[sdcTieredMenu],[sTieredMenu]", inputs: { items: "items", focusedItem: "focusedItem", triggerEvent: "triggerEvent", ariaLabel: "ariaLabel", dataCoreItems: ["sdcTieredMenu", "dataCoreItems"], legacyItems: ["sTieredMenu", "legacyItems"] }, outputs: { tieredMenuOpened: "tieredMenuOpened", tieredMenuClosed: "tieredMenuClosed" }, host: { listeners: { "click": "onClick($event)", "mouseenter": "onMouseEnter()" } }, 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: '[sdcTieredMenu],[sTieredMenu]',
+                    standalone: true,
+                    providers: [TieredMenuEventService, TieredMenuService]
+                }]
+        }], propDecorators: { items: [{
+                type: Input
+            }], focusedItem: [{
+                type: Input
+            }], triggerEvent: [{
+                type: Input
+            }], ariaLabel: [{
+                type: Input
+            }], tieredMenuOpened: [{
+                type: Output
+            }], tieredMenuClosed: [{
+                type: Output
+            }], dataCoreItems: [{
+                type: Input,
+                args: ['sdcTieredMenu']
+            }], legacyItems: [{
+                type: Input,
+                args: ['sTieredMenu']
+            }], onClick: [{
+                type: HostListener,
+                args: ['click', ['$event']]
+            }], onMouseEnter: [{
+                type: HostListener,
+                args: ['mouseenter']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tiered-menu.directive.js","sourceRoot":"","sources":["../../../../../../lib/src/features/tiered-menu/directives/tiered-menu.directive.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,cAAc,EACd,iBAAiB,EAEjB,SAAS,EACT,UAAU,EACV,YAAY,EACZ,YAAY,EACZ,QAAQ,EACR,KAAK,EAIL,MAAM,EAEN,eAAe,EACf,MAAM,EACP,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,MAAM,CAAC;AAE1C,OAAO,EAAE,iCAAiC,EAAE,gCAAgC,EAAE,MAAM,2CAA2C,CAAC;AAChI,OAAO,EAAE,gBAAgB,EAAE,MAAM,sCAAsC,CAAC;AAMxE,OAAO,EAAE,yBAAyB,EAAE,MAAM,+DAA+D,CAAC;AAC1G,OAAO,EAAE,mBAAmB,EAAE,MAAM,iDAAiD,CAAC;AACtF,OAAO,EAAE,sBAAsB,EAAE,MAAM,uCAAuC,CAAC;AAC/E,OAAO,EAAE,uBAAuB,EAAE,MAAM,wCAAwC,CAAC;AACjF,OAAO,EAAE,iBAAiB,EAAE,MAAM,iCAAiC,CAAC;;AAEpE,MAAM,yBAAyB,GAAG,GAAG,CAAC;AACtC,MAAM,iCAAiC,GAAG,EAAE,CAAC;AAC7C,MAAM,oCAAoC,GAAG,CAAC,CAAC;AAC/C,MAAM,6BAA6B,GAAG,CAAC,CAAC;AACxC,MAAM,kBAAkB,GAAG,CAAC,CAAC;AAO7B,MAAM,OAAO,mBAAmB;IACb,UAAU,GAAG,MAAM,CAAC,CAAA,UAAuB,CAAA,CAAC,CAAC;IAC7C,MAAM,GAAG,MAAM,CAAC,cAAc,CAAC,CAAC;IAChC,QAAQ,GAAG,MAAM,CAAC,QAAQ,CAAC,CAAC;IAC5B,YAAY,GAAG,MAAM,CAAC,sBAAsB,CAAC,CAAC;IAC9C,iBAAiB,GAAG,MAAM,CAAC,iBAAiB,CAAC,CAAC;IAC9C,aAAa,GAAG,MAAM,CAAC,uBAAuB,CAAC,CAAC;IAChD,GAAG,GAAG,MAAM,CAAC,iBAAiB,CAAC,CAAC;IAG1C,KAAK,GAAyB,EAAE,CAAC;IAGjC,WAAW,CAAsB;IAGjC,YAAY,GAA2B,iCAA2D,CAAC;IAGnG,SAAS,CAAU;IAET,gBAAgB,GAAG,IAAI,YAAY,EAAQ,CAAC;IAC5C,gBAAgB,GAAG,IAAI,YAAY,EAAQ,CAAC;IAE7D,IACW,aAAa,CAAC,KAA8C;QACrE,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;IACvB,CAAC;IAED,IACW,WAAW,CAAC,KAA8C;QACnE,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;IACvB,CAAC;IAEO,QAAQ,CAAC,KAA8C;QAC7D,IAAI,KAAK,EAAE,CAAC;YACV,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;QACrB,CAAC;IACH,CAAC;IAEO,YAAY,GAAyE,IAAI,CAAC;IAC1F,QAAQ,GAAG,KAAK,CAAC;IACjB,MAAM,GAAG,KAAK,CAAC;IACN,YAAY,GAAG,IAAI,OAAO,EAAQ,CAAC;IAC5C,iBAAiB,CAAW;IAC5B,aAAa,GAAG,KAAK,CAAC;IACb,cAAc,GAAG,IAAI,cAAc,CAAC,GAAG,EAAE;QACxD,IAAI,CAAC,eAAe,EAAE,CAAC;QACvB,IAAI,CAAC,YAAY,EAAE,QAAQ,CAAC,aAAa,EAAE,CAAC;IAC9C,CAAC,CAAC,CAAC;IAEH,QAAQ;QACN,IAAI,CAAC,aAAa,GAAG,CAAC,CAAC,IAAI,CAAC,KAAK,EAAE,MAAM,CAAC;QAE1C,IAAI,CAAC,IAAI,CAAC,aAAa,EAAE,CAAC;YACxB,OAAO;QACT,CAAC;QAED,IAAI,CAAC,eAAe,EAAE,CAAC;IACzB,CAAC;IAED,WAAW,CAAC,OAAsB;QAChC,IAAI,CAAC,IAAI,CAAC,aAAa,EAAE,CAAC;YACxB,IAAI,CAAC,aAAa,GAAG,CAAC,CAAC,IAAI,CAAC,KAAK,EAAE,MAAM,CAAC;YAC1C,IAAI,IAAI,CAAC,aAAa,EAAE,CAAC;gBACvB,IAAI,CAAC,eAAe,EAAE,CAAC;YACzB,CAAC;QACH,CAAC;QAED,IAAI,CAAC,IAAI,CAAC,aAAa,EAAE,CAAC;YACxB,OAAO;QACT,CAAC;QAED,IAAI,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC;YACrB,IAAI,CAAC,kBAAkB,EAAE,CAAC;YAC1B,IAAI,CAAC,GAAG,CAAC,aAAa,EAAE,CAAC;YACzB,IAAI,CAAC,WAAW,EAAE,CAAC;QACrB,CAAC;IACH,CAAC;IAED,WAAW;QACT,IAAI,CAAC,YAAY,CAAC,IAAI,EAAE,CAAC;QACzB,IAAI,CAAC,YAAY,CAAC,QAAQ,EAAE,CAAC;QAC7B,IAAI,CAAC,OAAO,EAAE,CAAC;IACjB,CAAC;IAGS,OAAO,CAAC,KAAiB;QACjC,IAAI,CAAC,IAAI,CAAC,aAAa,IAAI,IAAI,CAAC,YAAY,KAAK,OAAO,IAAI,IAAI,CAAC,MAAM,EAAE,CAAC;YACxE,OAAO;QACT,CAAC;QAED,IAAI,CAAC,iBAAiB,GAAG,QAAQ,CAAC,aAAwB,CAAC;QAC3D,IAAI,CAAC,UAAU,EAAE,CAAC;QAClB,KAAK,CAAC,cAAc,EAAE,CAAC;QACvB,KAAK,CAAC,eAAe,EAAE,CAAC;IAC1B,CAAC;IAGS,YAAY;QACpB,IAAI,CAAC,IAAI,CAAC,aAAa,IAAI,IAAI,CAAC,YAAY,KAAK,OAAO,IAAI,IAAI,CAAC,MAAM,EAAE,CAAC;YACxE,OAAO;QACT,CAAC;QAED,IAAI,CAAC,iBAAiB,GAAG,QAAQ,CAAC,aAAwB,CAAC;QAC3D,IAAI,CAAC,UAAU,EAAE,CAAC;IACpB,CAAC;IAEO,UAAU;QAChB,IAAI,CAAC,kBAAkB,EAAE,CAAC;QAE1B,IAAI,IAAI,CAAC,YAAY,IAAI,CAAC,IAAI,CAAC,iBAAiB,CAAC,KAAK,CAAC,MAAM,EAAE,CAAC;YAC9D,OAAO;QACT,CAAC;QAED,IAAI,CAAC,aAAa,CAAC,YAAY,EAAE,OAAO,EAAE,CAAC;QAC3C,IAAI,CAAC,aAAa,CAAC,YAAY,GAAG,IAAI,CAAC;QACtC,IAAI,CAAC,iBAA6C,EAAE,IAAI,EAAE,EAAE,CAAC;QAC9D,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC;QACnB,IAAI,CAAC,gBAAgB,CAAC,IAAI,EAAE,CAAC;QAC7B,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC,IAAI,CAAC,WAAW,GAAG,gCAAgC,CAAC;QAE7E,IAAI,IAAI,CAAC,QAAQ,EAAE,CAAC;YAClB,IAAI,CAAC,gBAAgB,EAAE,CAAC;QAC1B,CAAC;aAAM,CAAC;YACN,IAAI,CAAC,gBAAgB,EAAE,CAAC;QAC1B,CAAC;IACH,CAAC;IAEO,gBAAgB;QACtB,IAAI,CAAC,YAAY,GAAG,eAAe,CAAC,mBAAmB,EAAE;YACvD,mBAAmB,EAAE,IAAI,CAAC,MAAM,CAAC,QAAQ;YACzC,eAAe,EAAE,IAAI,CAAC,QAAQ;SAC/B,CAAC,CAAC;QACH,IAAI,CAAC,MAAM,CAAC,UAAU,CAAC,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC,CAAC;QACnD,QAAQ,CAAC,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC,aAA4B,CAAC,CAAC;QACnF,IAAI,CAAC,0BAA0B,EAAE,CAAC;QAClC,MAAM,WAAW,GAAI,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC,aAA6B,CAAC,aAAa,CAAC,kBAAkB,CAAC,CAAC;QAChH,IAAI,WAAW,EAAE,CAAC;YAChB,IAAI,CAAC,cAAc,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC;QAC3C,CAAC;QACD,IAAI,CAAC,eAAe,EAAE,CAAC;IACzB,CAAC;IAEO,gBAAgB;QACtB,IAAI,CAAC,YAAY,GAAG,eAAe,CAAC,yBAAyB,EAAE;YAC7D,mBAAmB,EAAE,IAAI,CAAC,MAAM,CAAC,QAAQ;YACzC,eAAe,EAAE,IAAI,CAAC,QAAQ;SAC/B,CAAC,CAAC;QACH,IAAI,CAAC,MAAM,CAAC,UAAU,CAAC,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC,CAAC;QACnD,QAAQ,CAAC,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC,aAA4B,CAAC,CAAC;QACnF,IAAI,CAAC,0BAA0B,EAAE,CAAC;QAClC,IAAI,CAAC,eAAe,EAAE,CAAC;IACzB,CAAC;IAEM,OAAO;QACZ,IAAI,CAAC,IAAI,CAAC,YAAY,EAAE,CAAC;YACvB,OAAO;QACT,CAAC;QAED,IAAI,CAAC,MAAM,GAAG,KAAK,CAAC;QACpB,IAAI,CAAC,gBAAgB,CAAC,IAAI,EAAE,CAAC;QAC7B,IAAI,CAAC,MAAM,CAAC,UAAU,CAAC,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC,CAAC;QACnD,IAAI,CAAC,YAAY,CAAC,OAAO,EAAE,CAAC;QAC5B,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC;QACzB,IAAI,CAAC,cAAc,CAAC,UAAU,EAAE,CAAC;QACjC,IAAI,CAAC,iBAAiB,CAAC,YAAY,GAAG,IAAI,CAAC,iBAAiB,CAAC,KAAK,CAAC;QACnE,IAAI,CAAC,iBAAiB,CAAC,WAAW,GAAG,IAAI,CAAC,iBAAiB,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,IAAI,CAAC;QAE7E,wEAAwE;QACxE,gBAAgB,EAAE,CAAC;QAClB,IAAI,CAAC,iBAA6C,EAAE,KAAK,EAAE,EAAE,CAAC;IACjE,CAAC;IAEO,eAAe;QACrB,IAAI,CAAC,IAAI,CAAC,YAAY,EAAE,CAAC;YACvB,OAAO;QACT,CAAC;QAED,MAAM,UAAU,GAAG,iCAAiC,CAAC;QACrD,MAAM,aAAa,GAAG,oCAAoC,CAAC;QAC3D,MAAM,OAAO,GAAG,6BAA6B,CAAC;QAC9C,MAAM,MAAM,GAAG,kBAAkB,CAAC;QAClC,MAAM,WAAW,GAAI,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC,aAA6B,CAAC,aAAa,CAAC,kBAAkB,CAAC,CAAC;QAChH,MAAM,SAAS,GAAG,WAAW,EAAE,WAAW,IAAI,yBAAyB,CAAC;QACxE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,KAAK,EAAE,GAAG,IAAI,CAAC,UAAU,CAAC,aAAa,CAAC,qBAAqB,EAAE,CAAC;QACtF,MAAM,UAAU,GAAG,IAAI,CAAC,iBAAiB,CAAC,KAAK,CAAC,MAAM,CACpD,CAAC,KAAa,EAAE,IAAgC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,KAAK,GAAG,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,EACxF,CAAC,CACF,CAAC;QACF,MAAM,aAAa,GAAG,IAAI,CAAC,iBAAiB,CAAC,KAAK,CAAC,MAAM,CACvD,CAAC,KAAa,EAAE,IAAgC,EAAE,EAAE,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,KAAK,GAAG,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,EACvF,CAAC,CACF,CAAC;QACF,MAAM,UAAU,GAAG,UAAU,GAAG,UAAU,GAAG,aAAa,GAAG,aAAa,GAAG,OAAO,GAAG,MAAM,CAAC;QAC9F,MAAM,cAAc,GAAG,MAAM,CAAC,UAAU,GAAG,KAAK,CAAC;QACjD,MAAM,eAAe,GAAG,MAAM,CAAC,WAAW,GAAG,MAAM,CAAC;QAEpD,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC,GAAG;YAC5B,eAAe,IAAI,UAAU,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,OAAO,GAAG,MAAM,GAAG,UAAU,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,OAAO,GAAG,MAAM,GAAG,MAAM,CAAC;QACvH,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC,IAAI;YAC7B,IAAI,CAAC,QAAQ,IAAI,cAAc,IAAI,SAAS,CAAC,CAAC,CAAC,MAAM,CAAC,OAAO,GAAG,KAAK,GAAG,SAAS,CAAC,CAAC,CAAC,MAAM,CAAC,OAAO,GAAG,IAAI,CAAC;QAE5G,IAAI,IAAI,CAAC,QAAQ,EAAE,CAAC;YAClB,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC,IAAI,GAAG,MAAM,CAAC;QAC3C,CAAC;IACH,CAAC;IAEO,0BAA0B;QAChC,IAAI,CAAC,IAAI,CAAC,YAAY,EAAE,CAAC;YACvB,OAAO;QACT,CAAC;QAED,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC,KAAK,GAAG,IAAI,CAAC,iBAAiB,CAAC,KAAK,CAAC;QAChE,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC,SAAS,GAAG,IAAI,CAAC,SAAS,CAAC;QACtD,IAAI,IAAI,CAAC,YAAY,CAAC,QAAQ,YAAY,mBAAmB,EAAE,CAAC;YAC9D,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC,gBAAgB,GAAG,IAAI,CAAC,YAAY,CAAC;QAClE,CAAC;IACH,CAAC;IAEO,eAAe;QACrB,IAAI,CAAC,YAAY,CAAC,kBAAkB,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,SAAS,CAAC,GAAG,EAAE;YACrF,IAAI,CAAC,iBAAiB,CAAC,KAAK,GAAG,IAAI,CAAC,iBAAiB,CAAC,oBAAoB,CAAC,IAAI,CAAC,iBAAiB,CAAC,KAAK,CAAC,CAAC;YACzG,IAAI,CAAC,OAAO,EAAE,CAAC;YACf,gBAAgB,EAAE,CAAC;QACrB,CAAC,CAAC,CAAC;IACL,CAAC;IAEO,WAAW;QACjB,IAAI,CAAC,OAAO,EAAE,CAAC;IACjB,CAAC;IAEO,kBAAkB;QACxB,IAAI,CAAC,iBAAiB,CAAC,KAAK,GAAG,IAAI,CAAC,iBAAiB,CAAC,aAAa,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QAChF,IAAI,CAAC,iBAAiB,CAAC,YAAY,GAAG,IAAI,CAAC,iBAAiB,CAAC,KAAK,CAAC;QAEnE,+FAA+F;QAC/F,IAAI,IAAI,CAAC,WAAW,EAAE,CAAC;YACrB,MAAM,YAAY,GAAG,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;YAC1D,IAAI,CAAC,iBAAiB,CAAC,WAAW,GAAG,YAAY,IAAI,CAAC,IAAI,YAAY,GAAG,IAAI,CAAC,iBAAiB,CAAC,KAAK,CAAC,MAAM;gBAC1G,CAAC,CAAC,IAAI,CAAC,iBAAiB,CAAC,KAAK,CAAC,YAAY,CAAC;gBAC5C,CAAC,CAAC,IAAI,CAAC,iBAAiB,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,IAAI,CAAC;QAC9C,CAAC;aAAM,CAAC;YACN,IAAI,CAAC,iBAAiB,CAAC,WAAW,GAAG,IAAI,CAAC,iBAAiB,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,IAAI,CAAC;QAC/E,CAAC;IACH,CAAC;wGArPU,mBAAmB;4FAAnB,mBAAmB,wcAFnB,CAAC,sBAAsB,EAAE,iBAAiB,CAAC;;4FAE3C,mBAAmB;kBAL/B,SAAS;mBAAC;oBACT,QAAQ,EAAE,+BAA+B;oBACzC,UAAU,EAAE,IAAI;oBAChB,SAAS,EAAE,CAAC,sBAAsB,EAAE,iBAAiB,CAAC;iBACvD;8BAWQ,KAAK;sBADX,KAAK;gBAIC,WAAW;sBADjB,KAAK;gBAIC,YAAY;sBADlB,KAAK;gBAIC,SAAS;sBADf,KAAK;gBAGW,gBAAgB;sBAAhC,MAAM;gBACU,gBAAgB;sBAAhC,MAAM;gBAGI,aAAa;sBADvB,KAAK;uBAAC,eAAe;gBAMX,WAAW;sBADrB,KAAK;uBAAC,aAAa;gBA0DV,OAAO;sBADhB,YAAY;uBAAC,OAAO,EAAE,CAAC,QAAQ,CAAC;gBAavB,YAAY;sBADrB,YAAY;uBAAC,YAAY","sourcesContent":["import {\n  ApplicationRef,\n  ChangeDetectorRef,\n  ComponentRef,\n  Directive,\n  ElementRef,\n  EventEmitter,\n  HostListener,\n  Injector,\n  Input,\n  OnChanges,\n  OnDestroy,\n  OnInit,\n  Output,\n  SimpleChanges,\n  createComponent,\n  inject\n} from '@angular/core';\nimport { Subject, takeUntil } from 'rxjs';\n\nimport { TIERED_MENU_DEFAULT_TRIGGER_EVENT, TIERED_MENU_MOBILE_BREAKPOINT_PX } from '../../../core/constants/tiered-menu.const';\nimport { enableBodyScroll } from '../../../core/utils/body-scroll.util';\nimport type {\n  TieredMenuItemData,\n  TieredMenuItemInternalData,\n  TieredMenuTriggerEvent\n} from '../../../core/types/tiered-menu.type';\nimport { TieredMenuNestedComponent } from '../components/tiered-menu-nested/tiered-menu-nested.component';\nimport { TieredMenuComponent } from '../components/tiered-menu/tiered-menu.component';\nimport { TieredMenuEventService } from '../services/tiered-menu.event.service';\nimport { TieredMenuGlobalService } from '../services/tiered-menu.global.service';\nimport { TieredMenuService } from '../services/tiered-menu.service';\n\nconst TIERED_MENU_DEFAULT_WIDTH = 176;\nconst TIERED_MENU_ITEM_HEIGHT_DIRECTIVE = 37;\nconst TIERED_MENU_DIVIDER_HEIGHT_DIRECTIVE = 5;\nconst TIERED_MENU_PADDING_DIRECTIVE = 8;\nconst TIERED_MENU_MARGIN = 4;\n\n@Directive({\n  selector: '[sdcTieredMenu],[sTieredMenu]',\n  standalone: true,\n  providers: [TieredMenuEventService, TieredMenuService]\n})\nexport class TieredMenuDirective implements OnInit, OnChanges, OnDestroy {\n  private readonly elementRef = inject(ElementRef<HTMLElement>);\n  private readonly appRef = inject(ApplicationRef);\n  private readonly injector = inject(Injector);\n  private readonly eventService = inject(TieredMenuEventService);\n  private readonly tieredMenuService = inject(TieredMenuService);\n  private readonly globalService = inject(TieredMenuGlobalService);\n  private readonly cdr = inject(ChangeDetectorRef);\n\n  @Input()\n  public items: TieredMenuItemData[] = [];\n\n  @Input()\n  public focusedItem?: TieredMenuItemData;\n\n  @Input()\n  public triggerEvent: TieredMenuTriggerEvent = TIERED_MENU_DEFAULT_TRIGGER_EVENT as TieredMenuTriggerEvent;\n\n  @Input()\n  public ariaLabel?: string;\n\n  @Output() public tieredMenuOpened = new EventEmitter<void>();\n  @Output() public tieredMenuClosed = new EventEmitter<void>();\n\n  @Input('sdcTieredMenu')\n  public set dataCoreItems(value: TieredMenuItemData[] | null | undefined) {\n    this.setItems(value);\n  }\n\n  @Input('sTieredMenu')\n  public set legacyItems(value: TieredMenuItemData[] | null | undefined) {\n    this.setItems(value);\n  }\n\n  private setItems(value: TieredMenuItemData[] | null | undefined): void {\n    if (value) {\n      this.items = value;\n    }\n  }\n\n  private componentRef: ComponentRef<TieredMenuComponent | TieredMenuNestedComponent> | null = null;\n  private isNested = false;\n  private isOpen = false;\n  private readonly unsubscribe$ = new Subject<void>();\n  private lastActiveElement?: Element;\n  private itemsAreValid = false;\n  private readonly resizeObserver = new ResizeObserver(() => {\n    this.setMenuPosition();\n    this.componentRef?.hostView.detectChanges();\n  });\n\n  ngOnInit(): void {\n    this.itemsAreValid = !!this.items?.length;\n\n    if (!this.itemsAreValid) {\n      return;\n    }\n\n    this.subscribeEvents();\n  }\n\n  ngOnChanges(changes: SimpleChanges): void {\n    if (!this.itemsAreValid) {\n      this.itemsAreValid = !!this.items?.length;\n      if (this.itemsAreValid) {\n        this.subscribeEvents();\n      }\n    }\n\n    if (!this.itemsAreValid) {\n      return;\n    }\n\n    if (changes['items']) {\n      this.updateServiceItems();\n      this.cdr.detectChanges();\n      this.rebuildMenu();\n    }\n  }\n\n  ngOnDestroy(): void {\n    this.unsubscribe$.next();\n    this.unsubscribe$.complete();\n    this.destroy();\n  }\n\n  @HostListener('click', ['$event'])\n  protected onClick(event: MouseEvent): void {\n    if (!this.itemsAreValid || this.triggerEvent !== 'click' || this.isOpen) {\n      return;\n    }\n\n    this.lastActiveElement = document.activeElement as Element;\n    this.createMenu();\n    event.preventDefault();\n    event.stopPropagation();\n  }\n\n  @HostListener('mouseenter')\n  protected onMouseEnter(): void {\n    if (!this.itemsAreValid || this.triggerEvent !== 'hover' || this.isOpen) {\n      return;\n    }\n\n    this.lastActiveElement = document.activeElement as Element;\n    this.createMenu();\n  }\n\n  private createMenu(): void {\n    this.updateServiceItems();\n\n    if (this.componentRef || !this.tieredMenuService.items.length) {\n      return;\n    }\n\n    this.globalService.lastInstance?.destroy();\n    this.globalService.lastInstance = this;\n    (this.lastActiveElement as HTMLElement | undefined)?.blur?.();\n    this.isOpen = true;\n    this.tieredMenuOpened.emit();\n    this.isNested = document.body.clientWidth < TIERED_MENU_MOBILE_BREAKPOINT_PX;\n\n    if (this.isNested) {\n      this.createNestedMenu();\n    } else {\n      this.createTieredMenu();\n    }\n  }\n\n  private createTieredMenu(): void {\n    this.componentRef = createComponent(TieredMenuComponent, {\n      environmentInjector: this.appRef.injector,\n      elementInjector: this.injector\n    });\n    this.appRef.attachView(this.componentRef.hostView);\n    document.body.appendChild(this.componentRef.location.nativeElement as HTMLElement);\n    this.setMenuComponentProperties();\n    const menuElement = (this.componentRef.location.nativeElement as HTMLElement).querySelector('.sdc-tiered-menu');\n    if (menuElement) {\n      this.resizeObserver.observe(menuElement);\n    }\n    this.setMenuPosition();\n  }\n\n  private createNestedMenu(): void {\n    this.componentRef = createComponent(TieredMenuNestedComponent, {\n      environmentInjector: this.appRef.injector,\n      elementInjector: this.injector\n    });\n    this.appRef.attachView(this.componentRef.hostView);\n    document.body.appendChild(this.componentRef.location.nativeElement as HTMLElement);\n    this.setMenuComponentProperties();\n    this.setMenuPosition();\n  }\n\n  public destroy(): void {\n    if (!this.componentRef) {\n      return;\n    }\n\n    this.isOpen = false;\n    this.tieredMenuClosed.emit();\n    this.appRef.detachView(this.componentRef.hostView);\n    this.componentRef.destroy();\n    this.componentRef = null;\n    this.resizeObserver.disconnect();\n    this.tieredMenuService.currentItems = this.tieredMenuService.items;\n    this.tieredMenuService.currentItem = this.tieredMenuService.items[0] ?? null;\n    \n    // Restore focus to the element that was focused before opening the menu\n    enableBodyScroll();\n    (this.lastActiveElement as HTMLElement | undefined)?.focus?.();\n  }\n\n  private setMenuPosition(): void {\n    if (!this.componentRef) {\n      return;\n    }\n\n    const itemHeight = TIERED_MENU_ITEM_HEIGHT_DIRECTIVE;\n    const dividerHeight = TIERED_MENU_DIVIDER_HEIGHT_DIRECTIVE;\n    const padding = TIERED_MENU_PADDING_DIRECTIVE;\n    const margin = TIERED_MENU_MARGIN;\n    const menuElement = (this.componentRef.location.nativeElement as HTMLElement).querySelector('.sdc-tiered-menu');\n    const menuWidth = menuElement?.clientWidth ?? TIERED_MENU_DEFAULT_WIDTH;\n    const { bottom, left, right } = this.elementRef.nativeElement.getBoundingClientRect();\n    const itemsCount = this.tieredMenuService.items.reduce(\n      (count: number, item: TieredMenuItemInternalData) => (!item.divider ? count + 1 : count),\n      0\n    );\n    const dividersCount = this.tieredMenuService.items.reduce(\n      (count: number, item: TieredMenuItemInternalData) => (item.divider ? count + 1 : count),\n      0\n    );\n    const menuHeight = itemsCount * itemHeight + dividersCount * dividerHeight + padding + margin;\n    const rightFreeSpace = window.innerWidth - right;\n    const bottomFreeSpace = window.innerHeight - bottom;\n\n    this.componentRef.instance.top =\n      bottomFreeSpace <= menuHeight ? Math.max(window.scrollY + bottom - menuHeight, 0) : window.scrollY + bottom + margin;\n    this.componentRef.instance.left =\n      this.isNested || rightFreeSpace <= menuWidth ? window.scrollX + right - menuWidth : window.scrollX + left;\n\n    if (this.isNested) {\n      this.componentRef.instance.left = margin;\n    }\n  }\n\n  private setMenuComponentProperties(): void {\n    if (!this.componentRef) {\n      return;\n    }\n\n    this.componentRef.instance.items = this.tieredMenuService.items;\n    this.componentRef.instance.ariaLabel = this.ariaLabel;\n    if (this.componentRef.instance instanceof TieredMenuComponent) {\n      this.componentRef.instance.menuTriggerEvent = this.triggerEvent;\n    }\n  }\n\n  private subscribeEvents(): void {\n    this.eventService.closeAllMenusEvent.pipe(takeUntil(this.unsubscribe$)).subscribe(() => {\n      this.tieredMenuService.items = this.tieredMenuService.markAllItemsAsClosed(this.tieredMenuService.items);\n      this.destroy();\n      enableBodyScroll();\n    });\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    // Find the focused item by matching the original object reference or label (if no match found)\n    if (this.focusedItem) {\n      const focusedIndex = this.items.indexOf(this.focusedItem);\n      this.tieredMenuService.currentItem = focusedIndex >= 0 && focusedIndex < this.tieredMenuService.items.length\n        ? this.tieredMenuService.items[focusedIndex]\n        : this.tieredMenuService.items[0] ?? null;\n    } else {\n      this.tieredMenuService.currentItem = this.tieredMenuService.items[0] ?? null;\n    }\n  }\n}\n"]}

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

@@ -0,0 +1,16 @@
+import { EventEmitter, Injectable } 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();
+    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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGllcmVkLW1lbnUuZXZlbnQuc2VydmljZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL2xpYi9zcmMvZmVhdHVyZXMvdGllcmVkLW1lbnUvc2VydmljZXMvdGllcmVkLW1lbnUuZXZlbnQuc2VydmljZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsWUFBWSxFQUFFLFVBQVUsRUFBRSxNQUFNLGVBQWUsQ0FBQzs7QUFLekQsTUFBTSxPQUFPLHNCQUFzQjtJQUMxQix5QkFBeUIsR0FBRyxJQUFJLFlBQVksRUFBUSxDQUFDO0lBQ3JELHlCQUF5QixHQUFHLElBQUksWUFBWSxFQUFRLENBQUM7SUFDckQsa0JBQWtCLEdBQUcsSUFBSSxZQUFZLEVBQVEsQ0FBQztJQUM5QyxlQUFlLEdBQUcsSUFBSSxZQUFZLEVBQXFDLENBQUM7SUFDeEUsaUJBQWlCLEdBQUcsSUFBSSxZQUFZLEVBQXFDLENBQUM7SUFDMUUsa0JBQWtCLEdBQUcsSUFBSSxZQUFZLEVBQXFDLENBQUM7d0dBTnZFLHNCQUFzQjs0R0FBdEIsc0JBQXNCOzs0RkFBdEIsc0JBQXNCO2tCQURsQyxVQUFVIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgRXZlbnRFbWl0dGVyLCBJbmplY3RhYmxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5cbmltcG9ydCB0eXBlIHsgVGllcmVkTWVudUl0ZW1JbnRlcm5hbERhdGEgfSBmcm9tICcuLi8uLi8uLi9jb3JlL3R5cGVzL3RpZXJlZC1tZW51LnR5cGUnO1xuXG5ASW5qZWN0YWJsZSgpXG5leHBvcnQgY2xhc3MgVGllcmVkTWVudUV2ZW50U2VydmljZSB7XG4gIHB1YmxpYyBpbmNyZW1lbnRDdXJyZW50SXRlbUV2ZW50ID0gbmV3IEV2ZW50RW1pdHRlcjx2b2lkPigpO1xuICBwdWJsaWMgZGVjcmVtZW50Q3VycmVudEl0ZW1FdmVudCA9IG5ldyBFdmVudEVtaXR0ZXI8dm9pZD4oKTtcbiAgcHVibGljIGNsb3NlQWxsTWVudXNFdmVudCA9IG5ldyBFdmVudEVtaXR0ZXI8dm9pZD4oKTtcbiAgcHVibGljIHNlbGVjdEl0ZW1FdmVudCA9IG5ldyBFdmVudEVtaXR0ZXI8VGllcmVkTWVudUl0ZW1JbnRlcm5hbERhdGEgfCBudWxsPigpO1xuICBwdWJsaWMgb3Blbkl0ZW1NZW51RXZlbnQgPSBuZXcgRXZlbnRFbWl0dGVyPFRpZXJlZE1lbnVJdGVtSW50ZXJuYWxEYXRhIHwgbnVsbD4oKTtcbiAgcHVibGljIGNsb3NlSXRlbU1lbnVFdmVudCA9IG5ldyBFdmVudEVtaXR0ZXI8VGllcmVkTWVudUl0ZW1JbnRlcm5hbERhdGEgfCBudWxsPigpO1xufVxuIl19

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

@@ -0,0 +1,12 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class TieredMenuGlobalService {
+    lastInstance = null;
+    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, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: TieredMenuGlobalService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGllcmVkLW1lbnUuZ2xvYmFsLnNlcnZpY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWIvc3JjL2ZlYXR1cmVzL3RpZXJlZC1tZW51L3NlcnZpY2VzL3RpZXJlZC1tZW51Lmdsb2JhbC5zZXJ2aWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxlQUFlLENBQUM7O0FBSzNDLE1BQU0sT0FBTyx1QkFBdUI7SUFDM0IsWUFBWSxHQUErQixJQUFJLENBQUM7d0dBRDVDLHVCQUF1Qjs0R0FBdkIsdUJBQXVCLGNBRFYsTUFBTTs7NEZBQ25CLHVCQUF1QjtrQkFEbkMsVUFBVTttQkFBQyxFQUFFLFVBQVUsRUFBRSxNQUFNLEVBQUUiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJbmplY3RhYmxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5cbmltcG9ydCB0eXBlIHsgVGllcmVkTWVudURpcmVjdGl2ZSB9IGZyb20gJy4uL2RpcmVjdGl2ZXMvdGllcmVkLW1lbnUuZGlyZWN0aXZlJztcblxuQEluamVjdGFibGUoeyBwcm92aWRlZEluOiAncm9vdCcgfSlcbmV4cG9ydCBjbGFzcyBUaWVyZWRNZW51R2xvYmFsU2VydmljZSB7XG4gIHB1YmxpYyBsYXN0SW5zdGFuY2U6IFRpZXJlZE1lbnVEaXJlY3RpdmUgfCBudWxsID0gbnVsbDtcbn1cbiJdfQ==

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

@@ -0,0 +1,49 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class TieredMenuService {
+    currentItem = null;
+    currentItems = [];
+    items = [];
+    idCounter = 0;
+    normalizeData(items, parent) {
+        return items.map((entry) => {
+            const item = {
+                visible: true,
+                ...entry,
+                id: this.generateId(),
+                parent,
+                isOpen: false
+            };
+            if (item.submenu) {
+                item.submenu = this.normalizeData(item.submenu, item);
+            }
+            return item;
+        });
+    }
+    markAllItemsAsClosed(items) {
+        return items.map((item) => ({
+            ...item,
+            isOpen: false,
+            submenu: item.submenu ? this.markAllItemsAsClosed(item.submenu) : undefined
+        }));
+    }
+    searchTheHierarchy(itemA, itemB) {
+        let current = itemB;
+        while (current) {
+            if (current === itemA) {
+                return true;
+            }
+            current = current.parent;
+        }
+        return false;
+    }
+    generateId() {
+        return `sdc-tiered-menu-${Date.now()}-${this.idCounter++}`;
+    }
+    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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