@wavemaker-ai/app-ng-runtime 1.0.0-rc.647469

package/components/navigation/menu/esm2022/index.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './public_api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9jb21wb25lbnRzL3dpZGdldHMvbmF2aWdhdGlvbi9tZW51L3NyYy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUVILGNBQWMsY0FBYyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBHZW5lcmF0ZWQgYnVuZGxlIGluZGV4LiBEbyBub3QgZWRpdC5cbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL3B1YmxpY19hcGknO1xuIl19

package/components/navigation/menu/esm2022/menu-adapator.component.mjs

@@ -0,0 +1,80 @@
+import { QueryList, ViewChildren, Directive, Optional, Inject } from '@angular/core';
+import { MenuComponent } from './menu.component';
+import { BaseContainerComponent } from '@wm/components/base';
+import { includes } from "lodash-es";
+import * as i0 from "@angular/core";
+const menuProps = ['itemlabel', 'itemicon', 'itemlink', 'itemaction', 'itemchildren', 'userrole'];
+export class MenuAdapterComponent extends BaseContainerComponent {
+    constructor(inj, WIDGET_CONFIG, explicitContext) {
+        super(inj, WIDGET_CONFIG, explicitContext);
+        this.pageScope = this.viewParent;
+        this.binditemlabel = this.nativeElement.getAttribute('itemlabel.bind');
+        this.binditemicon = this.nativeElement.getAttribute('itemicon.bind');
+        this.binditemaction = this.nativeElement.getAttribute('itemaction.bind');
+        this.binditemlink = this.nativeElement.getAttribute('itemlink.bind');
+        this.binduserrole = this.nativeElement.getAttribute('userrole.bind');
+        this.binditemchildren = this.nativeElement.getAttribute('itemchildren.bind');
+    }
+    onPropertyChange(key, nv, ov) {
+        if (includes(menuProps, key) && this.menuRef) {
+            this.menuRef.itemlabel = nv;
+        }
+        else {
+            super.onPropertyChange(key, nv, ov);
+        }
+    }
+    ngAfterViewInit() {
+        super.ngAfterViewInit();
+        if (this.menuRefQL['first']) {
+            this.setMenuProperty();
+        }
+        this.menuRefQLSubscription = this.menuRefQL.changes.subscribe((menuRefQL) => {
+            if (menuRefQL.first) {
+                this.setMenuProperty();
+                if (this.menuRefQLSubscription) {
+                    this.menuRefQLSubscription.unsubscribe();
+                    this.menuRefQLSubscription = null;
+                }
+            }
+        });
+    }
+    ngOnDestroy() {
+        // MEMORY LEAK FIX: Unsubscribe from QueryList changes
+        if (this.menuRefQLSubscription) {
+            this.menuRefQLSubscription.unsubscribe();
+            this.menuRefQLSubscription = null;
+        }
+        // MEMORY LEAK FIX: Clear QueryList reference
+        this.menuRefQL = null;
+        this.menuRef = null;
+        super.ngOnDestroy();
+    }
+    setMenuProperty() {
+        if (this.menuRefQL['first']) {
+            if (this.menuRefQL.first) {
+                this.menuRef = this.menuRefQL.first;
+                menuProps.forEach((prop) => {
+                    const bindProp = `bind${prop}`;
+                    if (this[bindProp]) {
+                        this.menuRef[bindProp] = this[bindProp];
+                    }
+                    this.menuRef[prop] = this[prop];
+                });
+            }
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: MenuAdapterComponent, deps: "invalid", target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.13", type: MenuAdapterComponent, viewQueries: [{ propertyName: "menuRefQL", predicate: MenuComponent, descendants: true }], usesInheritance: true, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: MenuAdapterComponent, decorators: [{
+            type: Directive
+        }], ctorParameters: () => [{ type: undefined }, { type: undefined }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['EXPLICIT_CONTEXT']
+                }, {
+                    type: Optional
+                }] }], propDecorators: { menuRefQL: [{
+                type: ViewChildren,
+                args: [MenuComponent]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"menu-adapator.component.js","sourceRoot":"","sources":["../../../../../projects/components/widgets/navigation/menu/src/menu-adapator.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { AfterViewInit, QueryList, ViewChildren, Directive, Optional, Inject, OnDestroy } from '@angular/core';\nimport { MenuComponent } from './menu.component';\nimport { BaseContainerComponent } from '@wm/components/base';\nimport { includes } from \"lodash-es\";\n\nconst menuProps = ['itemlabel', 'itemicon', 'itemlink', 'itemaction', 'itemchildren', 'userrole'];\n\n@Directive()\nexport class MenuAdapterComponent extends BaseContainerComponent implements AfterViewInit, OnDestroy {\n\n    private itemlabel;\n    private menuRef;\n    private pageScope;\n\n    private binditemlabel;\n    private binditemicon;\n    private binditemaction;\n    private binditemchildren;\n    private binditemlink;\n    private binduserrole;\n\n    @ViewChildren(MenuComponent) private menuRefQL: QueryList<MenuComponent>;\n    private menuRefQLSubscription: any;\n\n    constructor(\n        inj,\n        WIDGET_CONFIG,\n        @Inject('EXPLICIT_CONTEXT') @Optional() explicitContext: any\n    ) {\n        super(inj, WIDGET_CONFIG, explicitContext);\n\n        this.pageScope = this.viewParent;\n        this.binditemlabel = this.nativeElement.getAttribute('itemlabel.bind');\n        this.binditemicon = this.nativeElement.getAttribute('itemicon.bind');\n        this.binditemaction = this.nativeElement.getAttribute('itemaction.bind');\n        this.binditemlink = this.nativeElement.getAttribute('itemlink.bind');\n        this.binduserrole = this.nativeElement.getAttribute('userrole.bind');\n        this.binditemchildren = this.nativeElement.getAttribute('itemchildren.bind');\n    }\n\n    onPropertyChange(key: string, nv: any, ov?: any) {\n        if (includes(menuProps, key) && this.menuRef) {\n            this.menuRef.itemlabel = nv;\n        } else {\n            super.onPropertyChange(key, nv, ov);\n        }\n    }\n\n    ngAfterViewInit() {\n        super.ngAfterViewInit();\n        if(this.menuRefQL['first'])\n        {this.setMenuProperty();}\n        this.menuRefQLSubscription = this.menuRefQL.changes.subscribe((menuRefQL: QueryList<MenuComponent>) => {\n            if (menuRefQL.first) {\n                this.setMenuProperty();\n                if (this.menuRefQLSubscription) {\n                    this.menuRefQLSubscription.unsubscribe();\n                    this.menuRefQLSubscription = null;\n                }\n            }\n        });\n    }\n\n    ngOnDestroy() {\n        // MEMORY LEAK FIX: Unsubscribe from QueryList changes\n        if (this.menuRefQLSubscription) {\n            this.menuRefQLSubscription.unsubscribe();\n            this.menuRefQLSubscription = null;\n        }\n\n        // MEMORY LEAK FIX: Clear QueryList reference\n        this.menuRefQL = null;\n        this.menuRef = null;\n\n        super.ngOnDestroy();\n    }\n\n    protected setMenuProperty(){\n        if(this.menuRefQL['first']) {\n            if (this.menuRefQL.first) {\n                this.menuRef = this.menuRefQL.first;\n                menuProps.forEach((prop) => {\n                    const bindProp = `bind${prop}`;\n                    if (this[bindProp]) {\n                        this.menuRef[bindProp] = this[bindProp];\n                    }\n                    this.menuRef[prop] = this[prop];\n                });\n            }\n        }\n    }\n\n}\n"]}

package/components/navigation/menu/esm2022/menu-dropdown/menu-dropdown.component.mjs

@@ -0,0 +1,105 @@
+import { CommonModule } from '@angular/common';
+import { MenuDropdownItemComponent } from '../menu-dropdown-item/menu-dropdown-item.component';
+import { Component, ElementRef, inject, Input } from '@angular/core';
+import { addClass } from '@wm/core';
+import { MenuComponent } from '../menu.component';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+const animationClasses = {
+    scale: {
+        'name': 'wmScaleInLeft',
+        'down,right': 'wmScaleInLeft',
+        'down,left': 'wmScaleInRight',
+        'up,right': 'wmScaleInTopLeft',
+        'up,left': 'wmScaleInTopRight'
+    },
+    fade: {
+        'name': 'fadeIn',
+        'down,right': 'fadeIn',
+        'down,left': 'fadeIn',
+        'up,right': 'fadeIn',
+        'up,left': 'fadeIn'
+    },
+    slide: {
+        'name': 'wmSlideInDown',
+        'down,right': 'wmSlideInDown',
+        'down,left': 'wmSlideInDown',
+        'up,right': 'wmSlideInUp',
+        'up,left': 'wmSlideInUp'
+    }
+};
+const DEFAULT_CLS = 'dropdown-menu';
+export class MenuDropdownComponent {
+    constructor(elRef) {
+        this.menuRef = inject(MenuComponent);
+        this.nativeElement = elRef.nativeElement;
+        this.hasExecutedCallback = false;
+        addClass(this.nativeElement, DEFAULT_CLS);
+    }
+    ngAfterViewInit() {
+        const animateItems = this.menuRef.animateitems;
+        let animationClass = '';
+        if (animateItems) {
+            animationClass = `animated ${(animationClasses[animateItems][this.menuRef.menuposition] || animationClasses[animateItems].name)}`;
+        }
+        addClass(this.nativeElement, `dropdown-menu ${this.menuRef.menualign} ${animationClass}`, true);
+        this.getParentWidget();
+    }
+    // Function to check if the menu widget is present inside other widgets like table, tabs, dialog, nav, list, tile, panel, accordion
+    // if true then call createObserver() which internally calculates dropown height
+    getParentWidget() {
+        const closestWidget = $(this.menuRef.nativeElement).closest('table, ul.list-group');
+        // Check if the closest table is the parent of the menu widget
+        if (closestWidget && $(closestWidget).has(this.menuRef.nativeElement).length > 0) {
+            this.createObserver(this, this.callback);
+        }
+    }
+    // function which changes the position of the menu dropdown dynamically if it exceeds viewport height
+    callback(entries, observer) {
+        if (!this.hasExecutedCallback) {
+            const self = this;
+            const positions = this.menuRef.menuposition?.split(',') || [];
+            entries.forEach(entry => {
+                if (entry.isIntersecting) {
+                    positions[0] = 'down';
+                    self.menuRef.menuposition = positions.length > 1 ? positions.join() : 'down,right';
+                    self.nativeElement.parentElement?.classList.add('dropdown');
+                    self.menuRef.setMenuPosition();
+                }
+                else {
+                    positions[0] = 'up';
+                    self.menuRef.menuposition = positions.length > 1 ? positions.join() : 'up,right';
+                    self.nativeElement.parentElement?.classList.add('dropup');
+                    self.menuRef.setMenuPosition();
+                    // when container="body" is added to menu dropdown, the dropdown menu ul is attached directly to body.
+                    // so adding a class name inorder to adjust the styling of the dropdown
+                    const dropdownContainer = self.nativeElement.parentElement?.parentElement;
+                    if (dropdownContainer.tagName.toUpperCase() === "BS-DROPDOWN-CONTAINER") {
+                        // The parent element is <bs-dropdown-container>
+                        self.nativeElement.parentElement?.parentElement?.classList.add('parent-position');
+                    }
+                }
+            });
+            this.hasExecutedCallback = true;
+        }
+    }
+    // function which checks if the dropdown is within the viewport height or exceeds viewport height
+    createObserver(target, callback) {
+        const options = {
+            root: null,
+            threshold: 1,
+            once: true
+        };
+        const observer = new IntersectionObserver(callback.bind(this), options);
+        observer.observe(target.nativeElement);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: MenuDropdownComponent, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.13", type: MenuDropdownComponent, isStandalone: true, selector: "ul[wmMenuDropdown]", inputs: { items: "items" }, ngImport: i0, template: "@for (item of items; track item) {\n  <li wmMenuDropdownItem\n    [item]=\"item\"\n    [ngClass]=\"{disabled: item.disabled, 'dropdown-submenu': item.children.length > 0}\"\n    class=\"{{item.class}}\"\n    role=\"menuitem\">\n  </li>\n}\n", dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "component", type: MenuDropdownItemComponent, selector: "li[wmMenuDropdownItem]", inputs: ["item"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: MenuDropdownComponent, decorators: [{
+            type: Component,
+            args: [{ standalone: true, imports: [CommonModule, MenuDropdownItemComponent], selector: 'ul[wmMenuDropdown]', template: "@for (item of items; track item) {\n  <li wmMenuDropdownItem\n    [item]=\"item\"\n    [ngClass]=\"{disabled: item.disabled, 'dropdown-submenu': item.children.length > 0}\"\n    class=\"{{item.class}}\"\n    role=\"menuitem\">\n  </li>\n}\n" }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }], propDecorators: { items: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"menu-dropdown.component.js","sourceRoot":"","sources":["../../../../../../projects/components/widgets/navigation/menu/src/menu-dropdown/menu-dropdown.component.ts","../../../../../../projects/components/widgets/navigation/menu/src/menu-dropdown/menu-dropdown.component.html"],"names":[],"mappings":"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","sourcesContent":["import { CommonModule } from '@angular/common';\nimport { MenuDropdownItemComponent } from '../menu-dropdown-item/menu-dropdown-item.component';\nimport { AfterViewInit, Component, ElementRef, inject, Input } from '@angular/core';\n\nimport { addClass } from '@wm/core';\n\nimport { MenuComponent } from '../menu.component';\n\nconst animationClasses = {\n    scale: {\n        'name': 'wmScaleInLeft',\n        'down,right': 'wmScaleInLeft',\n        'down,left': 'wmScaleInRight',\n        'up,right': 'wmScaleInTopLeft',\n        'up,left': 'wmScaleInTopRight'\n    },\n    fade: {\n        'name': 'fadeIn',\n        'down,right': 'fadeIn',\n        'down,left': 'fadeIn',\n        'up,right': 'fadeIn',\n        'up,left': 'fadeIn'\n    },\n    slide: {\n        'name': 'wmSlideInDown',\n        'down,right': 'wmSlideInDown',\n        'down,left': 'wmSlideInDown',\n        'up,right': 'wmSlideInUp',\n        'up,left': 'wmSlideInUp'\n    }\n};\n\nconst DEFAULT_CLS = 'dropdown-menu';\n\n@Component({\n  standalone: true,\n  imports: [CommonModule, MenuDropdownItemComponent],\n    selector: 'ul[wmMenuDropdown]',\n    templateUrl: './menu-dropdown.component.html'\n})\nexport class MenuDropdownComponent implements AfterViewInit {\n    private readonly nativeElement;\n    private hasExecutedCallback;\n    @Input() items;\n    private menuRef = inject(MenuComponent);\n    constructor(elRef: ElementRef) {\n        this.nativeElement = elRef.nativeElement;\n        this.hasExecutedCallback = false;\n        addClass(this.nativeElement, DEFAULT_CLS);\n    }\n\n    ngAfterViewInit() {\n        const animateItems = this.menuRef.animateitems;\n        let animationClass = '';\n        if (animateItems) {\n            animationClass = `animated ${(animationClasses[animateItems][this.menuRef.menuposition] || animationClasses[animateItems].name)}`;\n        }\n        addClass(this.nativeElement, `dropdown-menu ${this.menuRef.menualign} ${animationClass}`, true);\n       this.getParentWidget();\n    }\n    // Function to check if the menu widget is present inside other widgets like table, tabs, dialog, nav, list, tile, panel, accordion\n    // if true then call createObserver() which internally calculates dropown height\n    getParentWidget() {\n        const closestWidget  = $(this.menuRef.nativeElement).closest('table, ul.list-group');\n\n        // Check if the closest table is the parent of the menu widget\n        if (closestWidget && $(closestWidget).has(this.menuRef.nativeElement).length > 0) {\n            this.createObserver(this, this.callback);\n        }\n    }\n    // function which changes the position of the menu dropdown dynamically if it exceeds viewport height\n     callback(entries, observer) {\n         if (!this.hasExecutedCallback) {\n             const self = this;\n             const positions = this.menuRef.menuposition?.split(',') || [];\n             entries.forEach(entry => {\n                 if(entry.isIntersecting) {\n                     positions[0]='down';\n                     self.menuRef.menuposition= positions.length > 1 ? positions.join() : 'down,right';\n                     self.nativeElement.parentElement?.classList.add('dropdown');\n                     self.menuRef.setMenuPosition();\n                 } else {\n                     positions[0]='up';\n                     self.menuRef.menuposition = positions.length > 1 ? positions.join() : 'up,right';\n                     self.nativeElement.parentElement?.classList.add('dropup');\n                     self.menuRef.setMenuPosition();\n                     // when container=\"body\" is added to menu dropdown, the dropdown menu ul is attached directly to body.\n                     // so adding a class name inorder to adjust the styling of the dropdown\n                     const dropdownContainer = self.nativeElement.parentElement?.parentElement;\n                     if (dropdownContainer.tagName.toUpperCase() === \"BS-DROPDOWN-CONTAINER\") {\n                         // The parent element is <bs-dropdown-container>\n                         self.nativeElement.parentElement?.parentElement?.classList.add('parent-position');\n                     }\n\n                 }\n             });\n             this.hasExecutedCallback = true;\n         }\n    }\n\n    // function which checks if the dropdown is within the viewport height or exceeds viewport height\n    createObserver(target, callback) {\n        const options = {\n            root: null,\n            threshold: 1,\n            once: true\n        };\n        const observer = new IntersectionObserver(callback.bind(this), options);\n        observer.observe(target.nativeElement);\n    }\n\n}\n","@for (item of items; track item) {\n  <li wmMenuDropdownItem\n    [item]=\"item\"\n    [ngClass]=\"{disabled: item.disabled, 'dropdown-submenu': item.children.length > 0}\"\n    class=\"{{item.class}}\"\n    role=\"menuitem\">\n  </li>\n}\n"]}

package/components/navigation/menu/esm2022/menu-dropdown-item/menu-dropdown-item.component.mjs

@@ -0,0 +1,191 @@
+import { MenuDropdownComponent } from '../menu-dropdown/menu-dropdown.component';
+import { NavigationControlDirective } from '../nav/navigation-control.directive';
+import { Component, ElementRef, forwardRef, HostListener, inject, Input, Optional } from '@angular/core';
+import { addClass, triggerItemAction, UserDefinedExecutionContext, App, toggleClass } from '@wm/core';
+import { hasLinkToCurrentPage, TextContentDirective } from '@wm/components/base';
+import { NavComponent } from '../nav/nav.component';
+import { KEYBOARD_MOVEMENTS, MENU_POSITION, MenuComponent } from '../menu.component';
+import { clone, includes } from "lodash-es";
+import * as i0 from "@angular/core";
+import * as i1 from "@wm/core";
+import * as i2 from "../nav/nav.component";
+const menuAlignClass = {
+    'pull-right': 'fa-caret-left',
+    'dropinline-menu': 'fa-caret-down',
+    'pull-left': 'fa-caret-right'
+};
+const MENU_LAYOUT_TYPE = {
+    HORIZONTAL: 'horizontal',
+    VERTICAL: 'vertical'
+};
+export class MenuDropdownItemComponent {
+    constructor(app, userDefinedExecutionContext, parentNav, elRef) {
+        this.app = app;
+        this.userDefinedExecutionContext = userDefinedExecutionContext;
+        this.parentNav = parentNav;
+        this.menuRef = inject(MenuComponent);
+        this.onSelect = ($event, item) => {
+            if (this.nativeElement !== $($event.target).closest('.app-menu-item').get(0)) {
+                return;
+            }
+            // prevent event event propagation if auto close is outside click.
+            if (this.menuRef.autoclose === 'outsideClick') {
+                $event.stopPropagation();
+            }
+            $event.preventDefault();
+            const args = { $event, $item: item };
+            this.menuRef.onMenuItemSelect(args);
+            const selectedItem = clone(item);
+            selectedItem.target = selectedItem.target || this.menuRef.linktarget;
+            // Trigger the action associated with active item
+            triggerItemAction(this, selectedItem);
+        };
+        this.nativeElement = elRef.nativeElement;
+        addClass(this.nativeElement, 'app-menu-item');
+        this.menualign = menuAlignClass[this.menuRef.menualign] || menuAlignClass['pull-left'];
+    }
+    ngOnInit() {
+        // add active class to the item only if it is in nav component.
+        if (this.parentNav) {
+            if (hasLinkToCurrentPage([this.item], this.menuRef.route.url)) {
+                // add active class to the li, if the menu item's link is same as the current page name.
+                addClass(this.nativeElement, 'active');
+            }
+            this.highlightActiveLinkSubscription = this.app.subscribe("highlightActiveLink", (data) => {
+                toggleClass(this.nativeElement, 'active', hasLinkToCurrentPage([this.item], this.menuRef.route.url));
+            });
+        }
+    }
+    getInitialKeyMovements() {
+        const KEY_MOVEMENTS = clone(KEYBOARD_MOVEMENTS);
+        if (this.menuRef.menulayout === MENU_LAYOUT_TYPE.HORIZONTAL) {
+            KEY_MOVEMENTS.MOVE_UP = 'LEFT-ARROW';
+            KEY_MOVEMENTS.MOVE_LEFT = 'UP-ARROW';
+            KEY_MOVEMENTS.MOVE_RIGHT = 'DOWN-ARROW';
+            KEY_MOVEMENTS.MOVE_DOWN = 'RIGHT-ARROW';
+        }
+        else {
+            if (this.menuRef.menuposition === MENU_POSITION.DOWN_LEFT || this.menuRef.menuposition === MENU_POSITION.UP_LEFT) {
+                KEY_MOVEMENTS.MOVE_LEFT = 'RIGHT-ARROW';
+                KEY_MOVEMENTS.MOVE_RIGHT = 'LEFT-ARROW';
+            }
+            else if (this.menuRef.menuposition === 'inline') {
+                KEY_MOVEMENTS.MOVE_UP = 'LEFT-ARROW';
+                KEY_MOVEMENTS.MOVE_LEFT = 'UP-ARROW';
+                KEY_MOVEMENTS.MOVE_RIGHT = 'DOWN-ARROW';
+                KEY_MOVEMENTS.MOVE_DOWN = 'RIGHT-ARROW';
+            }
+        }
+        return KEY_MOVEMENTS;
+    }
+    onKeyDown($event, eventAction) {
+        const $li = $(this.nativeElement);
+        const $ul = $(this.nativeElement).closest('ul.dropdown-menu');
+        const $parentUl = this.menuRef.$element.find('> ul.dropdown-menu');
+        const ARROW_KEYS = ['LEFT-ARROW', 'RIGHT-ARROW', 'UP-ARROW', 'DOWN-ARROW'];
+        const KEY_MOVEMENTS = this.getInitialKeyMovements();
+        if (includes(ARROW_KEYS, eventAction)) {
+            // preventing from page scroll when up/down arrow is pressed, in case of menu is opened.
+            $event.preventDefault();
+        }
+        if ((eventAction === KEY_MOVEMENTS.ON_TAB && $parentUl.children().last()[0] === this.nativeElement)
+            || (eventAction === KEY_MOVEMENTS.ON_SHIFT_TAB && $parentUl.children().first()[0] === this.nativeElement)
+            || eventAction === KEY_MOVEMENTS.ON_ESCAPE) {
+            /*closing all the children elements when
+            * 1. Tab is clicked on the last $element
+            * 2. Shift Tab is clicked on the first $element
+            * 3. When Escape key is clicked*/
+            $event.preventDefault();
+            this.menuRef.bsDropdown.hide();
+        }
+        else if ((eventAction === KEY_MOVEMENTS.ON_ENTER && !this.item.link) || eventAction === KEY_MOVEMENTS.MOVE_RIGHT) {
+            // when there is no link for the menu, on enter open the inner child elements and focus the first $element
+            $event.stopPropagation();
+            if (this.item.children.length) {
+                $li.toggleClass('open');
+                $li.find('li').first().find('> a').focus();
+            }
+            else {
+                $li.find('> a').focus();
+            }
+        }
+        else if (eventAction === KEY_MOVEMENTS.MOVE_LEFT
+            || (eventAction === KEY_MOVEMENTS.ON_TAB && $ul.children().last()[0] === this.nativeElement)
+            || (eventAction === KEY_MOVEMENTS.ON_SHIFT_TAB && $ul.children().first()[0] === this.nativeElement)) {
+            if ($parentUl[0] !== $ul[0]) {
+                const $parentItem = $ul.parent();
+                $parentItem.toggleClass('open').find('li.open').removeClass('open');
+                $parentItem.find('> a').focus();
+                $event.preventDefault();
+                $event.stopPropagation();
+            }
+        }
+        else if (eventAction === KEY_MOVEMENTS.MOVE_UP) {
+            if ($parentUl[0] !== $ul[0] || $parentUl.find('> li').first()[0] !== this.nativeElement) {
+                $event.stopPropagation();
+                $li.prev().find('> a').focus();
+            }
+        }
+        else if (eventAction === KEY_MOVEMENTS.MOVE_DOWN) {
+            $event.stopPropagation();
+            if ($parentUl.find('> li').last()[0] === this.nativeElement
+                && (this.menuRef.menulayout !== MENU_LAYOUT_TYPE.HORIZONTAL
+                    && this.menuRef.menuposition === MENU_POSITION.UP_RIGHT
+                    || this.menuRef.menuposition === MENU_POSITION.UP_LEFT)) {
+                this.menuRef.bsDropdown.hide();
+            }
+            else {
+                $li.next().find('> a').focus();
+            }
+        }
+        else if (eventAction === KEY_MOVEMENTS.ON_ENTER) {
+            this.onSelect($event, this.item);
+        }
+        else {
+            $event.stopPropagation();
+        }
+    }
+    ngOnDestroy() {
+        if (this.highlightActiveLinkSubscription) {
+            this.highlightActiveLinkSubscription();
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: MenuDropdownItemComponent, deps: [{ token: i1.App }, { token: i1.UserDefinedExecutionContext }, { token: i2.NavComponent, optional: true }, { token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.13", type: MenuDropdownItemComponent, isStandalone: true, selector: "li[wmMenuDropdownItem]", inputs: { item: "item" }, host: { listeners: { "keydown.tab": "onKeyDown($event,\"TAB\")", "keydown.shift.tab": "onKeyDown($event,\"SHIFT-TAB\")", "keydown.escape": "onKeyDown($event,\"ESC\")", "keydown.enter": "onKeyDown($event,\"ENTER\")", "keydown.arrowup": "onKeyDown($event,\"UP-ARROW\")", "keydown.arrowdown": "onKeyDown($event,\"DOWN-ARROW\")", "keydown.arrowright": "onKeyDown($event,\"RIGHT-ARROW\")", "keydown.arrowleft": "onKeyDown($event,\"LEFT-ARROW\")", "click": "onSelect($event,item)" } }, ngImport: i0, template: "<a href=\"javascript:void(0);\" [title]=\"item.label\" [wmNavigationControl]=\"item.link\" [disableMenuContext]=\"menuRef.disableMenuContext || !!item.action\">\n  @if (item.children.length) {\n    <span class=\"pull-right fa caret {{menualign}}\"></span>\n  }\n  <i class=\"app-icon {{item.icon}}\"></i>\n  <span class=\"anchor-caption\">{{item.label}}</span>\n  @if (item.badge) {\n    <span class=\"badge pull-right\" [textContent]=\"item.badge\"></span>\n  }\n</a>\n@if (item.children.length) {\n  <ul wmMenuDropdown [items]=\"item.children\"></ul>\n}", dependencies: [{ kind: "directive", type: i0.forwardRef(() => TextContentDirective), selector: "[textContent]", inputs: ["textContent"] }, { kind: "component", type: i0.forwardRef(() => MenuDropdownComponent), selector: "ul[wmMenuDropdown]", inputs: ["items"] }, { kind: "directive", type: i0.forwardRef(() => NavigationControlDirective), selector: "[wmNavigationControl]", inputs: ["disableMenuContext", "wmNavigationControl"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: MenuDropdownItemComponent, decorators: [{
+            type: Component,
+            args: [{ standalone: true, imports: [TextContentDirective, forwardRef(() => MenuDropdownComponent), NavigationControlDirective], selector: 'li[wmMenuDropdownItem]', template: "<a href=\"javascript:void(0);\" [title]=\"item.label\" [wmNavigationControl]=\"item.link\" [disableMenuContext]=\"menuRef.disableMenuContext || !!item.action\">\n  @if (item.children.length) {\n    <span class=\"pull-right fa caret {{menualign}}\"></span>\n  }\n  <i class=\"app-icon {{item.icon}}\"></i>\n  <span class=\"anchor-caption\">{{item.label}}</span>\n  @if (item.badge) {\n    <span class=\"badge pull-right\" [textContent]=\"item.badge\"></span>\n  }\n</a>\n@if (item.children.length) {\n  <ul wmMenuDropdown [items]=\"item.children\"></ul>\n}" }]
+        }], ctorParameters: () => [{ type: i1.App }, { type: i1.UserDefinedExecutionContext }, { type: i2.NavComponent, decorators: [{
+                    type: Optional
+                }] }, { type: i0.ElementRef }], propDecorators: { item: [{
+                type: Input
+            }], onKeyDown: [{
+                type: HostListener,
+                args: ['keydown.tab', ['$event', '"TAB"']]
+            }, {
+                type: HostListener,
+                args: ['keydown.shift.tab', ['$event', '"SHIFT-TAB"']]
+            }, {
+                type: HostListener,
+                args: ['keydown.escape', ['$event', '"ESC"']]
+            }, {
+                type: HostListener,
+                args: ['keydown.enter', ['$event', '"ENTER"']]
+            }, {
+                type: HostListener,
+                args: ['keydown.arrowup', ['$event', '"UP-ARROW"']]
+            }, {
+                type: HostListener,
+                args: ['keydown.arrowdown', ['$event', '"DOWN-ARROW"']]
+            }, {
+                type: HostListener,
+                args: ['keydown.arrowright', ['$event', '"RIGHT-ARROW"']]
+            }, {
+                type: HostListener,
+                args: ['keydown.arrowleft', ['$event', '"LEFT-ARROW"']]
+            }], onSelect: [{
+                type: HostListener,
+                args: ['click', ['$event', 'item']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"menu-dropdown-item.component.js","sourceRoot":"","sources":["../../../../../../projects/components/widgets/navigation/menu/src/menu-dropdown-item/menu-dropdown-item.component.ts","../../../../../../projects/components/widgets/navigation/menu/src/menu-dropdown-item/menu-dropdown-item.component.html"],"names":[],"mappings":"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","sourcesContent":["import { MenuDropdownComponent } from '../menu-dropdown/menu-dropdown.component';\nimport { NavigationControlDirective } from '../nav/navigation-control.directive';\nimport { Component, ElementRef, forwardRef, HostListener, inject, Input, OnDestroy, OnInit, Optional } from '@angular/core';\n\nimport { addClass, triggerItemAction, UserDefinedExecutionContext, App, toggleClass } from '@wm/core';\nimport { hasLinkToCurrentPage, TextContentDirective } from '@wm/components/base';\nimport { NavComponent } from '../nav/nav.component';\n\nimport { KEYBOARD_MOVEMENTS, MENU_POSITION, MenuComponent } from '../menu.component';\nimport { clone, includes } from \"lodash-es\";\n\ndeclare const $;\n\nconst menuAlignClass = {\n    'pull-right': 'fa-caret-left',\n    'dropinline-menu': 'fa-caret-down',\n    'pull-left': 'fa-caret-right'\n};\n\nconst MENU_LAYOUT_TYPE = {\n    HORIZONTAL: 'horizontal',\n    VERTICAL: 'vertical'\n};\n\n@Component({\n    standalone: true,\n    imports: [TextContentDirective, forwardRef(() => MenuDropdownComponent), NavigationControlDirective],\n    selector: 'li[wmMenuDropdownItem]',\n    templateUrl: './menu-dropdown-item.component.html',\n})\nexport class MenuDropdownItemComponent implements OnInit, OnDestroy {\n\n    public menualign: string;\n\n    private itemActionFn: Function;\n\n    @Input() item;\n\n    private readonly nativeElement;\n    private highlightActiveLinkSubscription: () => void;\n    public menuRef =  inject(MenuComponent);\n    constructor(\n        private app: App,\n        private userDefinedExecutionContext: UserDefinedExecutionContext,\n        @Optional() private parentNav: NavComponent,\n        elRef: ElementRef,\n    ) {\n        this.nativeElement = elRef.nativeElement;\n        addClass(this.nativeElement, 'app-menu-item');\n\n        this.menualign = menuAlignClass[this.menuRef.menualign] || menuAlignClass['pull-left'];\n    }\n\n    ngOnInit() {\n        // add active class to the item only if it is in nav component.\n        if (this.parentNav) {\n            if (hasLinkToCurrentPage([this.item], this.menuRef.route.url)) {\n                // add active class to the li, if the menu item's link is same as the current page name.\n                addClass(this.nativeElement, 'active');\n            }\n            this.highlightActiveLinkSubscription = this.app.subscribe(\"highlightActiveLink\", (data) => {\n                toggleClass(this.nativeElement, 'active', hasLinkToCurrentPage([this.item], this.menuRef.route.url));\n            });\n        }\n    }\n\n    getInitialKeyMovements() {\n        const KEY_MOVEMENTS = clone(KEYBOARD_MOVEMENTS);\n        if (this.menuRef.menulayout === MENU_LAYOUT_TYPE.HORIZONTAL) {\n            KEY_MOVEMENTS.MOVE_UP = 'LEFT-ARROW';\n            KEY_MOVEMENTS.MOVE_LEFT = 'UP-ARROW';\n            KEY_MOVEMENTS.MOVE_RIGHT = 'DOWN-ARROW';\n            KEY_MOVEMENTS.MOVE_DOWN = 'RIGHT-ARROW';\n        } else {\n            if (this.menuRef.menuposition === MENU_POSITION.DOWN_LEFT || this.menuRef.menuposition === MENU_POSITION.UP_LEFT) {\n                KEY_MOVEMENTS.MOVE_LEFT = 'RIGHT-ARROW';\n                KEY_MOVEMENTS.MOVE_RIGHT = 'LEFT-ARROW';\n            } else if (this.menuRef.menuposition === 'inline') {\n                KEY_MOVEMENTS.MOVE_UP = 'LEFT-ARROW';\n                KEY_MOVEMENTS.MOVE_LEFT = 'UP-ARROW';\n                KEY_MOVEMENTS.MOVE_RIGHT = 'DOWN-ARROW';\n                KEY_MOVEMENTS.MOVE_DOWN = 'RIGHT-ARROW';\n            }\n        }\n        return KEY_MOVEMENTS;\n    }\n\n    @HostListener('keydown.tab', ['$event', '\"TAB\"'])\n    @HostListener('keydown.shift.tab', ['$event', '\"SHIFT-TAB\"'])\n    @HostListener('keydown.escape', ['$event', '\"ESC\"'])\n    @HostListener('keydown.enter', ['$event', '\"ENTER\"'])\n    @HostListener('keydown.arrowup', ['$event', '\"UP-ARROW\"'])\n    @HostListener('keydown.arrowdown', ['$event', '\"DOWN-ARROW\"'])\n    @HostListener('keydown.arrowright', ['$event', '\"RIGHT-ARROW\"'])\n    @HostListener('keydown.arrowleft', ['$event', '\"LEFT-ARROW\"'])\n    onKeyDown($event, eventAction) {\n        const $li = $(this.nativeElement);\n        const $ul = $(this.nativeElement).closest('ul.dropdown-menu');\n        const $parentUl = this.menuRef.$element.find('> ul.dropdown-menu');\n        const ARROW_KEYS = ['LEFT-ARROW', 'RIGHT-ARROW', 'UP-ARROW', 'DOWN-ARROW'];\n        const KEY_MOVEMENTS = this.getInitialKeyMovements();\n\n        if (includes(ARROW_KEYS, eventAction)) {\n            // preventing from page scroll when up/down arrow is pressed, in case of menu is opened.\n            $event.preventDefault();\n        }\n\n        if ((eventAction === KEY_MOVEMENTS.ON_TAB && $parentUl.children().last()[0] === this.nativeElement)\n            || (eventAction === KEY_MOVEMENTS.ON_SHIFT_TAB && $parentUl.children().first()[0] === this.nativeElement)\n            || eventAction === KEY_MOVEMENTS.ON_ESCAPE) {\n            /*closing all the children elements when\n            * 1. Tab is clicked on the last $element\n            * 2. Shift Tab is clicked on the first $element\n            * 3. When Escape key is clicked*/\n            $event.preventDefault();\n            this.menuRef.bsDropdown.hide();\n        } else if ((eventAction === KEY_MOVEMENTS.ON_ENTER && !this.item.link) || eventAction === KEY_MOVEMENTS.MOVE_RIGHT) {\n            // when there is no link for the menu, on enter open the inner child elements and focus the first $element\n            $event.stopPropagation();\n            if (this.item.children.length) {\n                $li.toggleClass('open');\n                $li.find('li').first().find('> a').focus();\n            } else {\n                $li.find('> a').focus();\n            }\n        } else if (eventAction === KEY_MOVEMENTS.MOVE_LEFT\n            || (eventAction === KEY_MOVEMENTS.ON_TAB && $ul.children().last()[0] === this.nativeElement)\n            || (eventAction === KEY_MOVEMENTS.ON_SHIFT_TAB && $ul.children().first()[0] === this.nativeElement)) {\n            if ($parentUl[0] !== $ul[0]) {\n                const $parentItem = $ul.parent();\n                $parentItem.toggleClass('open').find('li.open').removeClass('open');\n                $parentItem.find('> a').focus();\n                $event.preventDefault();\n                $event.stopPropagation();\n            }\n        } else if (eventAction === KEY_MOVEMENTS.MOVE_UP) {\n            if ($parentUl[0] !== $ul[0] || $parentUl.find('> li').first()[0] !== this.nativeElement) {\n                $event.stopPropagation();\n                $li.prev().find('> a').focus();\n            }\n        } else if (eventAction === KEY_MOVEMENTS.MOVE_DOWN) {\n            $event.stopPropagation();\n            if ($parentUl.find('> li').last()[0] === this.nativeElement\n                && (this.menuRef.menulayout !== MENU_LAYOUT_TYPE.HORIZONTAL\n                    && this.menuRef.menuposition === MENU_POSITION.UP_RIGHT\n                    || this.menuRef.menuposition === MENU_POSITION.UP_LEFT)) {\n                this.menuRef.bsDropdown.hide();\n            } else {\n                $li.next().find('> a').focus();\n            }\n        } else if (eventAction === KEY_MOVEMENTS.ON_ENTER) {\n            this.onSelect($event, this.item);\n        } else {\n            $event.stopPropagation();\n        }\n    }\n\n    @HostListener('click', ['$event', 'item'])\n    onSelect = ($event, item) => {\n        if (this.nativeElement !== $($event.target).closest('.app-menu-item').get(0)) {\n            return;\n        }\n        // prevent event event propagation if auto close is outside click.\n        if (this.menuRef.autoclose === 'outsideClick') {\n            $event.stopPropagation();\n        }\n\n        $event.preventDefault();\n        const args = { $event, $item: item };\n        this.menuRef.onMenuItemSelect(args);\n        const selectedItem = clone(item);\n        selectedItem.target = selectedItem.target || this.menuRef.linktarget;\n        // Trigger the action associated with active item\n        triggerItemAction(this, selectedItem);\n    }\n\n    ngOnDestroy(): void {\n        if (this.highlightActiveLinkSubscription) {\n            this.highlightActiveLinkSubscription();\n        }\n    }\n}\n","<a href=\"javascript:void(0);\" [title]=\"item.label\" [wmNavigationControl]=\"item.link\" [disableMenuContext]=\"menuRef.disableMenuContext || !!item.action\">\n  @if (item.children.length) {\n    <span class=\"pull-right fa caret {{menualign}}\"></span>\n  }\n  <i class=\"app-icon {{item.icon}}\"></i>\n  <span class=\"anchor-caption\">{{item.label}}</span>\n  @if (item.badge) {\n    <span class=\"badge pull-right\" [textContent]=\"item.badge\"></span>\n  }\n</a>\n@if (item.children.length) {\n  <ul wmMenuDropdown [items]=\"item.children\"></ul>\n}"]}