vxe-pc-ui 4.16.10 → 4.16.12

package/es/menu/src/menu.js

@@ -1,8 +1,8 @@
-import { ref, h, reactive, inject, resolveComponent, watch, computed, nextTick, onBeforeUnmount, onMounted } from 'vue';
+import { ref, h, reactive, Teleport, inject, resolveComponent, watch, computed, nextTick, onBeforeUnmount, onMounted } from 'vue';
 import { defineVxeComponent } from '../../ui/src/comp';
 import XEUtils from 'xe-utils';
 import { VxeUI, createEvent, permission, useSize, globalEvents, renderEmptyElement } from '../../ui';
-import { toCssUnit } from '../../ui/src/dom';
+import { scrollToView, toCssUnit } from '../../ui/src/dom';
 import { getLastZIndex, nextZIndex, isEnableConf } from '../../ui/src/utils';
 import { getSlotVNs } from '../../ui/src/vn';
 import { createComponentLog } from '../../ui/src/log';
@@ -11,6 +11,10 @@ const { errLog } = createComponentLog('menu');
 const { menus, getConfig, getIcon } = VxeUI;
 function createInternalData() {
     return {
+        lastActiveTime: 0,
+        menuInitMaps: {},
+        menuCacheMaps: {},
+        menuKeyMaps: {},
         menuEffectMaps: {}
     };
 }
@@ -31,10 +35,19 @@ export default defineVxeComponent({
     props: {
         modelValue: [String, Number],
         expandAll: Boolean,
+        expandKeys: Array,
         accordion: {
             type: Boolean,
             default: () => getConfig().menu.accordion
         },
+        border: {
+            type: [Boolean, String],
+            default: () => getConfig().menu.border
+        },
+        optionProps: {
+            type: Object,
+            default: () => getConfig().menu.optionProps
+        },
         collapsed: {
             type: Boolean,
             default: null
@@ -72,6 +85,36 @@ export default defineVxeComponent({
         const computeMenuOpts = computed(() => {
             return Object.assign({}, getConfig().menu.menuConfig, props.menuConfig);
         });
+        const computePropsOpts = computed(() => {
+            return Object.assign({}, getConfig().menu.optionProps, props.optionProps);
+        });
+        const computeTitleField = computed(() => {
+            const propsOpts = computePropsOpts.value;
+            return propsOpts.title || 'title';
+        });
+        const computeKeyField = computed(() => {
+            const propsOpts = computePropsOpts.value;
+            return propsOpts.name || 'name';
+        });
+        const computeChildrenField = computed(() => {
+            const propsOpts = computePropsOpts.value;
+            return propsOpts.children || 'children';
+        });
+        const computeLinkUrlField = computed(() => {
+            const propsOpts = computePropsOpts.value;
+            return propsOpts.linkUrl || 'href';
+        });
+        const computeRouterLinkField = computed(() => {
+            const propsOpts = computePropsOpts.value;
+            return propsOpts.routerLink || 'routerLink';
+        });
+        const computeCurrBorder = computed(() => {
+            const { border } = props;
+            if (border) {
+                return border === true ? 'first-group' : border;
+            }
+            return '';
+        });
         const computeIsCollapsed = computed(() => {
             const { collapsed } = props;
             if (XEUtils.isBoolean(collapsed)) {
@@ -82,19 +125,13 @@ export default defineVxeComponent({
             }
             return false;
         });
-        const computeCollapseWidth = computed(() => {
-            let collapseWidth = '';
-            if ($xeLayoutAside) {
-                collapseWidth = $xeLayoutAside.props.collapseWidth || '';
-            }
-            return collapseWidth;
-        });
-        const computeCollapseEnterWidth = computed(() => {
-            let width = '';
+        const computeVarStyle = computed(() => {
             if ($xeLayoutAside) {
-                width = $xeLayoutAside.props.width || '';
+                const { computeVarStyle: asideComputeVarStyle } = $xeLayoutAside.getComputeMaps();
+                const asideVarStyle = asideComputeVarStyle.value;
+                return asideVarStyle;
             }
-            return width;
+            return {};
         });
         const computeMaps = {
             computeSize
@@ -104,6 +141,7 @@ export default defineVxeComponent({
             props,
             context,
             reactData,
+            internalData,
             getRefMaps: () => refMaps,
             getComputeMaps: () => computeMaps
         };
@@ -117,12 +155,14 @@ export default defineVxeComponent({
         };
         const updateActiveMenu = (isDefExpand) => {
             const { activeName } = reactData;
-            XEUtils.eachTree(reactData.menuList, (item, index, items, path, parent, nodes) => {
+            const { menuInitMaps } = internalData;
+            XEUtils.eachTree(reactData.menuList, (item, index, items, path, parentItem, nodes) => {
                 if (item.itemKey === activeName) {
                     nodes.forEach(obj => {
                         obj.isActive = true;
                         if (isDefExpand) {
                             obj.isExpand = true;
+                            menuInitMaps[obj.itemId] = true;
                         }
                     });
                     item.isExactActive = true;
@@ -134,20 +174,67 @@ export default defineVxeComponent({
             }, { children: 'childList' });
         };
         const updateMenuConfig = () => {
-            const { options, expandAll } = props;
-            reactData.menuList = XEUtils.mapTree(options, (item, index, items, path, parent) => {
-                const objItem = Object.assign(Object.assign({}, item), { parentKey: parent ? (parent.name || path.slice(0, path.length - 1).join(',')) : '', level: path.length, itemId: ++nemuUniqueKey, itemKey: item.name || path.join(','), isExactActive: false, isActive: false, isExpand: XEUtils.isBoolean(item.expanded) ? item.expanded : !!expandAll, hasChild: item.children && item.children.length > 0 });
+            const { options, expandAll, expandKeys } = props;
+            const muInitMaps = {};
+            const titleField = computeTitleField.value;
+            const keyField = computeKeyField.value;
+            const childrenField = computeChildrenField.value;
+            const linkUrlField = computeLinkUrlField.value;
+            const routerLinkField = computeRouterLinkField.value;
+            const defaultExpandMaps = {};
+            if (expandKeys) {
+                expandKeys.forEach(key => {
+                    defaultExpandMaps[key] = true;
+                });
+            }
+            const muCacheMaps = {};
+            const muKeyMaps = {};
+            reactData.menuList = XEUtils.mapTree(options, (item, index, items, path, parentItem) => {
+                const itemId = ++nemuUniqueKey;
+                const itemKey = item[keyField] || path.join(',');
+                const childList = item[childrenField];
+                const hasChild = childList && childList.length > 0;
+                const isExpand = hasChild ? (XEUtils.isBoolean(item.expanded) ? item.expanded : (defaultExpandMaps[itemKey] || !!expandAll)) : false;
+                if (isExpand) {
+                    muInitMaps[itemId] = true;
+                }
+                const objItem = {
+                    itemConf: item,
+                    title: item[titleField],
+                    name: item[keyField],
+                    icon: item.icon,
+                    linkUrl: item[linkUrlField],
+                    linkTarget: item.linkTarget,
+                    routerLink: item[routerLinkField],
+                    permissionCode: item.permissionCode,
+                    children: childList,
+                    slots: item.slots,
+                    parentKey: parentItem ? (parentItem.name || path.slice(0, path.length - 1).join(',')) : '',
+                    level: path.length,
+                    itemId,
+                    itemKey,
+                    isExactActive: false,
+                    isActive: false,
+                    isExpand,
+                    hasChild,
+                    childList: []
+                };
+                if (muKeyMaps[itemKey]) {
+                    errLog('vxe.error.repeatKey', [keyField, item[keyField]]);
+                }
+                muCacheMaps[itemId] = objItem;
+                muKeyMaps[itemKey] = objItem;
                 return objItem;
             }, { children: 'children', mapChildren: 'childList' });
+            internalData.menuInitMaps = muInitMaps;
+            internalData.menuCacheMaps = muCacheMaps;
+            internalData.menuKeyMaps = muKeyMaps;
         };
         const updateCollapseStyle = () => {
             const { collapseFixed } = props;
             if (collapseFixed) {
                 nextTick(() => {
-                    const { isEnterCollapse } = reactData;
                     const isCollapsed = computeIsCollapsed.value;
-                    const collapseEnterWidth = computeCollapseEnterWidth.value;
-                    const collapseWidth = computeCollapseWidth.value;
                     const el = refElem.value;
                     if (el) {
                         const clientRect = el.getBoundingClientRect();
@@ -157,7 +244,6 @@ export default defineVxeComponent({
                                 top: toCssUnit(clientRect.top),
                                 left: toCssUnit(clientRect.left),
                                 height: toCssUnit(parentNode.clientHeight),
-                                width: isEnterCollapse ? (collapseEnterWidth ? toCssUnit(collapseEnterWidth) : '') : (collapseWidth ? toCssUnit(collapseWidth) : ''),
                                 zIndex: reactData.collapseZindex
                             }
                             : {};
@@ -173,12 +259,6 @@ export default defineVxeComponent({
                 if (isCollapsed) {
                     if (!initialized) {
                         reactData.initialized = true;
-                        nextTick(() => {
-                            const collapseEl = refCollapseElem.value;
-                            if (collapseEl) {
-                                document.body.appendChild(collapseEl);
-                            }
-                        });
                     }
                 }
                 reactData.isEnterCollapse = false;
@@ -188,7 +268,7 @@ export default defineVxeComponent({
         };
         const handleClickIconCollapse = (evnt, item, itemList) => {
             const { accordion } = props;
-            const { menuEffectMaps } = internalData;
+            const { menuEffectMaps, menuInitMaps } = internalData;
             const { itemId, hasChild, isExpand } = item;
             const isCollapsed = computeIsCollapsed.value;
             const expanded = !isExpand;
@@ -206,6 +286,7 @@ export default defineVxeComponent({
                     });
                 }
                 item.isExpand = expanded;
+                menuInitMaps[itemId] = true;
                 const wrapperEl = isCollapsed ? refCollapseElem.value : refElem.value;
                 if (wrapperEl) {
                     const nemuEl = wrapperEl.querySelector(`.vxe-menu--item-wrapper[data-menu-id="${itemId}"]`);
@@ -243,7 +324,7 @@ export default defineVxeComponent({
             const menuOpts = computeMenuOpts.value;
             if (menuConfig ? isEnableConf(menuOpts) : menuOpts.enabled) {
                 const { options, visibleMethod } = menuOpts;
-                if (!visibleMethod || visibleMethod({ $menu: $xeMenu, options, currentMenu: item })) {
+                if (!visibleMethod || visibleMethod({ $menu: $xeMenu, options, currentMenu: item, currentOption: item.itemConf })) {
                     if (VxeUI.contextMenu) {
                         VxeUI.contextMenu.openByEvent(evnt, {
                             options,
@@ -252,7 +333,7 @@ export default defineVxeComponent({
                                     const { option } = eventParams;
                                     const gMenuOpts = menus.get(option.code);
                                     const mmMethod = gMenuOpts ? gMenuOpts.menuMenuMethod : null;
-                                    const params = { menu: option, currentMenu: item, $event: evnt, $menu: $xeMenu };
+                                    const params = { menu: option, currentMenu: item, currentOption: item.itemConf, $event: evnt, $menu: $xeMenu };
                                     if (mmMethod) {
                                         mmMethod(params, evnt);
                                     }
@@ -266,10 +347,11 @@ export default defineVxeComponent({
             dispatchEvent('option-menu', { currentMenu: item }, evnt);
         };
         const handleClickMenu = (evnt, item, itemList) => {
-            const { itemKey, routerLink, hasChild } = item;
-            if (routerLink) {
+            const { itemKey, linkUrl, routerLink, hasChild } = item;
+            if (linkUrl || routerLink) {
                 emitModel(itemKey);
-                handleMenuMouseleave();
+                reactData.isEnterCollapse = false;
+                internalData.lastActiveTime = Date.now();
             }
             else {
                 if (hasChild) {
@@ -277,36 +359,26 @@ export default defineVxeComponent({
                 }
                 else {
                     emitModel(itemKey);
-                    handleMenuMouseleave();
+                    reactData.isEnterCollapse = false;
+                    internalData.lastActiveTime = Date.now();
                 }
             }
             const params = {
                 currentMenu: item,
+                currentOption: item.itemConf,
+                option: item.itemConf,
                 // 已废弃
                 menu: item
             };
             dispatchEvent('click', params, evnt);
         };
         const handleMenuMouseenter = () => {
-            const { collapseStyle } = reactData;
-            const collapseEnterWidth = computeCollapseEnterWidth.value;
-            reactData.collapseStyle = Object.assign({}, collapseStyle, {
-                width: collapseEnterWidth ? toCssUnit(collapseEnterWidth) : ''
-            });
-            reactData.isEnterCollapse = true;
-        };
-        const handleMenuMouseover = () => {
-            const { isEnterCollapse } = reactData;
-            if (!isEnterCollapse) {
-                handleMenuMouseenter();
+            const { lastActiveTime } = internalData;
+            if (lastActiveTime < Date.now() - 500) {
+                reactData.isEnterCollapse = true;
             }
         };
         const handleMenuMouseleave = () => {
-            const { collapseStyle } = reactData;
-            const el = refElem.value;
-            reactData.collapseStyle = Object.assign({}, collapseStyle, {
-                width: el ? toCssUnit(el.offsetWidth) : ''
-            });
             reactData.isEnterCollapse = false;
         };
         const callSlot = (slotFunc, params) => {
@@ -323,8 +395,69 @@ export default defineVxeComponent({
         const dispatchEvent = (type, params, evnt) => {
             emit(type, createEvent(evnt, { $menu: $xeMenu }, params));
         };
+        const handleScrollToView = (itemId) => {
+            const wrapperEl = refElem.value;
+            const nemuEl = wrapperEl ? wrapperEl.querySelector(`.vxe-menu--item-wrapper[data-menu-id="${itemId}"]`) : null;
+            if (nemuEl) {
+                scrollToView(nemuEl);
+                return true;
+            }
+            return false;
+        };
         const menuMethods = {
-            dispatchEvent
+            dispatchEvent,
+            setExpandByMenuKey(menuKeys, expanded) {
+                const { menuKeyMaps, menuInitMaps } = internalData;
+                if (menuKeys) {
+                    if (!XEUtils.isArray(menuKeys)) {
+                        menuKeys = [menuKeys];
+                    }
+                    menuKeys.forEach(mKey => {
+                        const menuItem = menuKeyMaps[mKey];
+                        if (menuItem) {
+                            if (expanded) {
+                                menuInitMaps[menuItem.itemId] = true;
+                            }
+                            menuItem.isExpand = !!expanded;
+                        }
+                    });
+                }
+                return nextTick();
+            },
+            clearAllExpandMenu() {
+                const { menuList } = reactData;
+                XEUtils.eachTree(menuList, (item) => {
+                    item.isExpand = false;
+                }, { children: 'childList' });
+                internalData.menuInitMaps = {};
+                return nextTick();
+            },
+            scrollToMenuKey(menuKey) {
+                const { menuKeyMaps } = internalData;
+                const menuItem = menuKeyMaps[menuKey];
+                if (!menuItem) {
+                    return nextTick();
+                }
+                const { itemId } = menuItem;
+                if (handleScrollToView(itemId)) {
+                    return nextTick();
+                }
+                return nextTick().then(() => {
+                    handleScrollToView(itemId);
+                });
+            },
+            scrollToActiveMenu() {
+                const { activeName } = reactData;
+                if (activeName) {
+                    return $xeMenu.scrollToMenuKey(activeName);
+                }
+                return nextTick().then(() => {
+                    const { activeName } = reactData;
+                    if (activeName) {
+                        return $xeMenu.scrollToMenuKey(activeName);
+                    }
+                });
+            }
         };
         const menuPrivateMethods = {};
         Object.assign($xeMenu, menuMethods, menuPrivateMethods);
@@ -338,9 +471,9 @@ export default defineVxeComponent({
             const isCollapsed = computeIsCollapsed.value;
             const params = {
                 currentMenu: item,
-                collapsed: isCollapsed,
-                // 已废弃
-                option: item
+                currentOption: item.itemConf,
+                option: item.itemConf,
+                collapsed: isCollapsed
             };
             return [
                 optionSlot
@@ -377,89 +510,79 @@ export default defineVxeComponent({
             ];
         };
         const renderDefaultChildren = (item, itemList) => {
-            const { itemId, itemKey, level, hasChild, isActive, isExactActive, isExpand, routerLink, childList } = item;
+            const { itemId, itemKey, level, hasChild, isActive, isExactActive, isExpand, linkUrl, routerLink, linkTarget, childList } = item;
             const { isEnterCollapse } = reactData;
+            const { menuInitMaps } = internalData;
             const isCollapsed = computeIsCollapsed.value;
             if (item.permissionCode) {
                 if (!permission.checkVisible(item.permissionCode)) {
                     return renderEmptyElement($xeMenu);
                 }
             }
+            const isExpandChild = (!isCollapsed || isEnterCollapse) && isExpand;
+            const linkOns = {
+                onContextmenu(evnt) {
+                    handleContextmenuEvent(evnt, item);
+                },
+                onClick(evnt) {
+                    handleClickMenu(evnt, item, itemList);
+                }
+            };
             return h('div', {
                 key: itemKey,
                 class: ['vxe-menu--item-wrapper', `vxe-menu--item-level${level}`, {
+                        'has--child': hasChild,
                         'is--exact-active': isExactActive,
                         'is--active': isActive,
-                        'is--expand': (!isCollapsed || isEnterCollapse) && isExpand
+                        'is--expand': isExpandChild
                     }],
                 'data-menu-id': itemId
             }, [
-                routerLink
-                    ? h(resolveComponent('router-link'), {
-                        class: 'vxe-menu--item-link',
-                        to: routerLink,
-                        onContextmenu(evnt) {
-                            handleContextmenuEvent(evnt, item);
-                        },
-                        onClick(evnt) {
-                            handleClickMenu(evnt, item, itemList);
-                        }
-                    }, {
-                        default: () => renderMenuTitle(item, itemList)
-                    })
-                    : h('div', {
-                        class: 'vxe-menu--item-link',
-                        onContextmenu(evnt) {
-                            handleContextmenuEvent(evnt, item);
-                        },
-                        onClick(evnt) {
-                            handleClickMenu(evnt, item, itemList);
-                        }
-                    }, renderMenuTitle(item, itemList)),
+                linkUrl
+                    ? h('a', Object.assign({ class: 'vxe-menu--item-link is--link', href: linkUrl, target: linkTarget }, linkOns), renderMenuTitle(item, itemList))
+                    : (routerLink
+                        ? h(resolveComponent('router-link'), Object.assign({ class: 'vxe-menu--item-link is--router', to: routerLink, target: linkTarget }, linkOns), {
+                            default: () => renderMenuTitle(item, itemList)
+                        })
+                        : h('div', Object.assign({ class: 'vxe-menu--item-link is--default' }, linkOns), renderMenuTitle(item, itemList))),
                 hasChild
                     ? h('div', {
                         class: 'vxe-menu--item-group'
-                    }, childList.map(child => renderDefaultChildren(child, childList)))
+                    }, isExpandChild || menuInitMaps[itemId] ? childList.map(child => renderDefaultChildren(child, childList)) : [])
                     : renderEmptyElement($xeMenu)
             ]);
         };
         const renderCollapseChildren = (item, itemList) => {
-            const { itemId, itemKey, level, hasChild, isActive, isExactActive, routerLink, childList } = item;
+            const { itemId, itemKey, level, hasChild, isActive, isExactActive, routerLink, linkUrl, linkTarget, childList } = item;
             if (item.permissionCode) {
                 if (!permission.checkVisible(item.permissionCode)) {
                     return renderEmptyElement($xeMenu);
                 }
             }
+            const linkOns = {
+                onContextmenu(evnt) {
+                    handleContextmenuEvent(evnt, item);
+                },
+                onClick(evnt) {
+                    handleClickMenu(evnt, item, itemList);
+                }
+            };
             return h('div', {
                 key: itemKey,
                 class: ['vxe-menu--item-wrapper', `vxe-menu--item-level${level}`, {
+                        'has--child': hasChild,
                         'is--exact-active': isExactActive,
                         'is--active': isActive
                     }],
                 'data-menu-id': itemId
             }, [
-                routerLink
-                    ? h(resolveComponent('router-link'), {
-                        class: 'vxe-menu--item-link',
-                        to: routerLink,
-                        onContextmenu(evnt) {
-                            handleContextmenuEvent(evnt, item);
-                        },
-                        onClick(evnt) {
-                            handleClickMenu(evnt, item, itemList);
-                        }
-                    }, {
-                        default: () => renderMenuTitle(item, itemList)
-                    })
-                    : h('div', {
-                        class: 'vxe-menu--item-link',
-                        onContextmenu(evnt) {
-                            handleContextmenuEvent(evnt, item);
-                        },
-                        onClick(evnt) {
-                            handleClickMenu(evnt, item, itemList);
-                        }
-                    }, renderMenuTitle(item, itemList)),
+                linkUrl
+                    ? h('a', Object.assign({ class: 'vxe-menu--item-link is--link', href: linkUrl, target: linkTarget }, linkOns), renderMenuTitle(item, itemList))
+                    : (routerLink
+                        ? h(resolveComponent('router-link'), Object.assign({ class: 'vxe-menu--item-link is--router', to: routerLink, target: linkTarget }, linkOns), {
+                            default: () => renderMenuTitle(item, itemList)
+                        })
+                        : h('div', Object.assign({ class: 'vxe-menu--item-link is--default' }, linkOns), renderMenuTitle(item, itemList))),
                 hasChild
                     ? h('div', {
                         class: 'vxe-menu--item-group'
@@ -472,39 +595,67 @@ export default defineVxeComponent({
             const { initialized, menuList, collapseStyle, isEnterCollapse } = reactData;
             const vSize = computeSize.value;
             const isCollapsed = computeIsCollapsed.value;
+            const currBorder = computeCurrBorder.value;
+            const varStyle = computeVarStyle.value;
+            const headerSlot = slots.header;
+            const footerSlot = slots.footer;
             let ons = {};
             if (collapseFixed) {
                 ons = {
                     onMouseenter: handleMenuMouseenter,
-                    onMouseover: handleMenuMouseover,
                     onMouseleave: handleMenuMouseleave
                 };
             }
+            const stParams = { collapsed: isCollapsed };
             return h('div', {
                 ref: refElem,
                 class: ['vxe-menu', {
+                        [`border--${currBorder}`]: currBorder,
                         [`size--${vSize}`]: vSize,
                         'is--collapsed': isCollapsed,
                         'is--loading': loading
                     }]
             }, [
+                headerSlot
+                    ? h('div', {
+                        class: 'vxe-menu--header'
+                    }, headerSlot(stParams))
+                    : renderEmptyElement($xeMenu),
                 h('div', {
-                    class: 'vxe-menu--item-list'
+                    class: 'vxe-menu--body'
                 }, menuList.map(child => isCollapsed ? renderCollapseChildren(child, menuList) : renderDefaultChildren(child, menuList))),
-                initialized
-                    ? h('div', Object.assign({ ref: refCollapseElem, class: ['vxe-menu--collapse-wrapper', {
+                footerSlot
+                    ? h('div', {
+                        class: 'vxe-menu--footer'
+                    }, footerSlot(stParams))
+                    : renderEmptyElement($xeMenu),
+                h(Teleport, {
+                    to: 'body',
+                    disabled: !initialized
+                }, [
+                    h('div', Object.assign({ ref: refCollapseElem, class: ['vxe-menu--collapse-wrapper', {
                                 [`size--${vSize}`]: vSize,
                                 'is--collapsed': isCollapsed,
                                 'is--enter': isEnterCollapse,
                                 'is--loading': loading
-                            }], style: collapseStyle }, ons), [
-                        isCollapsed
-                            ? h('div', {
-                                class: 'vxe-menu--item-list'
-                            }, menuList.map(child => renderDefaultChildren(child, menuList)))
-                            : renderEmptyElement($xeMenu)
-                    ])
-                    : renderEmptyElement($xeMenu),
+                            }], style: Object.assign({}, varStyle, collapseStyle) }, ons), isCollapsed
+                        ? [
+                            headerSlot
+                                ? h('div', {
+                                    class: 'vxe-menu--header'
+                                }, headerSlot(stParams))
+                                : renderEmptyElement($xeMenu),
+                            h('div', {
+                                class: 'vxe-menu--body'
+                            }, menuList.map(child => renderDefaultChildren(child, menuList))),
+                            footerSlot
+                                ? h('div', {
+                                    class: 'vxe-menu--footer'
+                                }, footerSlot(stParams))
+                                : renderEmptyElement($xeMenu)
+                        ]
+                        : [])
+                ]),
                 /**
                  * 加载中
                  */
@@ -544,13 +695,6 @@ export default defineVxeComponent({
             updateCollapseStyle();
         });
         onBeforeUnmount(() => {
-            const collapseEl = refCollapseElem.value;
-            if (collapseEl) {
-                const parentNode = collapseEl.parentNode;
-                if (parentNode) {
-                    parentNode.removeChild(collapseEl);
-                }
-            }
             globalEvents.off($xeMenu, 'resize');
             XEUtils.assign(reactData, createReactData());
             XEUtils.assign(internalData, createInternalData());