@bnsights/bbsf-admin-portal 1.0.0

package/esm2015/lib/_metronic/core/components/MenuComponent.js

@@ -0,0 +1,826 @@
+import { createPopper } from '@popperjs/core';
+import { getAttributeValueByBreakpoint, getElementChild, getElementParents, getHighestZindex, insertAfterElement, slideDown, slideUp, throttle } from "../_utils/DomHelpers";
+import { EventHandlerUtil } from "../_utils/EventHandlerUtil";
+import { DataUtil } from "../_utils/_DataUtil";
+import { DOMEventHandlerUtil } from "../_utils/_DOMEventHandlerUtil";
+import { ElementStyleUtil } from "../_utils/_ElementStyleUtil";
+import { getUniqueIdWithPrefix } from "../_utils/_TypesHelpers";
+const defaultMenuOptions = {
+    dropdown: {
+        hoverTimeout: 200,
+        zindex: 105,
+    },
+    accordion: {
+        slideSpeed: 250,
+        expand: false,
+    },
+};
+class MenuComponent {
+    constructor(_element, options) {
+        this.triggerElement = null;
+        // Set external trigger element
+        this._setTriggerElement = () => {
+            const target = document.querySelector(`[data-kt-menu-target="#${this.element.getAttribute('id')}"`);
+            if (target) {
+                this.triggerElement = target;
+            }
+            else if (this.element.closest('[data-kt-menu-trigger]')) {
+                this.triggerElement = this.element.closest('[data-kt-menu-trigger]');
+            }
+            else if (this.element.parentNode &&
+                getElementChild(this.element.parentNode, '[data-kt-menu-trigger]')) {
+                const child = getElementChild(this.element.parentNode, '[data-kt-menu-trigger]');
+                if (child) {
+                    this.triggerElement = child;
+                }
+            }
+            if (this.triggerElement) {
+                DataUtil.set(this.triggerElement, 'menu', this);
+            }
+        };
+        // Test if menu has external trigger element
+        this._isTriggerElement = (item) => {
+            return this.triggerElement === item;
+        };
+        // Get item option(through html attributes)
+        this._getItemOption = (item, name) => {
+            let value = null;
+            if (item && item.hasAttribute('data-kt-menu-' + name)) {
+                const attr = item.getAttribute('data-kt-menu-' + name) || '';
+                value = getAttributeValueByBreakpoint(attr);
+                if (value !== null && String(value) === 'true') {
+                    value = true;
+                }
+                else if (value !== null && String(value) === 'false') {
+                    value = false;
+                }
+            }
+            return value;
+        };
+        // Get item element
+        this._getItemElement = (_element) => {
+            // Element is the external trigger element
+            if (this._isTriggerElement(_element)) {
+                return _element;
+            }
+            // Element has item toggler attribute
+            if (_element.hasAttribute('data-kt-menu-trigger')) {
+                return _element;
+            }
+            // Element has item DOM reference in it's data storage
+            const itemElement = DataUtil.get(_element, 'item');
+            if (itemElement) {
+                return itemElement;
+            }
+            // Item is parent of element
+            const item = _element.closest('.menu-item[data-kt-menu-trigger]');
+            if (item) {
+                return item;
+            }
+            // Element's parent has item DOM reference in it's data storage
+            const sub = _element.closest('.menu-sub');
+            if (sub) {
+                const subItem = DataUtil.get(sub, 'item');
+                if (subItem) {
+                    return subItem;
+                }
+            }
+        };
+        // Get item parent element
+        this._getItemParentElement = (item) => {
+            const sub = item.closest('.menu-sub');
+            if (!sub) {
+                return null;
+            }
+            const subItem = DataUtil.get(sub, 'item');
+            if (subItem) {
+                return subItem;
+            }
+            const parentItem = sub.closest('.menu-item[data-kt-menu-trigger]');
+            if (sub && parentItem) {
+                return parentItem;
+            }
+            return null;
+        };
+        // Get item parent elements
+        this._getItemParentElements = (item) => {
+            const parents = [];
+            let parent;
+            let i = 0;
+            let buffer = item;
+            do {
+                parent = this._getItemParentElement(buffer);
+                if (parent) {
+                    parents.push(parent);
+                    buffer = parent;
+                }
+                i++;
+            } while (parent !== null && i < 20);
+            if (this.triggerElement) {
+                parents.unshift(this.triggerElement);
+            }
+            return parents;
+        };
+        // Prepare popper config for dropdown(see: https://popper.js.org/docs/v2/)
+        this._getDropdownPopperConfig = (item) => {
+            // Placement
+            const placementOption = this._getItemOption(item, 'placement');
+            let placement = 'right';
+            if (placementOption) {
+                placement = placementOption;
+            }
+            // Flip
+            const flipValue = this._getItemOption(item, 'flip');
+            const flip = flipValue ? flipValue.toString().split(',') : [];
+            // Offset
+            const offsetValue = this._getItemOption(item, 'offset');
+            const offset = offsetValue ? offsetValue.toString().split(',') : [];
+            // Strategy
+            const strategy = this._getItemOption(item, 'overflow') === true ? 'absolute' : 'fixed';
+            var altAxis = this._getItemOption(item, 'flip') !== false;
+            return {
+                placement: placement,
+                strategy: strategy,
+                modifiers: [{
+                        name: 'offset',
+                        options: {
+                            offset: offset
+                        }
+                    }, {
+                        name: 'preventOverflow',
+                        options: {
+                            altAxis: altAxis
+                        }
+                    }, {
+                        name: 'flip',
+                        options: {
+                            flipVariations: false
+                        }
+                    }]
+            };
+        };
+        // Get item child element
+        this._getItemChildElement = (item) => {
+            let selector = item;
+            const subItem = DataUtil.get(item, 'sub');
+            if (subItem) {
+                selector = subItem;
+            }
+            if (selector) {
+                //element = selector.querySelector('.show.menu-item[data-kt-menu-trigger]');
+                const element = selector.querySelector('.menu-item[data-kt-menu-trigger]');
+                if (element) {
+                    return element;
+                }
+            }
+            return null;
+        };
+        // Get item child elements
+        this._getItemChildElements = (item) => {
+            const children = [];
+            let child;
+            let i = 0;
+            let buffer = item;
+            do {
+                child = this._getItemChildElement(buffer);
+                if (child) {
+                    children.push(child);
+                    buffer = child;
+                }
+                i++;
+            } while (child !== null && i < 20);
+            return children;
+        };
+        // Get item sub element
+        this._getItemSubElement = (item) => {
+            if (!item) {
+                return null;
+            }
+            if (this._isTriggerElement(item)) {
+                return this.element;
+            }
+            if (item.classList.contains('menu-sub')) {
+                return item;
+            }
+            else if (DataUtil.has(item, 'sub')) {
+                return DataUtil.get(item, 'sub');
+            }
+            else {
+                return getElementChild(item, '.menu-sub');
+            }
+        };
+        this._getCss = (el, styleProp) => {
+            const defaultView = (el.ownerDocument || document).defaultView;
+            if (!defaultView) {
+                return '';
+            }
+            // sanitize property name to css notation
+            // (hyphen separated words eg. font-Size)
+            styleProp = styleProp.replace(/([A-Z])/g, '-$1').toLowerCase();
+            return defaultView.getComputedStyle(el, null).getPropertyValue(styleProp);
+        };
+        // Get item sub type
+        this._getItemSubType = (element) => {
+            const sub = this._getItemSubElement(element);
+            if (sub && parseInt(this._getCss(sub, 'z-index')) > 0) {
+                return 'dropdown';
+            }
+            else {
+                return 'accordion';
+            }
+        };
+        // Test if item's sub is shown
+        this._isItemSubShown = (item) => {
+            let sub = this._getItemSubElement(item);
+            if (sub) {
+                if (this._getItemSubType(item) === 'dropdown') {
+                    return sub.classList.contains('show') && sub.hasAttribute('data-popper-placement');
+                }
+                else {
+                    return item.classList.contains('show');
+                }
+            }
+            return false;
+        };
+        // Test if item dropdown is permanent
+        this._isItemDropdownPermanent = (item) => {
+            return this._getItemOption(item, 'permanent') === true;
+        };
+        // Test if item's parent is shown
+        this._isItemParentShown = (item) => {
+            return getElementParents(item, '.menu-item.show').length > 0;
+        };
+        // Test of it is item sub element
+        this._isItemSubElement = (item) => {
+            return item.classList.contains('menu-sub');
+        };
+        // Test if item has sub
+        this._hasItemSub = (item) => {
+            return item.classList.contains('menu-item') && item.hasAttribute('data-kt-menu-trigger');
+        };
+        // Get link element
+        this._getItemLinkElement = (item) => {
+            return getElementChild(item, '.menu-link');
+        };
+        // Get toggle element
+        this._getItemToggleElement = (item) => {
+            if (this.triggerElement) {
+                return this.triggerElement;
+            }
+            return this._getItemLinkElement(item);
+        };
+        // Show item dropdown
+        this._showDropdown = (item) => {
+            if (EventHandlerUtil.trigger(this.element, 'kt.menu.dropdown.show') === false) {
+                return;
+            }
+            // Hide all currently shown dropdowns except current one
+            MenuComponent.hideDropdowns(item);
+            // const toggle = this._isTriggerElement(item) ? item : this._getItemLinkElement(item);
+            const sub = this._getItemSubElement(item);
+            const width = this._getItemOption(item, 'width');
+            const height = this._getItemOption(item, 'height');
+            let zindex = this.options.dropdown.zindex;
+            const parentZindex = getHighestZindex(item); // update
+            // Apply a new z-index if dropdown's toggle element or it's parent has greater z-index // update
+            if (parentZindex !== null && parentZindex >= zindex) {
+                zindex = parentZindex + 1;
+            }
+            if (zindex) {
+                ElementStyleUtil.set(sub, 'z-index', zindex);
+            }
+            if (width) {
+                ElementStyleUtil.set(sub, 'width', width);
+            }
+            if (height) {
+                ElementStyleUtil.set(sub, 'height', height);
+            }
+            this.initDropdownPopper(item, sub);
+            item.classList.add('show');
+            item.classList.add('menu-dropdown');
+            sub.classList.add('show');
+            // Append the sub the the root of the menu
+            if (this._getItemOption(item, 'overflow') === true) {
+                document.body.appendChild(sub);
+                DataUtil.set(item, 'sub', sub);
+                DataUtil.set(sub, 'item', item);
+                DataUtil.set(sub, 'menu', this);
+            }
+            else {
+                DataUtil.set(sub, 'item', item);
+            }
+            EventHandlerUtil.trigger(this.element, 'kt.menu.dropdown.shown');
+        };
+        // Init dropdown popper(new)
+        this.initDropdownPopper = (item, sub) => {
+            // Setup popper instance
+            let reference;
+            const attach = this._getItemOption(item, 'attach');
+            if (attach) {
+                if (attach === 'parent') {
+                    reference = item.parentNode;
+                }
+                else {
+                    reference = document.querySelector(attach);
+                }
+            }
+            else {
+                reference = item;
+            }
+            if (reference) {
+                const popper = createPopper(reference, sub, this._getDropdownPopperConfig(item));
+                DataUtil.set(item, 'popper', popper);
+            }
+        };
+        // Hide item dropdown
+        this._hideDropdown = (item) => {
+            if (EventHandlerUtil.trigger(this.element, 'kt.menu.dropdown.hide') === false) {
+                return;
+            }
+            const sub = this._getItemSubElement(item);
+            ElementStyleUtil.set(sub, 'z-index', '');
+            ElementStyleUtil.set(sub, 'width', '');
+            ElementStyleUtil.set(sub, 'height', '');
+            item.classList.remove('show');
+            item.classList.remove('menu-dropdown');
+            sub.classList.remove('show');
+            // Append the sub back to it's parent
+            if (this._getItemOption(item, 'overflow') === true) {
+                if (item.classList.contains('menu-item')) {
+                    item.appendChild(sub);
+                }
+                else {
+                    insertAfterElement(this.element, item);
+                }
+                DataUtil.remove(item, 'sub');
+                DataUtil.remove(sub, 'item');
+                DataUtil.remove(sub, 'menu');
+            }
+            if (DataUtil.has(item, 'popper') === true) {
+                DataUtil.get(item, 'popper').destroy();
+                DataUtil.remove(item, 'popper');
+            }
+            // Destroy popper(new)
+            this.destroyDropdownPopper(item);
+            EventHandlerUtil.trigger(this.element, 'kt.menu.dropdown.hidden');
+        };
+        // Destroy dropdown popper(new)
+        this.destroyDropdownPopper = (item) => {
+            if (DataUtil.has(item, 'popper') === true) {
+                DataUtil.get(item, 'popper').destroy();
+                DataUtil.remove(item, 'popper');
+            }
+            EventHandlerUtil.trigger(this.element, 'kt.menu.dropdown.hidden');
+        };
+        this._showAccordion = (item) => {
+            if (EventHandlerUtil.trigger(this.element, 'kt.menu.accordion.show') === false) {
+                return;
+            }
+            if (this.options.accordion.expand === false) {
+                this._hideAccordions(item);
+            }
+            if (DataUtil.has(item, 'popper') === true) {
+                this._hideDropdown(item);
+            }
+            item.classList.add('hover'); // updateWW
+            item.classList.add('showing');
+            const subElement = this._getItemSubElement(item);
+            if (subElement) {
+                const sub = subElement;
+                slideDown(sub, this.options.accordion.slideSpeed, () => {
+                    item.classList.remove('showing');
+                    item.classList.add('show');
+                    sub.classList.add('show');
+                    EventHandlerUtil.trigger(this.element, 'kt.menu.accordion.shown');
+                });
+            }
+        };
+        this._hideAccordion = (item) => {
+            if (EventHandlerUtil.trigger(this.element, 'kt.menu.accordion.hide') === false) {
+                return;
+            }
+            const sub = this._getItemSubElement(item);
+            item.classList.add('hiding');
+            if (sub) {
+                slideUp(sub, this.options.accordion.slideSpeed, () => {
+                    item.classList.remove('hiding');
+                    item.classList.remove('show');
+                    sub.classList.remove('show');
+                    item.classList.remove('hover'); // update
+                    EventHandlerUtil.trigger(this.element, 'kt.menu.accordion.hidden');
+                });
+            }
+        };
+        // Hide all shown accordions of item
+        this._hideAccordions = (item) => {
+            const itemsToHide = this.element.querySelectorAll('.show[data-kt-menu-trigger]');
+            if (itemsToHide && itemsToHide.length > 0) {
+                for (var i = 0, len = itemsToHide.length; i < len; i++) {
+                    const itemToHide = itemsToHide[i];
+                    if (this._getItemSubType(itemToHide) === 'accordion' &&
+                        itemToHide !== item &&
+                        item.contains(itemToHide) === false &&
+                        itemToHide.contains(item) === false) {
+                        this._hideAccordion(itemToHide);
+                    }
+                }
+            }
+        };
+        // Event Handlers
+        // Reset item state classes if item sub type changed
+        this._reset = (item) => {
+            if (this._hasItemSub(item) === false) {
+                return;
+            }
+            const sub = this._getItemSubElement(item);
+            // Reset sub state if sub type is changed during the window resize
+            if (DataUtil.has(item, 'type') && DataUtil.get(item, 'type') !== this._getItemSubType(item)) {
+                // updated
+                item.classList.remove('hover');
+                item.classList.remove('show');
+                item.classList.remove('show');
+                if (sub && sub.removeClass) {
+                    sub.removeClass(sub, 'show');
+                }
+            } // updated
+        };
+        // TODO: not done
+        this._destroy = () => { };
+        // Update all item state classes if item sub type changed
+        this._update = () => {
+            const items = this.element.querySelectorAll('.menu-item[data-kt-menu-trigger]');
+            items.forEach((el) => this._reset(el));
+        };
+        // Hide item sub
+        this._hide = (item) => {
+            if (!item) {
+                return;
+            }
+            if (this._isItemSubShown(item) === false) {
+                return;
+            }
+            if (this._getItemSubType(item) === 'dropdown') {
+                this._hideDropdown(item);
+            }
+            else if (this._getItemSubType(item) === 'accordion') {
+                this._hideAccordion(item);
+            }
+        };
+        // Show item sub
+        this._show = (item) => {
+            if (!item) {
+                return;
+            }
+            if (this._isItemSubShown(item) === true) {
+                return;
+            }
+            if (this._getItemSubType(item) === 'dropdown') {
+                this._showDropdown(item); // // show current dropdown
+            }
+            else if (this._getItemSubType(item) === 'accordion') {
+                this._showAccordion(item);
+            }
+            // Remember last submenu type
+            DataUtil.set(item, 'type', this._getItemSubType(item)); // updated
+        };
+        // Toggle item sub
+        this._toggle = (item) => {
+            if (!item) {
+                return;
+            }
+            if (this._isItemSubShown(item) === true) {
+                this._hide(item);
+            }
+            else {
+                this._show(item);
+            }
+        };
+        // Mouseout handle
+        this._mouseout = (element, e) => {
+            const item = this._getItemElement(element);
+            if (!item) {
+                return;
+            }
+            if (this._getItemOption(item, 'trigger') !== 'hover') {
+                return;
+            }
+            const timeout = setTimeout(() => {
+                if (DataUtil.get(item, 'hover') === '1') {
+                    this._hide(item);
+                }
+            }, this.options.dropdown.hoverTimeout);
+            DataUtil.set(item, 'hover', '1');
+            DataUtil.set(item, 'timeout', timeout);
+        };
+        // Mouseover handle
+        this._mouseover = (element, e) => {
+            const item = this._getItemElement(element);
+            if (!item) {
+                return;
+            }
+            if (this._getItemOption(item, 'trigger') !== 'hover') {
+                return;
+            }
+            if (DataUtil.get(item, 'hover') === '1') {
+                clearTimeout(DataUtil.get(item, 'timeout'));
+                DataUtil.remove(item, 'hover');
+                DataUtil.remove(item, 'timeout');
+            }
+            this._show(item);
+        };
+        // Dismiss handler
+        this._dismiss = (element, e) => {
+            const item = this._getItemElement(element);
+            const items = this._getItemChildElements(item);
+            //if ( item !== null && _getItemOption(item, 'trigger') === 'click' &&  _getItemSubType(item) === 'dropdown' ) {
+            const itemSubType = this._getItemSubType(item);
+            if (item !== null && itemSubType === 'dropdown') {
+                this._hide(item); // hide items dropdown
+                // Hide all child elements as well
+                if (items.length > 0) {
+                    for (let i = 0, len = items.length; i < len; i++) {
+                        //if ( _getItemOption(item, 'trigger') === 'click' &&  _getItemSubType(item) === 'dropdown' ) {
+                        if (items[i] !== null && this._getItemSubType(items[i]) === 'dropdown') {
+                            this._hide(items[i]);
+                        }
+                    }
+                }
+            }
+        };
+        // Link handler
+        this._link = (element, e) => {
+            if (EventHandlerUtil.trigger(this.element, 'kt.menu.link.click') === false) {
+                return;
+            }
+            // Dismiss all shown dropdowns
+            MenuComponent.hideDropdowns(undefined);
+            EventHandlerUtil.trigger(this.element, 'kt.menu.link.clicked');
+        };
+        this._click = (element, e) => {
+            e.preventDefault();
+            const item = this._getItemElement(element);
+            if (this._getItemOption(item, 'trigger') !== 'click') {
+                return;
+            }
+            if (this._getItemOption(item, 'toggle') === false) {
+                this._show(item);
+            }
+            else {
+                this._toggle(item);
+            }
+        };
+        ///////////////////////
+        // ** Public API  ** //
+        ///////////////////////
+        this.click = (element, e) => {
+            return this._click(element, e);
+        };
+        this.link = (element, e) => {
+            return this._link(element, e);
+        };
+        this.dismiss = (element, e) => {
+            return this._dismiss(element, e);
+        };
+        this.mouseover = (element, e) => {
+            return this._mouseover(element, e);
+        };
+        this.mouseout = (element, e) => {
+            return this._mouseout(element, e);
+        };
+        // General Methods
+        this.getItemTriggerType = (item) => {
+            return this._getItemOption(item, 'trigger');
+        };
+        this.getItemSubType = (element) => {
+            return this._getItemSubType(element);
+        };
+        this.show = (item) => {
+            return this._show(item);
+        };
+        this.hide = (item) => {
+            return this._hide(item);
+        };
+        this.reset = (item) => {
+            return this._reset(item);
+        };
+        this.update = () => {
+            return this._update();
+        };
+        this.getElement = () => {
+            return this.element;
+        };
+        this.getItemLinkElement = (item) => {
+            return this._getItemLinkElement(item);
+        };
+        this.getItemToggleElement = (item) => {
+            return this._getItemToggleElement(item);
+        };
+        this.getItemSubElement = (item) => {
+            return this._getItemSubElement(item);
+        };
+        this.getItemParentElements = (item) => {
+            return this._getItemParentElements(item);
+        };
+        this.isItemSubShown = (item) => {
+            return this._isItemSubShown(item);
+        };
+        this.isItemParentShown = (item) => {
+            return this._isItemParentShown(item);
+        };
+        this.getTriggerElement = () => {
+            return this.triggerElement;
+        };
+        this.isItemDropdownPermanent = (item) => {
+            return this._isItemDropdownPermanent(item);
+        };
+        // Accordion Mode Methods
+        this.hideAccordions = (item) => {
+            return this._hideAccordions(item);
+        };
+        // Event API
+        this.on = (name, handler) => {
+            return EventHandlerUtil.on(this.element, name, handler);
+        };
+        this.one = (name, handler) => {
+            return EventHandlerUtil.one(this.element, name, handler);
+        };
+        this.off = (name) => {
+            return EventHandlerUtil.off(this.element, name);
+        };
+        this.element = _element;
+        this.options = Object.assign(defaultMenuOptions, options);
+        this.instanceUid = getUniqueIdWithPrefix('menu');
+        // this.element.setAttribute('data-kt-menu', 'true')
+        this._setTriggerElement();
+        this._update();
+        DataUtil.set(this.element, 'menu', this);
+        return this;
+    }
+}
+// public static methods
+// Get KTMenu instance by element
+MenuComponent.getInstance = (element) => {
+    // Element has menu DOM reference in it's DATA storage
+    const elementMenu = DataUtil.get(element, 'menu');
+    if (elementMenu) {
+        return elementMenu;
+    }
+    // Element has .menu parent
+    const menu = element.closest('.menu');
+    if (menu) {
+        const menuData = DataUtil.get(menu, 'menu');
+        if (menuData) {
+            return menuData;
+        }
+    }
+    // Element has a parent with DOM reference to .menu in it's DATA storage
+    if (element.classList.contains('menu-link')) {
+        const sub = element.closest('.menu-sub');
+        if (sub) {
+            const subMenu = DataUtil.get(sub, 'menu');
+            if (subMenu) {
+                return subMenu;
+            }
+        }
+    }
+    return null;
+};
+// Hide all dropdowns and skip one if provided
+MenuComponent.hideDropdowns = (skip) => {
+    const items = document.querySelectorAll('.show.menu-dropdown[data-kt-menu-trigger]');
+    if (items && items.length > 0) {
+        for (let i = 0, len = items.length; i < len; i++) {
+            const item = items[i];
+            const menu = MenuComponent.getInstance(item);
+            if (menu && menu.getItemSubType(item) === 'dropdown') {
+                if (skip) {
+                    if (menu.getItemSubElement(item).contains(skip) === false &&
+                        item.contains(skip) === false &&
+                        item !== skip) {
+                        menu.hide(item);
+                    }
+                }
+                else {
+                    menu.hide(item);
+                }
+            }
+        }
+    }
+};
+MenuComponent.updateDropdowns = () => {
+    const items = document.querySelectorAll('.show.menu-dropdown[data-kt-menu-trigger]');
+    if (items && items.length > 0) {
+        for (var i = 0, len = items.length; i < len; i++) {
+            var item = items[i];
+            if (DataUtil.has(item, 'popper')) {
+                DataUtil.get(item, 'popper').forceUpdate();
+            }
+        }
+    }
+};
+// Global handlers
+MenuComponent.createInstances = (selector) => {
+    // Initialize menus
+    document.querySelectorAll(selector).forEach((el) => {
+        const menuItem = el;
+        let menuInstance = MenuComponent.getInstance(menuItem);
+        if (!menuInstance) {
+            menuInstance = new MenuComponent(el, defaultMenuOptions);
+        }
+    });
+};
+MenuComponent.initGlobalHandlers = () => {
+    // Dropdown handler
+    document.addEventListener('click', (e) => {
+        const menuItems = document.querySelectorAll('.show.menu-dropdown[data-kt-menu-trigger]');
+        if (menuItems && menuItems.length > 0) {
+            for (let i = 0; i < menuItems.length; i++) {
+                const item = menuItems[i];
+                const menuObj = MenuComponent.getInstance(item);
+                if (menuObj && menuObj.getItemSubType(item) === 'dropdown') {
+                    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+                    const menu = menuObj.getElement();
+                    const sub = menuObj.getItemSubElement(item);
+                    if (item === e.target || item.contains(e.target)) {
+                        continue;
+                    }
+                    if (sub && (sub === e.target || sub.contains(e.target))) {
+                        continue;
+                    }
+                    menuObj.hide(item);
+                }
+            }
+        }
+    });
+    // Sub toggle handler
+    DOMEventHandlerUtil.on(document.body, '.menu-item[data-kt-menu-trigger] > .menu-link, [data-kt-menu-trigger]:not(.menu-item):not([data-kt-menu-trigger="auto"])', 'click', function (e) {
+        const menu = MenuComponent.getInstance(this);
+        if (menu) {
+            return menu.click(this, e);
+        }
+    });
+    // // Link handler
+    DOMEventHandlerUtil.on(document.body, '.menu-item:not([data-kt-menu-trigger]) > .menu-link', 'click', function (e) {
+        e.stopPropagation();
+        const menu = MenuComponent.getInstance(this);
+        if (menu && menu.link) {
+            return menu.link(this, e);
+        }
+    });
+    // Dismiss handler
+    DOMEventHandlerUtil.on(document.body, '[data-kt-menu-dismiss="true"]', 'click', function (e) {
+        const menu = MenuComponent.getInstance(this);
+        if (menu) {
+            return menu.dismiss(this, e);
+        }
+    });
+    // Mouseover handler
+    DOMEventHandlerUtil.on(document.body, '[data-kt-menu-trigger], .menu-sub', 'mouseover', function (e) {
+        const menu = MenuComponent.getInstance(this);
+        if (menu && menu.getItemSubType(this) === 'dropdown') {
+            return menu.mouseover(this, e);
+        }
+    });
+    // Mouseout handler
+    DOMEventHandlerUtil.on(document.body, '[data-kt-menu-trigger], .menu-sub', 'mouseout', function (e) {
+        const menu = MenuComponent.getInstance(this);
+        if (menu && menu.getItemSubType(this) === 'dropdown') {
+            return menu.mouseout(this, e);
+        }
+    });
+    // Resize handler
+    window.addEventListener('resize', () => {
+        let timer;
+        throttle(timer, () => {
+            // Locate and update Drawer instances on window resize
+            const elements = document.querySelectorAll('[data-kt-menu="true"]');
+            elements.forEach((el) => {
+                const menu = MenuComponent.getInstance(el);
+                if (menu) {
+                    menu.update();
+                }
+            });
+        }, 200);
+    });
+};
+MenuComponent.bootstrap = () => {
+    MenuComponent.initGlobalHandlers();
+    MenuComponent.createInstances('[data-kt-menu="true"]');
+};
+MenuComponent.reinitialization = () => {
+    MenuComponent.createInstances('[data-kt-menu="true"]');
+};
+MenuComponent.createInsance = (selector, options = defaultMenuOptions) => {
+    const element = document.body.querySelector(selector);
+    if (!element) {
+        return;
+    }
+    const item = element;
+    let menu = MenuComponent.getInstance(item);
+    if (!menu) {
+        menu = new MenuComponent(item, options);
+    }
+    return menu;
+};
+export { MenuComponent, defaultMenuOptions };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"MenuComponent.js","sourceRoot":"","sources":["../../../../../../../projects/bbsf-admin-portal/src/lib/_metronic/core/components/MenuComponent.ts"],"names":[],"mappings":"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","sourcesContent":["import {createPopper, VirtualElement} from '@popperjs/core'\r\n\r\nimport { getAttributeValueByBreakpoint, getCSS, getElementChild, getElementParents, getHighestZindex, insertAfterElement, slideDown, slideUp, throttle } from \"../_utils/DomHelpers\"\r\nimport { EventHandlerUtil } from \"../_utils/EventHandlerUtil\"\r\nimport { DataUtil } from \"../_utils/_DataUtil\"\r\nimport { DOMEventHandlerUtil } from \"../_utils/_DOMEventHandlerUtil\"\r\nimport { ElementStyleUtil } from \"../_utils/_ElementStyleUtil\"\r\nimport { getObjectPropertyValueByKey, getUniqueIdWithPrefix, stringSnakeToCamel } from \"../_utils/_TypesHelpers\"\r\n\r\nexport interface MenuOptions {\r\n  dropdown: {\r\n    hoverTimeout: number\r\n    zindex: number\r\n  }\r\n  accordion: {\r\n    slideSpeed: number\r\n    expand: boolean\r\n  }\r\n}\r\n\r\nconst defaultMenuOptions: MenuOptions = {\r\n  dropdown: {\r\n    hoverTimeout: 200,\r\n    zindex: 105,\r\n  },\r\n  accordion: {\r\n    slideSpeed: 250,\r\n    expand: false,\r\n  },\r\n}\r\n\r\ntype PopperPlacement =\r\n  | 'right'\r\n  | 'auto'\r\n  | 'auto-start'\r\n  | 'auto-end'\r\n  | 'top'\r\n  | 'bottom'\r\n  | 'left'\r\n  | 'top-start'\r\n  | 'top-end'\r\n  | 'bottom-start'\r\n  | 'bottom-end'\r\n  | 'right-start'\r\n  | 'right-end'\r\n  | 'left-start'\r\n  | 'left-end'\r\n  | undefined\r\n\r\nclass MenuComponent {\r\n  element: HTMLElement\r\n  options: MenuOptions\r\n  instanceUid: string\r\n  triggerElement: HTMLElement | null = null\r\n\r\n  constructor(_element: HTMLElement, options: MenuOptions) {\r\n    this.element = _element\r\n    this.options = Object.assign(defaultMenuOptions, options)\r\n    this.instanceUid = getUniqueIdWithPrefix('menu')\r\n    // this.element.setAttribute('data-kt-menu', 'true')\r\n    this._setTriggerElement()\r\n    this._update()\r\n    DataUtil.set(this.element, 'menu', this)\r\n    return this\r\n  }\r\n\r\n  // Set external trigger element\r\n  private _setTriggerElement = () => {\r\n    const target = document.querySelector(\r\n      `[data-kt-menu-target=\"#${this.element.getAttribute('id')}\"`\r\n    )\r\n\r\n    if (target) {\r\n      this.triggerElement = target as HTMLElement\r\n    } else if (this.element.closest('[data-kt-menu-trigger]')) {\r\n      this.triggerElement = this.element.closest('[data-kt-menu-trigger]') as HTMLElement\r\n    } else if (\r\n      this.element.parentNode &&\r\n      getElementChild(this.element.parentNode as HTMLElement, '[data-kt-menu-trigger]')\r\n    ) {\r\n      const child = getElementChild(\r\n        this.element.parentNode as HTMLElement,\r\n        '[data-kt-menu-trigger]'\r\n      )\r\n      if (child) {\r\n        this.triggerElement = child\r\n      }\r\n    }\r\n\r\n    if (this.triggerElement) {\r\n      DataUtil.set(this.triggerElement, 'menu', this)\r\n    }\r\n  }\r\n\r\n  // Test if menu has external trigger element\r\n  private _isTriggerElement = (item: HTMLElement) => {\r\n    return this.triggerElement === item\r\n  }\r\n\r\n  // Get item option(through html attributes)\r\n  private _getItemOption = (item: HTMLElement, name: string) => {\r\n    let value = null\r\n    if (item && item.hasAttribute('data-kt-menu-' + name)) {\r\n      const attr = item.getAttribute('data-kt-menu-' + name) || ''\r\n      value = getAttributeValueByBreakpoint(attr)\r\n      if (value !== null && String(value) === 'true') {\r\n        value = true\r\n      } else if (value !== null && String(value) === 'false') {\r\n        value = false\r\n      }\r\n    }\r\n    return value\r\n  }\r\n\r\n  // Get item element\r\n  private _getItemElement = (_element: HTMLElement) => {\r\n    // Element is the external trigger element\r\n    if (this._isTriggerElement(_element)) {\r\n      return _element\r\n    }\r\n\r\n    // Element has item toggler attribute\r\n    if (_element.hasAttribute('data-kt-menu-trigger')) {\r\n      return _element\r\n    }\r\n\r\n    // Element has item DOM reference in it's data storage\r\n    const itemElement = DataUtil.get(_element, 'item')\r\n    if (itemElement) {\r\n      return itemElement\r\n    }\r\n\r\n    // Item is parent of element\r\n    const item = _element.closest('.menu-item[data-kt-menu-trigger]')\r\n    if (item) {\r\n      return item\r\n    }\r\n\r\n    // Element's parent has item DOM reference in it's data storage\r\n    const sub = _element.closest('.menu-sub')\r\n    if (sub) {\r\n      const subItem = DataUtil.get(sub as HTMLElement, 'item')\r\n      if (subItem) {\r\n        return subItem\r\n      }\r\n    }\r\n  }\r\n\r\n  // Get item parent element\r\n  private _getItemParentElement = (item: HTMLElement) => {\r\n    const sub = item.closest('.menu-sub')\r\n    if (!sub) {\r\n      return null\r\n    }\r\n\r\n    const subItem = DataUtil.get(sub as HTMLElement, 'item')\r\n    if (subItem) {\r\n      return subItem\r\n    }\r\n\r\n    const parentItem = sub.closest('.menu-item[data-kt-menu-trigger]')\r\n    if (sub && parentItem) {\r\n      return parentItem\r\n    }\r\n\r\n    return null\r\n  }\r\n\r\n  // Get item parent elements\r\n  private _getItemParentElements = (item: HTMLElement) => {\r\n    const parents = []\r\n    let parent\r\n    let i = 0\r\n    let buffer = item\r\n\r\n    do {\r\n      parent = this._getItemParentElement(buffer)\r\n      if (parent) {\r\n        parents.push(parent)\r\n        buffer = parent\r\n      }\r\n\r\n      i++\r\n    } while (parent !== null && i < 20)\r\n\r\n    if (this.triggerElement) {\r\n      parents.unshift(this.triggerElement)\r\n    }\r\n\r\n    return parents\r\n  }\r\n\r\n  // Prepare popper config for dropdown(see: https://popper.js.org/docs/v2/)\r\n  private _getDropdownPopperConfig = (item: HTMLElement) => {\r\n    // Placement\r\n    const placementOption = this._getItemOption(item, 'placement')\r\n    let placement: PopperPlacement = 'right'\r\n    if (placementOption) {\r\n      placement = placementOption as PopperPlacement\r\n    }\r\n\r\n    // Flip\r\n    const flipValue = this._getItemOption(item, 'flip')\r\n    const flip = flipValue ? flipValue.toString().split(',') : []\r\n\r\n    // Offset\r\n    const offsetValue = this._getItemOption(item, 'offset')\r\n    const offset = offsetValue ? offsetValue.toString().split(',') : []\r\n\r\n    // Strategy\r\n    const strategy: 'absolute' | 'fixed' | undefined =\r\n      this._getItemOption(item, 'overflow') === true ? 'absolute' : 'fixed'\r\n\r\n    var altAxis = this._getItemOption(item, 'flip') !== false;\r\n\r\n    return {\r\n      placement: placement,\r\n      strategy: strategy,\r\n      modifiers: [{\r\n        name: 'offset',\r\n        options: {\r\n          offset: offset\r\n        }\r\n      }, {\r\n        name: 'preventOverflow',\r\n        options: {\r\n          altAxis: altAxis\r\n        }\r\n      }, {\r\n        name: 'flip',\r\n        options: {\r\n          flipVariations: false\r\n        }\r\n      }]\r\n    };\r\n  }\r\n\r\n  // Get item child element\r\n  private _getItemChildElement = (item: HTMLElement) => {\r\n    let selector = item\r\n\r\n    const subItem = DataUtil.get(item, 'sub')\r\n    if (subItem) {\r\n      selector = subItem\r\n    }\r\n\r\n    if (selector) {\r\n      //element = selector.querySelector('.show.menu-item[data-kt-menu-trigger]');\r\n      const element = selector.querySelector('.menu-item[data-kt-menu-trigger]')\r\n      if (element) {\r\n        return element\r\n      }\r\n    }\r\n    return null\r\n  }\r\n\r\n  // Get item child elements\r\n  private _getItemChildElements = (item: HTMLElement) => {\r\n    const children = []\r\n    let child\r\n    let i = 0\r\n    let buffer = item\r\n    do {\r\n      child = this._getItemChildElement(buffer)\r\n      if (child) {\r\n        children.push(child)\r\n        buffer = child as HTMLElement\r\n      }\r\n\r\n      i++\r\n    } while (child !== null && i < 20)\r\n\r\n    return children\r\n  }\r\n\r\n  // Get item sub element\r\n  private _getItemSubElement = (item: HTMLElement) => {\r\n    if (!item) {\r\n      return null\r\n    }\r\n\r\n    if (this._isTriggerElement(item)) {\r\n      return this.element\r\n    }\r\n\r\n    if (item.classList.contains('menu-sub')) {\r\n      return item\r\n    } else if (DataUtil.has(item, 'sub')) {\r\n      return DataUtil.get(item, 'sub')\r\n    } else {\r\n      return getElementChild(item, '.menu-sub')\r\n    }\r\n  }\r\n\r\n  private _getCss = (el: HTMLElement, styleProp: string) => {\r\n    const defaultView = (el.ownerDocument || document).defaultView\r\n    if (!defaultView) {\r\n      return ''\r\n    }\r\n\r\n    // sanitize property name to css notation\r\n    // (hyphen separated words eg. font-Size)\r\n    styleProp = styleProp.replace(/([A-Z])/g, '-$1').toLowerCase()\r\n\r\n    return defaultView.getComputedStyle(el, null).getPropertyValue(styleProp)\r\n  }\r\n\r\n  // Get item sub type\r\n  private _getItemSubType = (element: HTMLElement) => {\r\n    const sub = this._getItemSubElement(element)\r\n    if (sub && parseInt(this._getCss(sub, 'z-index')) > 0) {\r\n      return 'dropdown'\r\n    } else {\r\n      return 'accordion'\r\n    }\r\n  }\r\n\r\n  // Test if item's sub is shown\r\n  private _isItemSubShown = (item: HTMLElement) => {\r\n    let sub = this._getItemSubElement(item)\r\n    if (sub) {\r\n      if (this._getItemSubType(item) === 'dropdown') {\r\n        return sub.classList.contains('show') && sub.hasAttribute('data-popper-placement')\r\n      } else {\r\n        return item.classList.contains('show')\r\n      }\r\n    }\r\n\r\n    return false\r\n  }\r\n\r\n  // Test if item dropdown is permanent\r\n  private _isItemDropdownPermanent = (item: HTMLElement) => {\r\n    return this._getItemOption(item, 'permanent') === true\r\n  }\r\n\r\n  // Test if item's parent is shown\r\n  private _isItemParentShown = (item: HTMLElement) => {\r\n    return getElementParents(item, '.menu-item.show').length > 0\r\n  }\r\n\r\n  // Test of it is item sub element\r\n  private _isItemSubElement = (item: HTMLElement) => {\r\n    return item.classList.contains('menu-sub')\r\n  }\r\n\r\n  // Test if item has sub\r\n  private _hasItemSub = (item: HTMLElement) => {\r\n    return item.classList.contains('menu-item') && item.hasAttribute('data-kt-menu-trigger')\r\n  }\r\n\r\n  // Get link element\r\n  private _getItemLinkElement = (item: HTMLElement) => {\r\n    return getElementChild(item, '.menu-link')\r\n  }\r\n\r\n  // Get toggle element\r\n  private _getItemToggleElement = (item: HTMLElement) => {\r\n    if (this.triggerElement) {\r\n      return this.triggerElement\r\n    }\r\n\r\n    return this._getItemLinkElement(item)\r\n  }\r\n\r\n  // Show item dropdown\r\n  private _showDropdown = (item: HTMLElement) => {\r\n    if (EventHandlerUtil.trigger(this.element, 'kt.menu.dropdown.show') === false) {\r\n      return\r\n    }\r\n\r\n    // Hide all currently shown dropdowns except current one\r\n    MenuComponent.hideDropdowns(item)\r\n\r\n    // const toggle = this._isTriggerElement(item) ? item : this._getItemLinkElement(item);\r\n    const sub = this._getItemSubElement(item)\r\n    const width = this._getItemOption(item, 'width')\r\n    const height = this._getItemOption(item, 'height')\r\n\r\n    let zindex = this.options.dropdown.zindex\r\n    const parentZindex = getHighestZindex(item) // update\r\n    // Apply a new z-index if dropdown's toggle element or it's parent has greater z-index // update\r\n    if (parentZindex !== null && parentZindex >= zindex) {\r\n      zindex = parentZindex + 1\r\n    }\r\n\r\n    if (zindex) {\r\n      ElementStyleUtil.set(sub, 'z-index', zindex)\r\n    }\r\n\r\n    if (width) {\r\n      ElementStyleUtil.set(sub, 'width', width)\r\n    }\r\n\r\n    if (height) {\r\n      ElementStyleUtil.set(sub, 'height', height)\r\n    }\r\n\r\n    this.initDropdownPopper(item, sub)\r\n\r\n    item.classList.add('show')\r\n    item.classList.add('menu-dropdown')\r\n    sub.classList.add('show')\r\n\r\n    // Append the sub the the root of the menu\r\n    if (this._getItemOption(item, 'overflow') === true) {\r\n      document.body.appendChild(sub)\r\n      DataUtil.set(item, 'sub', sub)\r\n      DataUtil.set(sub, 'item', item)\r\n      DataUtil.set(sub, 'menu', this)\r\n    } else {\r\n      DataUtil.set(sub, 'item', item)\r\n    }\r\n\r\n    EventHandlerUtil.trigger(this.element, 'kt.menu.dropdown.shown')\r\n  }\r\n\r\n  // Init dropdown popper(new)\r\n  private initDropdownPopper = (item: HTMLElement, sub: HTMLElement) => {\r\n    // Setup popper instance\r\n    let reference\r\n    const attach = this._getItemOption(item, 'attach') as string\r\n\r\n    if (attach) {\r\n      if (attach === 'parent') {\r\n        reference = item.parentNode\r\n      } else {\r\n        reference = document.querySelector(attach)\r\n      }\r\n    } else {\r\n      reference = item\r\n    }\r\n\r\n    if (reference) {\r\n      const popper = createPopper(\r\n        reference as Element | VirtualElement,\r\n        sub,\r\n        this._getDropdownPopperConfig(item)\r\n      )\r\n      DataUtil.set(item, 'popper', popper)\r\n    }\r\n  }\r\n\r\n  // Hide item dropdown\r\n  private _hideDropdown = (item: HTMLElement) => {\r\n    if (EventHandlerUtil.trigger(this.element, 'kt.menu.dropdown.hide') === false) {\r\n      return\r\n    }\r\n\r\n    const sub = this._getItemSubElement(item)\r\n    ElementStyleUtil.set(sub, 'z-index', '')\r\n    ElementStyleUtil.set(sub, 'width', '')\r\n    ElementStyleUtil.set(sub, 'height', '')\r\n    item.classList.remove('show')\r\n    item.classList.remove('menu-dropdown')\r\n    sub.classList.remove('show')\r\n\r\n    // Append the sub back to it's parent\r\n    if (this._getItemOption(item, 'overflow') === true) {\r\n      if (item.classList.contains('menu-item')) {\r\n        item.appendChild(sub)\r\n      } else {\r\n        insertAfterElement(this.element, item)\r\n      }\r\n\r\n      DataUtil.remove(item, 'sub')\r\n      DataUtil.remove(sub, 'item')\r\n      DataUtil.remove(sub, 'menu')\r\n    }\r\n\r\n    if (DataUtil.has(item, 'popper') === true) {\r\n      DataUtil.get(item, 'popper').destroy()\r\n      DataUtil.remove(item, 'popper')\r\n    }\r\n\r\n    // Destroy popper(new)\r\n    this.destroyDropdownPopper(item)\r\n    EventHandlerUtil.trigger(this.element, 'kt.menu.dropdown.hidden')\r\n  }\r\n\r\n  // Destroy dropdown popper(new)\r\n  private destroyDropdownPopper = (item: HTMLElement) => {\r\n    if (DataUtil.has(item, 'popper') === true) {\r\n      DataUtil.get(item, 'popper').destroy()\r\n      DataUtil.remove(item, 'popper')\r\n    }\r\n\r\n    EventHandlerUtil.trigger(this.element, 'kt.menu.dropdown.hidden')\r\n  }\r\n\r\n  private _showAccordion = (item: HTMLElement) => {\r\n    if (EventHandlerUtil.trigger(this.element, 'kt.menu.accordion.show') === false) {\r\n      return\r\n    }\r\n\r\n    if (this.options.accordion.expand === false) {\r\n      this._hideAccordions(item)\r\n    }\r\n\r\n    if (DataUtil.has(item, 'popper') === true) {\r\n      this._hideDropdown(item)\r\n    }\r\n\r\n    item.classList.add('hover') // updateWW\r\n    item.classList.add('showing')\r\n\r\n    const subElement = this._getItemSubElement(item)\r\n    if (subElement) {\r\n      const sub = subElement as HTMLElement\r\n      slideDown(sub, this.options.accordion.slideSpeed, () => {\r\n        item.classList.remove('showing')\r\n        item.classList.add('show')\r\n        sub.classList.add('show')\r\n        EventHandlerUtil.trigger(this.element, 'kt.menu.accordion.shown')\r\n      })\r\n    }\r\n  }\r\n\r\n  private _hideAccordion = (item: HTMLElement) => {\r\n    if (EventHandlerUtil.trigger(this.element, 'kt.menu.accordion.hide') === false) {\r\n      return\r\n    }\r\n\r\n    const sub = this._getItemSubElement(item)\r\n    item.classList.add('hiding')\r\n\r\n    if (sub) {\r\n      slideUp(sub, this.options.accordion.slideSpeed, () => {\r\n        item.classList.remove('hiding')\r\n        item.classList.remove('show')\r\n        sub.classList.remove('show')\r\n        item.classList.remove('hover') // update\r\n        EventHandlerUtil.trigger(this.element, 'kt.menu.accordion.hidden')\r\n      })\r\n    }\r\n  }\r\n\r\n  // Hide all shown accordions of item\r\n  private _hideAccordions = (item: HTMLElement) => {\r\n    const itemsToHide = this.element.querySelectorAll('.show[data-kt-menu-trigger]')\r\n    if (itemsToHide && itemsToHide.length > 0) {\r\n      for (var i = 0, len = itemsToHide.length; i < len; i++) {\r\n        const itemToHide = itemsToHide[i] as HTMLElement\r\n\r\n        if (\r\n          this._getItemSubType(itemToHide) === 'accordion' &&\r\n          itemToHide !== item &&\r\n          item.contains(itemToHide) === false &&\r\n          itemToHide.contains(item) === false\r\n        ) {\r\n          this._hideAccordion(itemToHide)\r\n        }\r\n      }\r\n    }\r\n  }\r\n\r\n  // Event Handlers\r\n  // Reset item state classes if item sub type changed\r\n  private _reset = (item: HTMLElement) => {\r\n    if (this._hasItemSub(item) === false) {\r\n      return\r\n    }\r\n\r\n    const sub = this._getItemSubElement(item)\r\n\r\n    // Reset sub state if sub type is changed during the window resize\r\n    if (DataUtil.has(item, 'type') && DataUtil.get(item, 'type') !== this._getItemSubType(item)) {\r\n      // updated\r\n      item.classList.remove('hover')\r\n      item.classList.remove('show')\r\n      item.classList.remove('show')\r\n      if (sub && sub.removeClass) {\r\n        sub.removeClass(sub, 'show')\r\n      }\r\n    } // updated\r\n  }\r\n\r\n  // TODO: not done\r\n  private _destroy = () => {}\r\n\r\n  // Update all item state classes if item sub type changed\r\n  private _update = () => {\r\n    const items = this.element.querySelectorAll('.menu-item[data-kt-menu-trigger]')\r\n    items.forEach((el) => this._reset(el as HTMLElement))\r\n  }\r\n\r\n  // Hide item sub\r\n  private _hide = (item: HTMLElement) => {\r\n    if (!item) {\r\n      return\r\n    }\r\n\r\n    if (this._isItemSubShown(item) === false) {\r\n      return\r\n    }\r\n\r\n    if (this._getItemSubType(item) === 'dropdown') {\r\n      this._hideDropdown(item)\r\n    } else if (this._getItemSubType(item) === 'accordion') {\r\n      this._hideAccordion(item)\r\n    }\r\n  }\r\n\r\n  // Show item sub\r\n  private _show = (item: HTMLElement) => {\r\n    if (!item) {\r\n      return\r\n    }\r\n\r\n    if (this._isItemSubShown(item) === true) {\r\n      return\r\n    }\r\n\r\n    if (this._getItemSubType(item) === 'dropdown') {\r\n      this._showDropdown(item) // // show current dropdown\r\n    } else if (this._getItemSubType(item) === 'accordion') {\r\n      this._showAccordion(item)\r\n    }\r\n\r\n    // Remember last submenu type\r\n\r\n    DataUtil.set(item, 'type', this._getItemSubType(item)) // updated\r\n  }\r\n\r\n  // Toggle item sub\r\n  private _toggle = (item: HTMLElement) => {\r\n    if (!item) {\r\n      return\r\n    }\r\n\r\n    if (this._isItemSubShown(item) === true) {\r\n      this._hide(item)\r\n    } else {\r\n      this._show(item)\r\n    }\r\n  }\r\n\r\n  // Mouseout handle\r\n  private _mouseout = (element: HTMLElement, e: MouseEvent) => {\r\n    const item = this._getItemElement(element)\r\n    if (!item) {\r\n      return\r\n    }\r\n\r\n    if (this._getItemOption(item, 'trigger') !== 'hover') {\r\n      return\r\n    }\r\n\r\n    const timeout = setTimeout(() => {\r\n      if (DataUtil.get(item, 'hover') === '1') {\r\n        this._hide(item)\r\n      }\r\n    }, this.options.dropdown.hoverTimeout)\r\n\r\n    DataUtil.set(item, 'hover', '1')\r\n    DataUtil.set(item, 'timeout', timeout)\r\n  }\r\n\r\n  // Mouseover handle\r\n  private _mouseover = (element: HTMLElement, e: MouseEvent) => {\r\n    const item = this._getItemElement(element)\r\n    if (!item) {\r\n      return\r\n    }\r\n\r\n    if (this._getItemOption(item, 'trigger') !== 'hover') {\r\n      return\r\n    }\r\n\r\n    if (DataUtil.get(item, 'hover') === '1') {\r\n      clearTimeout(DataUtil.get(item, 'timeout'))\r\n      DataUtil.remove(item, 'hover')\r\n      DataUtil.remove(item, 'timeout')\r\n    }\r\n\r\n    this._show(item)\r\n  }\r\n\r\n  // Dismiss handler\r\n  private _dismiss = (element: HTMLElement, e: Event) => {\r\n    const item = this._getItemElement(element)\r\n    const items = this._getItemChildElements(item)\r\n    //if ( item !== null && _getItemOption(item, 'trigger') === 'click' &&  _getItemSubType(item) === 'dropdown' ) {\r\n    const itemSubType = this._getItemSubType(item)\r\n    if (item !== null && itemSubType === 'dropdown') {\r\n      this._hide(item) // hide items dropdown\r\n\r\n      // Hide all child elements as well\r\n      if (items.length > 0) {\r\n        for (let i = 0, len = items.length; i < len; i++) {\r\n          //if ( _getItemOption(item, 'trigger') === 'click' &&  _getItemSubType(item) === 'dropdown' ) {\r\n          if (items[i] !== null && this._getItemSubType(items[i] as HTMLElement) === 'dropdown') {\r\n            this._hide(items[i] as HTMLElement)\r\n          }\r\n        }\r\n      }\r\n    }\r\n  }\r\n\r\n  // Link handler\r\n  private _link = (element: HTMLElement, e: Event) => {\r\n    if (EventHandlerUtil.trigger(this.element, 'kt.menu.link.click') === false) {\r\n      return\r\n    }\r\n\r\n    // Dismiss all shown dropdowns\r\n    MenuComponent.hideDropdowns(undefined)\r\n    EventHandlerUtil.trigger(this.element, 'kt.menu.link.clicked')\r\n  }\r\n\r\n  private _click = (element: HTMLElement, e: Event) => {\r\n    e.preventDefault()\r\n    const item = this._getItemElement(element)\r\n    if (this._getItemOption(item, 'trigger') !== 'click') {\r\n      return\r\n    }\r\n\r\n    if (this._getItemOption(item, 'toggle') === false) {\r\n      this._show(item)\r\n    } else {\r\n      this._toggle(item)\r\n    }\r\n  }\r\n\r\n  ///////////////////////\r\n  // ** Public API  ** //\r\n  ///////////////////////\r\n  public click = (element: HTMLElement, e: Event) => {\r\n    return this._click(element, e)\r\n  }\r\n\r\n  public link = (element: HTMLElement, e: Event) => {\r\n    return this._link(element, e)\r\n  }\r\n\r\n  public dismiss = (element: HTMLElement, e: Event) => {\r\n    return this._dismiss(element, e)\r\n  }\r\n\r\n  public mouseover = (element: HTMLElement, e: Event) => {\r\n    return this._mouseover(element, e as MouseEvent)\r\n  }\r\n\r\n  public mouseout = (element: HTMLElement, e: Event) => {\r\n    return this._mouseout(element, e as MouseEvent)\r\n  }\r\n\r\n  // General Methods\r\n  public getItemTriggerType = (item: HTMLElement) => {\r\n    return this._getItemOption(item, 'trigger')\r\n  }\r\n\r\n  public getItemSubType = (element: HTMLElement) => {\r\n    return this._getItemSubType(element)\r\n  }\r\n\r\n  public show = (item: HTMLElement) => {\r\n    return this._show(item)\r\n  }\r\n\r\n  public hide = (item: HTMLElement) => {\r\n    return this._hide(item)\r\n  }\r\n\r\n  public reset = (item: HTMLElement) => {\r\n    return this._reset(item)\r\n  }\r\n\r\n  public update = () => {\r\n    return this._update()\r\n  }\r\n\r\n  public getElement = () => {\r\n    return this.element\r\n  }\r\n\r\n  public getItemLinkElement = (item: HTMLElement) => {\r\n    return this._getItemLinkElement(item)\r\n  }\r\n\r\n  public getItemToggleElement = (item: HTMLElement) => {\r\n    return this._getItemToggleElement(item)\r\n  }\r\n\r\n  public getItemSubElement = (item: HTMLElement) => {\r\n    return this._getItemSubElement(item)\r\n  }\r\n\r\n  public getItemParentElements = (item: HTMLElement) => {\r\n    return this._getItemParentElements(item)\r\n  }\r\n\r\n  public isItemSubShown = (item: HTMLElement) => {\r\n    return this._isItemSubShown(item)\r\n  }\r\n\r\n  public isItemParentShown = (item: HTMLElement) => {\r\n    return this._isItemParentShown(item)\r\n  }\r\n\r\n  public getTriggerElement = () => {\r\n    return this.triggerElement\r\n  }\r\n\r\n  public isItemDropdownPermanent = (item: HTMLElement) => {\r\n    return this._isItemDropdownPermanent(item)\r\n  }\r\n\r\n  // Accordion Mode Methods\r\n  public hideAccordions = (item: HTMLElement) => {\r\n    return this._hideAccordions(item)\r\n  }\r\n\r\n  // Event API\r\n  public on = (name: string, handler: any) => {\r\n    return EventHandlerUtil.on(this.element, name, handler)\r\n  }\r\n\r\n  public one = (name: string, handler: any) => {\r\n    return EventHandlerUtil.one(this.element, name, handler)\r\n  }\r\n\r\n  public off = (name: string) => {\r\n    return EventHandlerUtil.off(this.element, name)\r\n  }\r\n\r\n  // public static methods\r\n  // Get KTMenu instance by element\r\n  public static getInstance = (element: HTMLElement) => {\r\n    // Element has menu DOM reference in it's DATA storage\r\n    const elementMenu = DataUtil.get(element, 'menu')\r\n    if (elementMenu) {\r\n      return elementMenu\r\n    }\r\n\r\n    // Element has .menu parent\r\n    const menu = element.closest('.menu')\r\n    if (menu) {\r\n      const menuData = DataUtil.get(menu as HTMLElement, 'menu')\r\n      if (menuData) {\r\n        return menuData\r\n      }\r\n    }\r\n\r\n    // Element has a parent with DOM reference to .menu in it's DATA storage\r\n    if (element.classList.contains('menu-link')) {\r\n      const sub = element.closest('.menu-sub')\r\n      if (sub) {\r\n        const subMenu = DataUtil.get(sub as HTMLElement, 'menu')\r\n        if (subMenu) {\r\n          return subMenu\r\n        }\r\n      }\r\n    }\r\n\r\n    return null\r\n  }\r\n\r\n  // Hide all dropdowns and skip one if provided\r\n  public static hideDropdowns = (skip: HTMLElement | undefined) => {\r\n    const items = document.querySelectorAll('.show.menu-dropdown[data-kt-menu-trigger]')\r\n\r\n    if (items && items.length > 0) {\r\n      for (let i = 0, len = items.length; i < len; i++) {\r\n        const item = items[i]\r\n        const menu = MenuComponent.getInstance(item as HTMLElement)\r\n\r\n        if (menu && menu.getItemSubType(item) === 'dropdown') {\r\n          if (skip) {\r\n            if (\r\n              menu.getItemSubElement(item).contains(skip) === false &&\r\n              item.contains(skip) === false &&\r\n              item !== skip\r\n            ) {\r\n              menu.hide(item)\r\n            }\r\n          } else {\r\n            menu.hide(item)\r\n          }\r\n        }\r\n      }\r\n    }\r\n  }\r\n\r\n  public static updateDropdowns = () => {\r\n    const items = document.querySelectorAll('.show.menu-dropdown[data-kt-menu-trigger]')\r\n    if (items && items.length > 0) {\r\n      for (var i = 0, len = items.length; i < len; i++) {\r\n        var item = items[i]\r\n\r\n        if (DataUtil.has(item as HTMLElement, 'popper')) {\r\n          DataUtil.get(item as HTMLElement, 'popper').forceUpdate()\r\n        }\r\n      }\r\n    }\r\n  }\r\n\r\n  // Global handlers\r\n  public static createInstances = (selector: string) => {\r\n    // Initialize menus\r\n    document.querySelectorAll(selector).forEach((el) => {\r\n      const menuItem = el as HTMLElement\r\n      let menuInstance = MenuComponent.getInstance(menuItem)\r\n      if (!menuInstance) {\r\n        menuInstance = new MenuComponent(el as HTMLElement, defaultMenuOptions)\r\n      }\r\n    })\r\n  }\r\n\r\n  public static initGlobalHandlers = () => {\r\n    // Dropdown handler\r\n    document.addEventListener('click', (e) => {\r\n      const menuItems = document.querySelectorAll('.show.menu-dropdown[data-kt-menu-trigger]')\r\n      if (menuItems && menuItems.length > 0) {\r\n        for (let i = 0; i < menuItems.length; i++) {\r\n          const item = menuItems[i] as HTMLElement\r\n          const menuObj = MenuComponent.getInstance(item) as MenuComponent\r\n          if (menuObj && menuObj.getItemSubType(item) === 'dropdown') {\r\n            // eslint-disable-next-line @typescript-eslint/no-unused-vars\r\n            const menu = menuObj.getElement()\r\n            const sub = menuObj.getItemSubElement(item) as HTMLElement\r\n            if (item === e.target || item.contains(e.target as HTMLElement)) {\r\n              continue\r\n            }\r\n\r\n            if (sub && (sub === e.target || sub.contains(e.target as HTMLElement))) {\r\n              continue\r\n            }\r\n            menuObj.hide(item)\r\n          }\r\n        }\r\n      }\r\n    })\r\n\r\n    // Sub toggle handler\r\n    DOMEventHandlerUtil.on(\r\n      document.body,\r\n      '.menu-item[data-kt-menu-trigger] > .menu-link, [data-kt-menu-trigger]:not(.menu-item):not([data-kt-menu-trigger=\"auto\"])',\r\n      'click',\r\n      function (this: HTMLElement, e: Event) {\r\n        const menu = MenuComponent.getInstance(this) as MenuComponent\r\n        if (menu) {\r\n          return menu.click(this, e)\r\n        }\r\n      }\r\n    )\r\n\r\n    // // Link handler\r\n    DOMEventHandlerUtil.on(\r\n      document.body,\r\n      '.menu-item:not([data-kt-menu-trigger]) > .menu-link',\r\n      'click',\r\n      function (this: HTMLElement, e: Event) {\r\n        e.stopPropagation()\r\n        const menu = MenuComponent.getInstance(this)\r\n        if (menu && menu.link) {\r\n          return menu.link(this, e)\r\n        }\r\n      }\r\n    )\r\n\r\n    // Dismiss handler\r\n    DOMEventHandlerUtil.on(\r\n      document.body,\r\n      '[data-kt-menu-dismiss=\"true\"]',\r\n      'click',\r\n      function (this: HTMLElement, e: Event) {\r\n        const menu = MenuComponent.getInstance(this) as MenuComponent\r\n        if (menu) {\r\n          return menu.dismiss(this, e)\r\n        }\r\n      }\r\n    )\r\n\r\n    // Mouseover handler\r\n    DOMEventHandlerUtil.on(\r\n      document.body,\r\n      '[data-kt-menu-trigger], .menu-sub',\r\n      'mouseover',\r\n      function (this: HTMLElement, e: Event) {\r\n        const menu = MenuComponent.getInstance(this) as MenuComponent\r\n        if (menu && menu.getItemSubType(this) === 'dropdown') {\r\n          return menu.mouseover(this, e)\r\n        }\r\n      }\r\n    )\r\n\r\n    // Mouseout handler\r\n    DOMEventHandlerUtil.on(\r\n      document.body,\r\n      '[data-kt-menu-trigger], .menu-sub',\r\n      'mouseout',\r\n      function (this: HTMLElement, e: Event) {\r\n        const menu = MenuComponent.getInstance(this) as MenuComponent\r\n        if (menu && menu.getItemSubType(this) === 'dropdown') {\r\n          return menu.mouseout(this, e)\r\n        }\r\n      }\r\n    )\r\n\r\n    // Resize handler\r\n    window.addEventListener('resize', () => {\r\n      let timer\r\n      throttle(\r\n        timer,\r\n        () => {\r\n          // Locate and update Drawer instances on window resize\r\n          const elements = document.querySelectorAll('[data-kt-menu=\"true\"]')\r\n          elements.forEach((el) => {\r\n            const menu = MenuComponent.getInstance(el as HTMLElement)\r\n            if (menu) {\r\n              menu.update()\r\n            }\r\n          })\r\n        },\r\n        200\r\n      )\r\n    })\r\n  }\r\n\r\n  public static bootstrap = () => {\r\n    MenuComponent.initGlobalHandlers()\r\n    MenuComponent.createInstances('[data-kt-menu=\"true\"]')\r\n  }\r\n\r\n  public static reinitialization = () => {\r\n    MenuComponent.createInstances('[data-kt-menu=\"true\"]')\r\n  }\r\n\r\n  public static createInsance = (\r\n    selector: string,\r\n    options: MenuOptions = defaultMenuOptions\r\n  ): MenuComponent | undefined => {\r\n    const element = document.body.querySelector(selector)\r\n    if (!element) {\r\n      return\r\n    }\r\n    const item = element as HTMLElement\r\n    let menu = MenuComponent.getInstance(item)\r\n    if (!menu) {\r\n      menu = new MenuComponent(item, options)\r\n    }\r\n    return menu\r\n  }\r\n}\r\n\r\nexport {MenuComponent, defaultMenuOptions}\r\n"]}