vxe-pc-ui 4.20.24 → 4.20.26

package/lib/tree/src/tree.js

@@ -33,7 +33,7 @@ __export(tree_exports, {
 module.exports = __toCommonJS(tree_exports);
 var import_vue = require("vue");
 var import_comp = require("../../ui/src/comp");
-var import_ui = require("../../ui");
+var import_core = require("@vxe-ui/core");
 var import_util = require("./util");
 var import_log = require("../../ui/src/log");
 var import_store = require("./store");
@@ -45,7 +45,7 @@ var import_anime = require("../../ui/src/anime");
 var import_loading = __toESM(require("../../loading"));
 var import_tooltip = __toESM(require("../../tooltip"));
 const { warnLog, errLog } = (0, import_log.createComponentLog)("tree");
-const { menus, getConfig, getI18n, getIcon, baseUtils, domUtils, createEvent, useFns, globalEvents, globalResize, renderEmptyElement } = import_ui.VxeUI;
+const { menus, getConfig, getI18n, getIcon, baseUtils, domUtils, createEvent, useFns, globalEvents, globalResize, renderEmptyElement } = import_core.VxeUI;
 const { getDefVal } = baseUtils;
 function getNodeUniqueId() {
   return import_xe_utils.default.uniqueId("node_");
@@ -447,17 +447,20 @@ var tree_default = (0, import_comp.defineVxeComponent)({
       const scrollbarYToLeft = computeScrollbarYToLeft.value;
       const scrollXVisible = computeScrollXVisible.value;
       const scrollYVisible = computeScrollYVisible.value;
-      return domUtils.buildClass([
-        "vxe-scrollbar is--virtual",
-        scrollbarOpts.fluentOverlay ? "is--fluent-overlay" : "is--default-mode",
-        `ov-x--${scrollXVisible === false ? "hidden" : "visible"}`,
-        `ov-y--${scrollYVisible === false ? "hidden" : "visible"}`,
-        `sx-pos--${scrollbarXToTop ? "top" : "bottom"}`,
-        `sy-pos--${scrollbarYToLeft ? "left" : "right"}`
-      ], {
-        "overflow-y": yThumbHeight,
-        "overflow-x": xThumbWidth
-      });
+      return domUtils.buildClass(
+        [
+          "vxe-scrollbar is--virtual",
+          scrollbarOpts.fluentOverlay ? "is--fluent-overlay" : "is--default-mode",
+          `ov-x--${scrollXVisible === false ? "hidden" : "visible"}`,
+          `ov-y--${scrollYVisible === false ? "hidden" : "visible"}`,
+          `sx-pos--${scrollbarXToTop ? "top" : "bottom"}`,
+          `sy-pos--${scrollbarYToLeft ? "left" : "right"}`
+        ],
+        {
+          "overflow-y": yThumbHeight,
+          "overflow-x": xThumbWidth
+        }
+      );
     });
     const computeScrollbarXToTop = (0, import_vue.computed)(() => {
       const scrollbarXOpts = computeScrollbarXOpts.value;
@@ -486,21 +489,7 @@ var tree_default = (0, import_comp.defineVxeComponent)({
       getRefMaps: () => refMaps,
       getComputeMaps: () => computeMaps
     };
-    const {
-      refTrackXElem,
-      refTrackYElem,
-      refThumbXElem,
-      refThumbYElem,
-      updateThumbSize,
-      updateThumbOffset,
-      clickTrackXEvent,
-      clickTrackYEvent,
-      pointerdownThumbXEvent,
-      pointermoveThumbXEvent,
-      cleatPointerThumbEvent,
-      pointerdownThumbYEvent,
-      pointermoveThumbYEvent
-    } = useFns.useInitVScrollbar($xeTree);
+    const { refTrackXElem, refTrackYElem, refThumbXElem, refThumbYElem, updateThumbSize, updateThumbOffset, clickTrackXEvent, clickTrackYEvent, pointerdownThumbXEvent, pointermoveThumbXEvent, cleatPointerThumbEvent, pointerdownThumbYEvent, pointermoveThumbYEvent } = useFns.useInitVScrollbar($xeTree);
     const getNodeId = (node) => {
       if (!node) {
         return "";
@@ -656,47 +645,19 @@ var tree_default = (0, import_comp.defineVxeComponent)({
       const valueField = computeValueField.value;
       const childrenField = computeChildrenField.value;
       const keyMaps = {};
-      import_xe_utils.default.eachTree(treeFullData, (item, index, items, path, parenItem, nodes) => {
-        let nodeid = getNodeId(item);
-        if (!nodeid) {
-          nodeid = getNodeUniqueId();
-          import_xe_utils.default.set(item, valueField, nodeid);
-        }
-        keyMaps[nodeid] = {
-          item,
-          index,
-          $index: -1,
-          _index: -1,
-          items,
-          parent: parenItem,
-          nodes,
-          level: nodes.length - 1,
-          treeIndex: index,
-          lineCount: 0,
-          treeLoaded: false
-        };
-      }, { children: childrenField });
-      internalData.nodeMaps = keyMaps;
-    };
-    const updateAfterDataIndex = () => {
-      const { transform } = props;
-      const { afterTreeList, nodeMaps } = internalData;
-      const childrenField = computeChildrenField.value;
-      const mapChildrenField = computeMapChildrenField.value;
-      let vtIndex = 0;
-      import_xe_utils.default.eachTree(afterTreeList, (item, index, items, path, parenItem, nodes) => {
-        const nodeid = getNodeId(item);
-        const nodeItem = nodeMaps[nodeid];
-        if (nodeItem) {
-          nodeItem.items = items;
-          nodeItem.treeIndex = index;
-          nodeItem._index = vtIndex;
-        } else {
-          const rest = {
+      import_xe_utils.default.eachTree(
+        treeFullData,
+        (item, index, items, path, parenItem, nodes) => {
+          let nodeid = getNodeId(item);
+          if (!nodeid) {
+            nodeid = getNodeUniqueId();
+            import_xe_utils.default.set(item, valueField, nodeid);
+          }
+          keyMaps[nodeid] = {
             item,
             index,
             $index: -1,
-            _index: vtIndex,
+            _index: -1,
             items,
             parent: parenItem,
             nodes,
@@ -705,10 +666,46 @@ var tree_default = (0, import_comp.defineVxeComponent)({
             lineCount: 0,
             treeLoaded: false
           };
-          nodeMaps[nodeid] = rest;
-        }
-        vtIndex++;
-      }, { children: transform ? mapChildrenField : childrenField });
+        },
+        { children: childrenField }
+      );
+      internalData.nodeMaps = keyMaps;
+    };
+    const updateAfterDataIndex = () => {
+      const { transform } = props;
+      const { afterTreeList, nodeMaps } = internalData;
+      const childrenField = computeChildrenField.value;
+      const mapChildrenField = computeMapChildrenField.value;
+      let vtIndex = 0;
+      import_xe_utils.default.eachTree(
+        afterTreeList,
+        (item, index, items, path, parenItem, nodes) => {
+          const nodeid = getNodeId(item);
+          const nodeItem = nodeMaps[nodeid];
+          if (nodeItem) {
+            nodeItem.items = items;
+            nodeItem.treeIndex = index;
+            nodeItem._index = vtIndex;
+          } else {
+            const rest = {
+              item,
+              index,
+              $index: -1,
+              _index: vtIndex,
+              items,
+              parent: parenItem,
+              nodes,
+              level: nodes.length - 1,
+              treeIndex: index,
+              lineCount: 0,
+              treeLoaded: false
+            };
+            nodeMaps[nodeid] = rest;
+          }
+          vtIndex++;
+        },
+        { children: transform ? mapChildrenField : childrenField }
+      );
     };
     const updateAfterFullData = () => {
       const { transform, filterValue } = props;
@@ -803,14 +800,18 @@ var tree_default = (0, import_comp.defineVxeComponent)({
       const expandMaps = {};
       if (transform) {
         const fullData = [];
-        import_xe_utils.default.eachTree(afterTreeList, (item, index, items, path, parentNode) => {
-          const nodeid = getNodeId(item);
-          const parentNodeid = getNodeId(parentNode);
-          if (!parentNode || expandMaps[parentNodeid] && treeExpandedMaps[parentNodeid]) {
-            expandMaps[nodeid] = 1;
-            fullData.push(item);
-          }
-        }, { children: mapChildrenField });
+        import_xe_utils.default.eachTree(
+          afterTreeList,
+          (item, index, items, path, parentNode) => {
+            const nodeid = getNodeId(item);
+            const parentNodeid = getNodeId(parentNode);
+            if (!parentNode || expandMaps[parentNodeid] && treeExpandedMaps[parentNodeid]) {
+              expandMaps[nodeid] = 1;
+              fullData.push(item);
+            }
+          },
+          { children: mapChildrenField }
+        );
         updateScrollYStatus(fullData);
         internalData.afterVisibleList = fullData;
         return fullData;
@@ -1201,8 +1202,8 @@ var tree_default = (0, import_comp.defineVxeComponent)({
           } else if (reactData.currentNode) {
             reactData.currentNode = null;
           }
-          if (import_ui.VxeUI.contextMenu) {
-            import_ui.VxeUI.contextMenu.openByEvent(evnt, {
+          if (import_core.VxeUI.contextMenu) {
+            import_core.VxeUI.contextMenu.openByEvent(evnt, {
               options,
               events: {
                 optionClick(eventParams) {
@@ -1241,9 +1242,7 @@ var tree_default = (0, import_comp.defineVxeComponent)({
         const nodeItem = nodeMaps[nodeid];
         if (loadMethod) {
           internalData.treeExpandLazyLoadedMaps[nodeid] = true;
-          Promise.resolve(
-            loadMethod({ $tree: $xeTree, node })
-          ).then((childRecords) => {
+          Promise.resolve(loadMethod({ $tree: $xeTree, node })).then((childRecords) => {
             const { treeExpandLazyLoadedMaps } = internalData;
             if (nodeItem) {
               nodeItem.treeLoaded = true;
@@ -1365,14 +1364,18 @@ var tree_default = (0, import_comp.defineVxeComponent)({
       if (!checkStrictly) {
         const childNodeMaps = {};
         const childNodeList = [];
-        import_xe_utils.default.eachTree(afterTreeList, (node) => {
-          const nodeid = getNodeId(node);
-          const childList = node[childrenField];
-          if (childList && childList.length && !childNodeMaps[nodeid]) {
-            childNodeMaps[nodeid] = 1;
-            childNodeList.unshift([node, nodeid, childList]);
-          }
-        }, { children: transform ? mapChildrenField : childrenField });
+        import_xe_utils.default.eachTree(
+          afterTreeList,
+          (node) => {
+            const nodeid = getNodeId(node);
+            const childList = node[childrenField];
+            if (childList && childList.length && !childNodeMaps[nodeid]) {
+              childNodeMaps[nodeid] = 1;
+              childNodeList.unshift([node, nodeid, childList]);
+            }
+          },
+          { children: transform ? mapChildrenField : childrenField }
+        );
         childNodeList.forEach((vals) => {
           const node = vals[0];
           const nodeid = vals[1];
@@ -1474,18 +1477,22 @@ var tree_default = (0, import_comp.defineVxeComponent)({
         selectCheckboxMaps[nodeid] = node;
       }
       if (!checkStrictly) {
-        import_xe_utils.default.eachTree(import_xe_utils.default.get(node, transform ? mapChildrenField : childrenField), (childNode) => {
-          const childNodeid = getNodeId(childNode);
-          if (isChecked) {
-            if (!selectCheckboxMaps[childNodeid]) {
-              selectCheckboxMaps[childNodeid] = true;
-            }
-          } else {
-            if (selectCheckboxMaps[childNodeid]) {
-              delete selectCheckboxMaps[childNodeid];
+        import_xe_utils.default.eachTree(
+          import_xe_utils.default.get(node, transform ? mapChildrenField : childrenField),
+          (childNode) => {
+            const childNodeid = getNodeId(childNode);
+            if (isChecked) {
+              if (!selectCheckboxMaps[childNodeid]) {
+                selectCheckboxMaps[childNodeid] = true;
+              }
+            } else {
+              if (selectCheckboxMaps[childNodeid]) {
+                delete selectCheckboxMaps[childNodeid];
+              }
             }
-          }
-        }, { children: transform ? mapChildrenField : childrenField });
+          },
+          { children: transform ? mapChildrenField : childrenField }
+        );
       }
       reactData.updateCheckboxFlag++;
       updateCheckboxStatus();
@@ -1639,15 +1646,19 @@ var tree_default = (0, import_comp.defineVxeComponent)({
               }
               parentMapChilds.splice(targetIndex, 0, item);
             });
-            import_xe_utils.default.eachTree(treeRecords, (item) => {
-              const nodeid = getNodeId(item);
-              const nodeRest = (0, import_util.getItemCacheObj)(item);
-              nodeRest.level = parentLevel;
-              if (item[childrenField]) {
-                item[mapChildrenField] = item[childrenField];
-              }
-              nodeMaps[nodeid] = nodeRest;
-            }, { children: childrenField });
+            import_xe_utils.default.eachTree(
+              treeRecords,
+              (item) => {
+                const nodeid = getNodeId(item);
+                const nodeRest = (0, import_util.getItemCacheObj)(item);
+                nodeRest.level = parentLevel;
+                if (item[childrenField]) {
+                  item[mapChildrenField] = item[childrenField];
+                }
+                nodeMaps[nodeid] = nodeRest;
+              },
+              { children: childrenField }
+            );
             if (parentNode) {
               const matchObj = import_xe_utils.default.findTree(treeFullData, (item) => targetNode[keyField] === item[keyField], { children: childrenField });
               if (matchObj) {
@@ -1712,7 +1723,11 @@ var tree_default = (0, import_comp.defineVxeComponent)({
           parentNode = nodeRest.item;
         }
       }
-      return handleInsertNodeAt(records.map((item) => Object.assign({}, item, { [parentField]: parentNode[keyField] })), targetNodeOrNodeid, isInsertNextNode);
+      return handleInsertNodeAt(
+        records.map((item) => Object.assign({}, item, { [parentField]: parentNode[keyField] })),
+        targetNodeOrNodeid,
+        isInsertNextNode
+      );
     };
     const treeMethods = {
       dispatchEvent,
@@ -1859,12 +1874,16 @@ var tree_default = (0, import_comp.defineVxeComponent)({
         const checkKeys = [];
         const checkNodes = [];
         if (checked) {
-          import_xe_utils.default.eachTree(transform ? afterTreeList : afterVisibleList, (node) => {
-            const nodeid = getNodeId(node);
-            checkKeys.push(nodeid);
-            checkNodes.push(node);
-            selectMaps[nodeid] = true;
-          }, { children: transform ? mapChildrenField : childrenField });
+          import_xe_utils.default.eachTree(
+            transform ? afterTreeList : afterVisibleList,
+            (node) => {
+              const nodeid = getNodeId(node);
+              checkKeys.push(nodeid);
+              checkNodes.push(node);
+              selectMaps[nodeid] = true;
+            },
+            { children: transform ? mapChildrenField : childrenField }
+          );
         }
         internalData.indeterminateNodeMaps = {};
         internalData.selectCheckboxMaps = selectMaps;
@@ -1987,14 +2006,18 @@ var tree_default = (0, import_comp.defineVxeComponent)({
         const childrenField = computeChildrenField.value;
         const mapChildrenField = computeMapChildrenField.value;
         if (expanded) {
-          import_xe_utils.default.eachTree(internalData.afterTreeList, (node) => {
-            const childList = import_xe_utils.default.get(node, childrenField);
-            const hasChild = childList && childList.length;
-            if (hasChild) {
-              const nodeid = getNodeId(node);
-              treeExpandedMaps[nodeid] = true;
-            }
-          }, { children: transform ? mapChildrenField : childrenField });
+          import_xe_utils.default.eachTree(
+            internalData.afterTreeList,
+            (node) => {
+              const childList = import_xe_utils.default.get(node, childrenField);
+              const hasChild = childList && childList.length;
+              if (hasChild) {
+                const nodeid = getNodeId(node);
+                treeExpandedMaps[nodeid] = true;
+              }
+            },
+            { children: transform ? mapChildrenField : childrenField }
+          );
         } else {
           internalData.treeExpandedMaps = {};
         }
@@ -2045,22 +2068,26 @@ var tree_default = (0, import_comp.defineVxeComponent)({
         const parentLevel = parentNodeItem ? parentNodeItem.level : 0;
         const parentNodes = parentNodeItem ? parentNodeItem.nodes : [];
         return createNode(childRecords).then((nodeList) => {
-          import_xe_utils.default.eachTree(nodeList, (childNode, index, items, path, parent, nodes) => {
-            const itemNodeId = getNodeId(childNode);
-            nodeMaps[itemNodeId] = {
-              item: childNode,
-              index: -1,
-              $index: -1,
-              _index: -1,
-              items,
-              parent: parent || parentNodeItem.item,
-              nodes: parentNodes.concat(nodes),
-              level: parentLevel + nodes.length,
-              treeIndex: -1,
-              lineCount: 0,
-              treeLoaded: false
-            };
-          }, { children: childrenField });
+          import_xe_utils.default.eachTree(
+            nodeList,
+            (childNode, index, items, path, parent, nodes) => {
+              const itemNodeId = getNodeId(childNode);
+              nodeMaps[itemNodeId] = {
+                item: childNode,
+                index: -1,
+                $index: -1,
+                _index: -1,
+                items,
+                parent: parent || parentNodeItem.item,
+                nodes: parentNodes.concat(nodes),
+                level: parentLevel + nodes.length,
+                treeIndex: -1,
+                lineCount: 0,
+                treeLoaded: false
+              };
+            },
+            { children: childrenField }
+          );
           node[childrenField] = nodeList;
           if (transform) {
             node[mapChildrenField] = nodeList;
@@ -2246,6 +2273,7 @@ var tree_default = (0, import_comp.defineVxeComponent)({
       if (el) {
         const clss = "node--drag-origin";
         import_xe_utils.default.arrayEach(el.querySelectorAll(`.${clss}`), (elem) => {
+          ;
           elem.draggable = false;
           (0, import_dom.removeClass)(elem, clss);
         });
@@ -2430,9 +2458,13 @@ var tree_default = (0, import_comp.defineVxeComponent)({
           if (oldRest && newRest) {
             const { level: oldLevel } = oldRest;
             const { level: newLevel } = newRest;
-            import_xe_utils.default.eachTree([dragNode], (item) => {
-              oldAllMaps[getNodeId(item)] = item;
-            }, { children: mapChildrenField });
+            import_xe_utils.default.eachTree(
+              [dragNode],
+              (item) => {
+                oldAllMaps[getNodeId(item)] = item;
+              },
+              { children: mapChildrenField }
+            );
             if (oldLevel && newLevel) {
               if (isPeerDrag && !isCrossDrag) {
                 if (oldRest.item[parentField] !== newRest.item[parentField]) {
@@ -2447,8 +2479,8 @@ var tree_default = (0, import_comp.defineVxeComponent)({
                 if (oldAllMaps[newNodeid]) {
                   isSelfToChildStatus = true;
                   if (!(isCrossDrag && isSelfToChildDrag)) {
-                    if (import_ui.VxeUI.modal) {
-                      import_ui.VxeUI.modal.message({
+                    if (import_core.VxeUI.modal) {
+                      import_core.VxeUI.modal.message({
                         status: "error",
                         content: getI18n("vxe.error.treeDragChild")
                       });
@@ -2471,8 +2503,8 @@ var tree_default = (0, import_comp.defineVxeComponent)({
               if (oldAllMaps[newNodeid]) {
                 isSelfToChildStatus = true;
                 if (!(isCrossDrag && isSelfToChildDrag)) {
-                  if (import_ui.VxeUI.modal) {
-                    import_ui.VxeUI.modal.message({
+                  if (import_core.VxeUI.modal) {
+                    import_core.VxeUI.modal.message({
                       status: "error",
                       content: getI18n("vxe.error.treeDragChild")
                     });
@@ -2503,7 +2535,7 @@ var tree_default = (0, import_comp.defineVxeComponent)({
               const ptfIndex = $xeTree.findNodeIndexOf(fullList, prevDragNode);
               const ntfIndex = ptfIndex + dragOffsetIndex;
               fullList.splice(ntfIndex, 0, dragNode);
-              if (isSelfToChildStatus && (isCrossDrag && isSelfToChildDrag)) {
+              if (isSelfToChildStatus && isCrossDrag && isSelfToChildDrag) {
                 import_xe_utils.default.each(dragNode[childrenField], (childNode) => {
                   childNode[parentField] = dragNode[parentField];
                 });
@@ -2538,18 +2570,22 @@ var tree_default = (0, import_comp.defineVxeComponent)({
             updateYSpace();
           }
           if (evnt) {
-            dispatchEvent("node-dragend", {
-              oldNode: dragNode,
-              newNode: prevDragNode,
-              dragNode,
-              dragPos: prevDragPos,
-              dragToChild: isDragToChildFlag,
-              offsetIndex: dragOffsetIndex,
-              _index: {
-                newIndex: nafIndex,
-                oldIndex: oafIndex
-              }
-            }, evnt);
+            dispatchEvent(
+              "node-dragend",
+              {
+                oldNode: dragNode,
+                newNode: prevDragNode,
+                dragNode,
+                dragPos: prevDragPos,
+                dragToChild: isDragToChildFlag,
+                offsetIndex: dragOffsetIndex,
+                _index: {
+                  newIndex: nafIndex,
+                  oldIndex: oafIndex
+                }
+              },
+              evnt
+            );
           }
           return (0, import_vue.nextTick)().then(() => {
             if (animation) {
@@ -2673,7 +2709,7 @@ var tree_default = (0, import_comp.defineVxeComponent)({
         const node = nodeItem.item;
         const offsetY = evnt.clientY - itemEl.getBoundingClientRect().y;
         const dragPos = offsetY < itemEl.clientHeight / 2 ? "top" : "bottom";
-        internalData.prevDragToChild = !!(transform && (isCrossDrag && isToChildDrag) && isControlKey);
+        internalData.prevDragToChild = !!(transform && isCrossDrag && isToChildDrag && isControlKey);
         internalData.prevDragNode = node;
         internalData.prevDragPos = dragPos;
         if (isCrossTreeDrag && isCrossDrag && crossTreeDragNodeObj) {
@@ -2705,11 +2741,15 @@ var tree_default = (0, import_comp.defineVxeComponent)({
           return;
         }
         showDropTip(evnt, itemEl, true, dragPos);
-        dispatchEvent("node-dragover", {
-          oldRNode: dragNode,
-          targetNode: node,
-          dragPos
-        }, evnt);
+        dispatchEvent(
+          "node-dragover",
+          {
+            oldRNode: dragNode,
+            targetNode: node,
+            dragPos
+          },
+          evnt
+        );
       }
     };
     const treePrivateMethods = {
@@ -2781,9 +2821,13 @@ var tree_default = (0, import_comp.defineVxeComponent)({
                 (0, import_anime.moveRowAnimateToTb)(dtTrList, dragNodeHeight);
               }
             });
-            dispatchEvent("node-remove-dragend", {
-              node: dragNode
-            }, evnt);
+            dispatchEvent(
+              "node-remove-dragend",
+              {
+                node: dragNode
+              },
+              evnt
+            );
             handleNodeDragEndClearStatus();
           }
         }
@@ -2882,14 +2926,18 @@ var tree_default = (0, import_comp.defineVxeComponent)({
               } else {
                 insertRest = $xeTree.insert(dragList);
               }
-              $xeTree.dispatchEvent("node-insert-dragend", {
-                oldNode,
-                newNode: prevDragNode,
-                dragNode,
-                dragPos: prevDragPos,
-                dragToChild: isDragToChildFlag,
-                offsetIndex: dragOffsetIndex
-              }, evnt);
+              $xeTree.dispatchEvent(
+                "node-insert-dragend",
+                {
+                  oldNode,
+                  newNode: prevDragNode,
+                  dragNode,
+                  dragPos: prevDragPos,
+                  dragToChild: isDragToChildFlag,
+                  offsetIndex: dragOffsetIndex
+                },
+                evnt
+              );
               clearNodeDragData();
               insertRest.then(() => {
                 const { treeList } = reactData;
@@ -2974,16 +3022,23 @@ var tree_default = (0, import_comp.defineVxeComponent)({
             };
             ons.onMouseup = handleNodeDragMouseupEvent;
           }
-          return (0, import_vue.h)("div", {
-            class: ["vxe-tree--drag-handle", {
-              "is--disabled": isDisabled
-            }],
-            ...ons
-          }, [
-            (0, import_vue.h)("i", {
-              class: icon || getIcon().TREE_DRAG
-            })
-          ]);
+          return (0, import_vue.h)(
+            "div",
+            {
+              class: [
+                "vxe-tree--drag-handle",
+                {
+                  "is--disabled": isDisabled
+                }
+              ],
+              ...ons
+            },
+            [
+              (0, import_vue.h)("i", {
+                class: icon || getIcon().TREE_DRAG
+              })
+            ]
+          );
         }
       }
       return renderEmptyElement($xeTree);
@@ -3005,21 +3060,28 @@ var tree_default = (0, import_comp.defineVxeComponent)({
       const { showIcon, visibleMode, visibleMethod } = radioOpts;
       const isVisible = visibleMethod ? visibleMethod({ $tree: $xeTree, node }) : handleVisibleOrCheckMode(visibleMode, isExistChild, nLevel);
       if (showRadio && showIcon && isVisible) {
-        return (0, import_vue.h)("div", {
-          class: ["vxe-tree--radio-option", {
-            "is--checked": isChecked,
-            "is--disabled": isDisabled
-          }],
-          onClick: (evnt) => {
-            if (!isDisabled) {
-              changeRadioEvent(evnt, node);
+        return (0, import_vue.h)(
+          "div",
+          {
+            class: [
+              "vxe-tree--radio-option",
+              {
+                "is--checked": isChecked,
+                "is--disabled": isDisabled
+              }
+            ],
+            onClick: (evnt) => {
+              if (!isDisabled) {
+                changeRadioEvent(evnt, node);
+              }
             }
-          }
-        }, [
-          (0, import_vue.h)("span", {
-            class: ["vxe-radio--icon", isChecked ? getIcon().RADIO_CHECKED : isDisabled ? getIcon().RADIO_DISABLED_UNCHECKED : getIcon().RADIO_UNCHECKED]
-          })
-        ]);
+          },
+          [
+            (0, import_vue.h)("span", {
+              class: ["vxe-radio--icon", isChecked ? getIcon().RADIO_CHECKED : isDisabled ? getIcon().RADIO_DISABLED_UNCHECKED : getIcon().RADIO_UNCHECKED]
+            })
+          ]
+        );
       }
       return renderEmptyElement($xeTree);
     };
@@ -3029,22 +3091,29 @@ var tree_default = (0, import_comp.defineVxeComponent)({
       const { showIcon, visibleMode, visibleMethod } = checkboxOpts;
       const isVisible = visibleMethod ? visibleMethod({ $tree: $xeTree, node }) : handleVisibleOrCheckMode(visibleMode, isExistChild, nLevel);
       if (showCheckbox && showIcon && isVisible) {
-        return (0, import_vue.h)("div", {
-          class: ["vxe-tree--checkbox-option", {
-            "is--checked": isChecked,
-            "is--indeterminate": isIndeterminate,
-            "is--disabled": isDisabled
-          }],
-          onClick: (evnt) => {
-            if (!isDisabled) {
-              changeCheckboxEvent(evnt, node);
+        return (0, import_vue.h)(
+          "div",
+          {
+            class: [
+              "vxe-tree--checkbox-option",
+              {
+                "is--checked": isChecked,
+                "is--indeterminate": isIndeterminate,
+                "is--disabled": isDisabled
+              }
+            ],
+            onClick: (evnt) => {
+              if (!isDisabled) {
+                changeCheckboxEvent(evnt, node);
+              }
             }
-          }
-        }, [
-          (0, import_vue.h)("span", {
-            class: ["vxe-checkbox--icon", isIndeterminate ? getIcon().CHECKBOX_INDETERMINATE : isChecked ? getIcon().CHECKBOX_CHECKED : isDisabled ? getIcon().CHECKBOX_DISABLED_UNCHECKED : getIcon().CHECKBOX_UNCHECKED]
-          })
-        ]);
+          },
+          [
+            (0, import_vue.h)("span", {
+              class: ["vxe-checkbox--icon", isIndeterminate ? getIcon().CHECKBOX_INDETERMINATE : isChecked ? getIcon().CHECKBOX_CHECKED : isDisabled ? getIcon().CHECKBOX_DISABLED_UNCHECKED : getIcon().CHECKBOX_UNCHECKED]
+            })
+          ]
+        );
       }
       return renderEmptyElement($xeTree);
     };
@@ -3118,66 +3187,105 @@ var tree_default = (0, import_comp.defineVxeComponent)({
         itemOns.onDragend = handleNodeDragDragendEvent;
         itemOns.onDragover = handleNodeDragDragoverEvent;
       }
-      return (0, import_vue.h)("div", {
-        key: nodeid,
-        class: ["vxe-tree--node-wrapper", `node--level-${nLevel}`],
-        nodeid,
-        title: tipMode === "title" ? nodeTitle : "",
-        ...itemOns
-      }, [
-        (0, import_vue.h)("div", {
-          class: ["vxe-tree--node-item", {
-            "is--current": currentNode && nodeid === getNodeId(currentNode),
-            "is-radio--disabled": isRadioDisabled,
-            "is-radio--checked": isRadioChecked,
-            "is-checkbox--disabled": isCheckboxDisabled,
-            "is-checkbox--checked": isCheckboxChecked,
-            "is-checkbox--indeterminate": isCheckboxIndeterminate
-          }]
-        }, [
-          showLine ? (0, import_vue.h)("div", {
-            class: "vxe-tree--node-line-wrapper"
-          }, [
-            (0, import_vue.h)("div", {
-              class: "vxe-tree--node-line",
-              style: {
-                height: `${getNodeId(afterTreeList[0]) === nodeid ? 1 : (0, import_util.calcTreeLine)($xeTree, node, prevNode)}px`
-              }
-            })
-          ]) : renderEmptyElement($xeTree),
-          (0, import_vue.h)("div", {
-            class: "vxe-tree--node-item-switcher"
-          }, showIcon && (lazy ? isLazyLoaded ? isExistChild : hasLazyChilds : isExistChild) && (!visibleMethod || visibleMethod(nParams)) ? [
-            (0, import_vue.h)("div", {
-              class: "vxe-tree--node-item-icon",
-              onClick(evnt) {
-                toggleExpandEvent(evnt, node);
-              }
-            }, iconSlot ? (0, import_vn.getSlotVNs)(iconSlot(nParams)) : [
-              (0, import_vue.h)("i", {
-                class: isLazyLoading ? iconLoaded || getIcon().TREE_NODE_LOADED : isExpand ? iconOpen || getIcon().TREE_NODE_OPEN : iconClose || getIcon().TREE_NODE_CLOSE
-              })
-            ])
-          ] : []),
-          renderRadio(node, nodeid, isExistChild, nLevel, isRadioDisabled, isRadioChecked),
-          renderCheckbox(node, nodeid, isExistChild, nLevel, isCheckboxDisabled, isCheckboxChecked, isCheckboxIndeterminate),
-          renderDragIcon(node, nodeid),
-          (0, import_vue.h)("div", {
-            class: "vxe-tree--node-item-inner"
-          }, [
-            (0, import_vue.h)("div", {
-              class: "vxe-tree--node-item-wrapper"
-            }, [
-              (0, import_vue.h)("span", {
-                class: "vxe-tree--node-item-title"
-              }, titleSlot ? (0, import_vn.getSlotVNs)(titleSlot(nParams)) : nodeTitle)
-            ]),
-            extraSlot ? (0, import_vue.h)("div", {
-              class: "vxe-tree--node-item-extra"
-            }, (0, import_vn.getSlotVNs)(extraSlot(nParams))) : renderEmptyElement($xeTree)
-          ])
-        ])
-      ]);
+      return (0, import_vue.h)(
+        "div",
+        {
+          key: nodeid,
+          class: ["vxe-tree--node-wrapper", `node--level-${nLevel}`],
+          nodeid,
+          title: tipMode === "title" ? nodeTitle : "",
+          ...itemOns
+        },
+        [
+          (0, import_vue.h)(
+            "div",
+            {
+              class: [
+                "vxe-tree--node-item",
+                {
+                  "is--current": currentNode && nodeid === getNodeId(currentNode),
+                  "is-radio--disabled": isRadioDisabled,
+                  "is-radio--checked": isRadioChecked,
+                  "is-checkbox--disabled": isCheckboxDisabled,
+                  "is-checkbox--checked": isCheckboxChecked,
+                  "is-checkbox--indeterminate": isCheckboxIndeterminate
+                }
+              ]
+            },
+            [
+              showLine ? (0, import_vue.h)(
+                "div",
+                {
+                  class: "vxe-tree--node-line-wrapper"
+                },
+                [
+                  (0, import_vue.h)("div", {
+                    class: "vxe-tree--node-line",
+                    style: {
+                      height: `${getNodeId(afterTreeList[0]) === nodeid ? 1 : (0, import_util.calcTreeLine)($xeTree, node, prevNode)}px`
+                    }
+                  })
+                ]
+              ) : renderEmptyElement($xeTree),
+              (0, import_vue.h)(
+                "div",
+                {
+                  class: "vxe-tree--node-item-switcher"
+                },
+                showIcon && (lazy ? isLazyLoaded ? isExistChild : hasLazyChilds : isExistChild) && (!visibleMethod || visibleMethod(nParams)) ? [
+                  (0, import_vue.h)(
+                    "div",
+                    {
+                      class: "vxe-tree--node-item-icon",
+                      onClick(evnt) {
+                        toggleExpandEvent(evnt, node);
+                      }
+                    },
+                    iconSlot ? (0, import_vn.getSlotVNs)(iconSlot(nParams)) : [
+                      (0, import_vue.h)("i", {
+                        class: isLazyLoading ? iconLoaded || getIcon().TREE_NODE_LOADED : isExpand ? iconOpen || getIcon().TREE_NODE_OPEN : iconClose || getIcon().TREE_NODE_CLOSE
+                      })
+                    ]
+                  )
+                ] : []
+              ),
+              renderRadio(node, nodeid, isExistChild, nLevel, isRadioDisabled, isRadioChecked),
+              renderCheckbox(node, nodeid, isExistChild, nLevel, isCheckboxDisabled, isCheckboxChecked, isCheckboxIndeterminate),
+              renderDragIcon(node, nodeid),
+              (0, import_vue.h)(
+                "div",
+                {
+                  class: "vxe-tree--node-item-inner"
+                },
+                [
+                  (0, import_vue.h)(
+                    "div",
+                    {
+                      class: "vxe-tree--node-item-wrapper"
+                    },
+                    [
+                      (0, import_vue.h)(
+                        "span",
+                        {
+                          class: "vxe-tree--node-item-title"
+                        },
+                        titleSlot ? (0, import_vn.getSlotVNs)(titleSlot(nParams)) : nodeTitle
+                      )
+                    ]
+                  ),
+                  extraSlot ? (0, import_vue.h)(
+                    "div",
+                    {
+                      class: "vxe-tree--node-item-extra"
+                    },
+                    (0, import_vn.getSlotVNs)(extraSlot(nParams))
+                  ) : renderEmptyElement($xeTree)
+                ]
+              )
+            ]
+          )
+        ]
+      );
     };
     const renderList = (treeList) => {
       const { loading, transform, emptyText } = props;
@@ -3186,28 +3294,38 @@ var tree_default = (0, import_comp.defineVxeComponent)({
       const emptySlot = slots.empty;
       if (!loading && !treeList.length) {
         return [
-          (0, import_vue.h)("div", {
-            class: "vxe-tree--empty-placeholder"
-          }, emptySlot ? emptySlot({}) : [
-            (0, import_vue.h)("div", {
-              class: "vxe-tree--empty-placeholder-content"
-            }, (0, import_utils.getText)(emptyText || getI18n("vxe.tree.searchEmpty")))
-          ])
+          (0, import_vue.h)(
+            "div",
+            {
+              class: "vxe-tree--empty-placeholder"
+            },
+            emptySlot ? emptySlot({}) : [
+              (0, import_vue.h)(
+                "div",
+                {
+                  class: "vxe-tree--empty-placeholder-content"
+                },
+                (0, import_utils.getText)(emptyText || getI18n("vxe.tree.searchEmpty"))
+              )
+            ]
+          )
         ];
       }
       const nodeVNs = [];
-      treeList.forEach(transform ? (node) => {
-        const nodeid = getNodeId(node);
-        nodeVNs.push(renderNode(node, nodeid));
-      } : (node) => {
-        const nodeid = getNodeId(node);
-        nodeVNs.push(renderNode(node, nodeid));
-        const childList = import_xe_utils.default.get(node, childrenField);
-        const hasChild = childList && childList.length;
-        if (hasChild && treeExpandedMaps[nodeid]) {
-          nodeVNs.push(...renderList(childList));
+      treeList.forEach(
+        transform ? (node) => {
+          const nodeid = getNodeId(node);
+          nodeVNs.push(renderNode(node, nodeid));
+        } : (node) => {
+          const nodeid = getNodeId(node);
+          nodeVNs.push(renderNode(node, nodeid));
+          const childList = import_xe_utils.default.get(node, childrenField);
+          const hasChild = childList && childList.length;
+          if (hasChild && treeExpandedMaps[nodeid]) {
+            nodeVNs.push(...renderList(childList));
+          }
         }
-      });
+      );
       return nodeVNs;
     };
     const renderDragTip = () => {
@@ -3216,41 +3334,64 @@ var tree_default = (0, import_comp.defineVxeComponent)({
       const dragOpts = computeDragOpts.value;
       const dNode = dragNode;
       if (drag) {
-        return (0, import_vue.h)("div", {
-          class: "vxe-tree--drag-wrapper"
-        }, [
-          (0, import_vue.h)("div", {
-            ref: refDragNodeLineElem,
-            class: ["vxe-tree--drag-node-line", {
-              "is--guides": dragOpts.showGuidesStatus
-            }]
-          }),
-          dNode && dragOpts.showDragTip ? (0, import_vue.h)("div", {
-            ref: refDragTipElem,
-            class: "vxe-tree--drag-sort-tip"
-          }, [
+        return (0, import_vue.h)(
+          "div",
+          {
+            class: "vxe-tree--drag-wrapper"
+          },
+          [
             (0, import_vue.h)("div", {
-              class: "vxe-tree--drag-sort-tip-wrapper"
-            }, [
-              (0, import_vue.h)("div", {
-                class: "vxe-tree--drag-sort-tip-status"
-              }, [
-                (0, import_vue.h)("span", {
-                  class: ["vxe-tree--drag-sort-tip-normal-status", getIcon().TREE_DRAG_STATUS_NODE]
-                }),
-                (0, import_vue.h)("span", {
-                  class: ["vxe-tree--drag-sort-tip-sub-status", getIcon().TREE_DRAG_STATUS_SUB_NODE]
-                }),
-                (0, import_vue.h)("span", {
-                  class: ["vxe-tree--drag-sort-tip-disabled-status", getIcon().TREE_DRAG_DISABLED]
-                })
-              ]),
-              (0, import_vue.h)("div", {
-                class: "vxe-tree--drag-sort-tip-content"
-              }, dragTipText)
-            ])
-          ]) : renderEmptyElement($xeTree)
-        ]);
+              ref: refDragNodeLineElem,
+              class: [
+                "vxe-tree--drag-node-line",
+                {
+                  "is--guides": dragOpts.showGuidesStatus
+                }
+              ]
+            }),
+            dNode && dragOpts.showDragTip ? (0, import_vue.h)(
+              "div",
+              {
+                ref: refDragTipElem,
+                class: "vxe-tree--drag-sort-tip"
+              },
+              [
+                (0, import_vue.h)(
+                  "div",
+                  {
+                    class: "vxe-tree--drag-sort-tip-wrapper"
+                  },
+                  [
+                    (0, import_vue.h)(
+                      "div",
+                      {
+                        class: "vxe-tree--drag-sort-tip-status"
+                      },
+                      [
+                        (0, import_vue.h)("span", {
+                          class: ["vxe-tree--drag-sort-tip-normal-status", getIcon().TREE_DRAG_STATUS_NODE]
+                        }),
+                        (0, import_vue.h)("span", {
+                          class: ["vxe-tree--drag-sort-tip-sub-status", getIcon().TREE_DRAG_STATUS_SUB_NODE]
+                        }),
+                        (0, import_vue.h)("span", {
+                          class: ["vxe-tree--drag-sort-tip-disabled-status", getIcon().TREE_DRAG_DISABLED]
+                        })
+                      ]
+                    ),
+                    (0, import_vue.h)(
+                      "div",
+                      {
+                        class: "vxe-tree--drag-sort-tip-content"
+                      },
+                      dragTipText
+                    )
+                  ]
+                )
+              ]
+            ) : renderEmptyElement($xeTree)
+          ]
+        );
       }
       return renderEmptyElement($xeTree);
     };
@@ -3283,187 +3424,263 @@ var tree_default = (0, import_comp.defineVxeComponent)({
       if (dragOpts.isCrossTreeDrag && !treeList.length) {
         teOns.onDragover = $xeTree.handleCrossTreeNodeDragoverEmptyEvent;
       }
-      return (0, import_vue.h)("div", {
-        ref: refElem,
-        class: [
-          "vxe-tree",
-          isVScrollbar ? `ov-x--${scrollXVisible === false ? "hidden" : "visible"}` : "",
-          isVScrollbar ? `ov-y--${scrollYVisible === false ? "hidden" : "visible"}` : "",
-          isVScrollbar ? `sx-pos--${scrollbarXToTop ? "top" : "bottom"}` : "",
-          isVScrollbar ? `sy-pos--${scrollbarYToLeft ? "left" : "right"}` : "",
-          {
-            [`size--${vSize}`]: vSize,
-            "show--line": showLine,
-            "is--virtual-scrollbar": isVScrollbar,
-            "ov-padding": isVScrollbar && scrollbarOpts.padding,
-            "ov-x--auto-hide": isVScrollbar && scrollXAutoHide,
-            "ov-y--auto-hide": isVScrollbar && scrollYAutoHide,
-            "overflow-y": yThumbHeight,
-            "overflow-x": xThumbWidth,
-            "checkbox--highlight": checkboxOpts.highlight,
-            "radio--highlight": radioOpts.highlight,
-            "node--hover": isNodeHover,
-            "node--trigger": trigger === "node",
-            "is--loading": loading
-          }
-        ],
-        style: wrapperStyles,
-        ...teOns
-      }, [
-        headerSlot ? (0, import_vue.h)("div", {
-          ref: refHeaderWrapperElem,
-          class: "vxe-tree--header-wrapper"
-        }, headerSlot({ $tree: $xeTree })) : renderEmptyElement($xeTree),
-        (0, import_vue.h)("div", {
-          ref: refVirtualWrapper,
-          class: "vxe-tree--node-list-wrapper",
-          style: treeStyle,
-          onScroll: scrollEvent
-        }, [
-          (0, import_vue.h)("div", {
-            ref: refVirtualSpaceElem,
-            class: "vxe-tree--y-space",
-            style: {
-              height: bodyHeight ? `${bodyHeight}px` : ""
-            }
-          }),
-          (0, import_vue.h)("div", {
-            ref: refVirtualBody,
-            class: "vxe-tree--node-list-body",
-            style: {
-              transform: `translateY(${topSpaceHeight}px)`
+      return (0, import_vue.h)(
+        "div",
+        {
+          ref: refElem,
+          class: [
+            "vxe-tree",
+            isVScrollbar ? `ov-x--${scrollXVisible === false ? "hidden" : "visible"}` : "",
+            isVScrollbar ? `ov-y--${scrollYVisible === false ? "hidden" : "visible"}` : "",
+            isVScrollbar ? `sx-pos--${scrollbarXToTop ? "top" : "bottom"}` : "",
+            isVScrollbar ? `sy-pos--${scrollbarYToLeft ? "left" : "right"}` : "",
+            {
+              [`size--${vSize}`]: vSize,
+              "show--line": showLine,
+              "is--virtual-scrollbar": isVScrollbar,
+              "ov-padding": isVScrollbar && scrollbarOpts.padding,
+              "ov-x--auto-hide": isVScrollbar && scrollXAutoHide,
+              "ov-y--auto-hide": isVScrollbar && scrollYAutoHide,
+              "overflow-y": yThumbHeight,
+              "overflow-x": xThumbWidth,
+              "checkbox--highlight": checkboxOpts.highlight,
+              "radio--highlight": radioOpts.highlight,
+              "node--hover": isNodeHover,
+              "node--trigger": trigger === "node",
+              "is--loading": loading
             }
-          }, renderList(treeList))
-        ]),
-        footerSlot ? (0, import_vue.h)("div", {
-          ref: refFooterWrapperElem,
-          class: "vxe-tree--footer-wrapper"
-        }, footerSlot({ $tree: $xeTree })) : renderEmptyElement($xeTree),
-        /**
-         * 滚动条
-         */
-        isVScrollbar ? (0, import_vue.h)("div", {
-          class: scrollbarWrapperClss
-        }, [
-          scrollXVisible === false ? renderEmptyElement($xeTree) : (0, import_vue.h)("div", {
-            ref: refTrackXElem,
-            class: "vxe-scrollbar--track-x",
-            onClick: clickTrackXEvent
-          }, [
-            (0, import_vue.h)("div", {
-              ref: refThumbXElem,
-              class: "vxe-scrollbar--thumb-x",
-              onPointerdown: pointerdownThumbXEvent,
-              onPointermove: pointermoveThumbXEvent,
-              onPointerup: cleatPointerThumbEvent,
-              onPointercancel: cleatPointerThumbEvent,
-              onLostpointercapture: cleatPointerThumbEvent
-            })
-          ]),
-          scrollYVisible === false ? renderEmptyElement($xeTree) : (0, import_vue.h)("div", {
-            ref: refTrackYElem,
-            class: "vxe-scrollbar--track-y",
-            onClick: clickTrackYEvent
-          }, [
-            (0, import_vue.h)("div", {
-              ref: refThumbYElem,
-              class: "vxe-scrollbar--thumb-y",
-              onPointerdown: pointerdownThumbYEvent,
-              onPointermove: pointermoveThumbYEvent,
-              onPointerup: cleatPointerThumbEvent,
-              onPointercancel: cleatPointerThumbEvent,
-              onLostpointercapture: cleatPointerThumbEvent
-            })
-          ])
-        ]) : renderEmptyElement($xeTree),
-        /**
-         * 拖拽提示
-         */
-        renderDragTip(),
-        /**
-          * 工具提示
-          */
-        tooltipOpts.mode === "tooltip" ? (0, import_vue.h)(import_tooltip.default, {
-          ref: refTooltip,
-          theme: tooltipOpts.theme,
-          enterable: tooltipOpts.enterable,
-          enterDelay: tooltipOpts.enterDelay,
-          leaveDelay: tooltipOpts.leaveDelay,
-          useHtml: tooltipOpts.useHtml,
-          width: tooltipOpts.width,
-          height: tooltipOpts.height,
-          minWidth: tooltipOpts.minWidth,
-          minHeight: tooltipOpts.minHeight,
-          maxWidth: tooltipOpts.maxWidth,
-          maxHeight: tooltipOpts.maxHeight,
-          placement: tooltipOpts.placement,
-          defaultPlacement: tooltipOpts.defaultPlacement,
-          popupClassName: tooltipOpts.popupClassName
-        }, tooltipSlot ? {
-          content: () => {
-            const { node } = tooltipStore;
-            return tooltipSlot({ node, $tree: $xeTree });
-          }
-        } : void 0) : renderEmptyElement($xeTree),
-        /**
-         * 加载中
-         */
-        (0, import_vue.h)(import_loading.default, {
-          class: "vxe-tree--loading",
-          modelValue: loading,
-          icon: loadingOpts.icon,
-          text: loadingOpts.text
-        }, loadingSlot ? {
-          default: () => loadingSlot({ $tree: $xeTree })
-        } : void 0)
-      ]);
+          ],
+          style: wrapperStyles,
+          ...teOns
+        },
+        [
+          headerSlot ? (0, import_vue.h)(
+            "div",
+            {
+              ref: refHeaderWrapperElem,
+              class: "vxe-tree--header-wrapper"
+            },
+            headerSlot({ $tree: $xeTree })
+          ) : renderEmptyElement($xeTree),
+          (0, import_vue.h)(
+            "div",
+            {
+              ref: refVirtualWrapper,
+              class: "vxe-tree--node-list-wrapper",
+              style: treeStyle,
+              onScroll: scrollEvent
+            },
+            [
+              (0, import_vue.h)("div", {
+                ref: refVirtualSpaceElem,
+                class: "vxe-tree--y-space",
+                style: {
+                  height: bodyHeight ? `${bodyHeight}px` : ""
+                }
+              }),
+              (0, import_vue.h)(
+                "div",
+                {
+                  ref: refVirtualBody,
+                  class: "vxe-tree--node-list-body",
+                  style: {
+                    transform: `translateY(${topSpaceHeight}px)`
+                  }
+                },
+                renderList(treeList)
+              )
+            ]
+          ),
+          footerSlot ? (0, import_vue.h)(
+            "div",
+            {
+              ref: refFooterWrapperElem,
+              class: "vxe-tree--footer-wrapper"
+            },
+            footerSlot({ $tree: $xeTree })
+          ) : renderEmptyElement($xeTree),
+          /**
+           * 滚动条
+           */
+          isVScrollbar ? (0, import_vue.h)(
+            "div",
+            {
+              class: scrollbarWrapperClss
+            },
+            [
+              scrollXVisible === false ? renderEmptyElement($xeTree) : (0, import_vue.h)(
+                "div",
+                {
+                  ref: refTrackXElem,
+                  class: "vxe-scrollbar--track-x",
+                  onClick: clickTrackXEvent
+                },
+                [
+                  (0, import_vue.h)("div", {
+                    ref: refThumbXElem,
+                    class: "vxe-scrollbar--thumb-x",
+                    onPointerdown: pointerdownThumbXEvent,
+                    onPointermove: pointermoveThumbXEvent,
+                    onPointerup: cleatPointerThumbEvent,
+                    onPointercancel: cleatPointerThumbEvent,
+                    onLostpointercapture: cleatPointerThumbEvent
+                  })
+                ]
+              ),
+              scrollYVisible === false ? renderEmptyElement($xeTree) : (0, import_vue.h)(
+                "div",
+                {
+                  ref: refTrackYElem,
+                  class: "vxe-scrollbar--track-y",
+                  onClick: clickTrackYEvent
+                },
+                [
+                  (0, import_vue.h)("div", {
+                    ref: refThumbYElem,
+                    class: "vxe-scrollbar--thumb-y",
+                    onPointerdown: pointerdownThumbYEvent,
+                    onPointermove: pointermoveThumbYEvent,
+                    onPointerup: cleatPointerThumbEvent,
+                    onPointercancel: cleatPointerThumbEvent,
+                    onLostpointercapture: cleatPointerThumbEvent
+                  })
+                ]
+              )
+            ]
+          ) : renderEmptyElement($xeTree),
+          /**
+           * 拖拽提示
+           */
+          renderDragTip(),
+          /**
+           * 工具提示
+           */
+          tooltipOpts.mode === "tooltip" ? (0, import_vue.h)(
+            import_tooltip.default,
+            {
+              ref: refTooltip,
+              theme: tooltipOpts.theme,
+              enterable: tooltipOpts.enterable,
+              enterDelay: tooltipOpts.enterDelay,
+              leaveDelay: tooltipOpts.leaveDelay,
+              useHtml: tooltipOpts.useHtml,
+              width: tooltipOpts.width,
+              height: tooltipOpts.height,
+              minWidth: tooltipOpts.minWidth,
+              minHeight: tooltipOpts.minHeight,
+              maxWidth: tooltipOpts.maxWidth,
+              maxHeight: tooltipOpts.maxHeight,
+              placement: tooltipOpts.placement,
+              defaultPlacement: tooltipOpts.defaultPlacement,
+              popupClassName: tooltipOpts.popupClassName
+            },
+            tooltipSlot ? {
+              content: () => {
+                const { node } = tooltipStore;
+                return tooltipSlot({ node, $tree: $xeTree });
+              }
+            } : void 0
+          ) : renderEmptyElement($xeTree),
+          /**
+           * 加载中
+           */
+          (0, import_vue.h)(
+            import_loading.default,
+            {
+              class: "vxe-tree--loading",
+              modelValue: loading,
+              icon: loadingOpts.icon,
+              text: loadingOpts.text
+            },
+            loadingSlot ? {
+              default: () => loadingSlot({ $tree: $xeTree })
+            } : void 0
+          )
+        ]
+      );
     };
     const dataFlag = (0, import_vue.ref)(0);
-    (0, import_vue.watch)(() => props.data ? props.data.length : 0, () => {
-      dataFlag.value++;
-    });
-    (0, import_vue.watch)(() => props.data, () => {
-      dataFlag.value++;
-    });
-    (0, import_vue.watch)(() => props.rootParentValue, () => {
-      dataFlag.value++;
-    });
-    (0, import_vue.watch)(() => props.rootValues ? props.rootValues.length : 0, () => {
-      dataFlag.value++;
-    });
-    (0, import_vue.watch)(() => props.rootValues, () => {
-      dataFlag.value++;
-    });
+    (0, import_vue.watch)(
+      () => props.data ? props.data.length : 0,
+      () => {
+        dataFlag.value++;
+      }
+    );
+    (0, import_vue.watch)(
+      () => props.data,
+      () => {
+        dataFlag.value++;
+      }
+    );
+    (0, import_vue.watch)(
+      () => props.rootParentValue,
+      () => {
+        dataFlag.value++;
+      }
+    );
+    (0, import_vue.watch)(
+      () => props.rootValues ? props.rootValues.length : 0,
+      () => {
+        dataFlag.value++;
+      }
+    );
+    (0, import_vue.watch)(
+      () => props.rootValues,
+      () => {
+        dataFlag.value++;
+      }
+    );
     (0, import_vue.watch)(dataFlag, () => {
       loadData(props.data || []);
     });
-    (0, import_vue.watch)(() => props.checkNodeKey, (nodeKey) => {
-      reactData.selectRadioKey = (0, import_utils.enModelValue)(nodeKey);
-    });
+    (0, import_vue.watch)(
+      () => props.checkNodeKey,
+      (nodeKey) => {
+        reactData.selectRadioKey = (0, import_utils.enModelValue)(nodeKey);
+      }
+    );
     const checkboxFlag = (0, import_vue.ref)(0);
-    (0, import_vue.watch)(() => props.checkNodeKeys ? props.checkNodeKeys.length : 0, () => {
-      checkboxFlag.value++;
-    });
-    (0, import_vue.watch)(() => props.checkNodeKeys, () => {
-      checkboxFlag.value++;
-    });
+    (0, import_vue.watch)(
+      () => props.checkNodeKeys ? props.checkNodeKeys.length : 0,
+      () => {
+        checkboxFlag.value++;
+      }
+    );
+    (0, import_vue.watch)(
+      () => props.checkNodeKeys,
+      () => {
+        checkboxFlag.value++;
+      }
+    );
     (0, import_vue.watch)(checkboxFlag, () => {
       updateCheckboxChecked(props.checkNodeKeys || []);
     });
-    (0, import_vue.watch)(() => props.filterValue, () => {
-      triggerSearchEvent(new Event("filter"));
-    });
+    (0, import_vue.watch)(
+      () => props.filterValue,
+      () => {
+        triggerSearchEvent(new Event("filter"));
+      }
+    );
     const reScrollFlag = (0, import_vue.ref)(0);
     const reLayoutFlag = (0, import_vue.ref)(0);
-    (0, import_vue.watch)(() => props.height, () => {
-      reLayoutFlag.value++;
-    });
-    (0, import_vue.watch)(() => props.minHeight, () => {
-      reLayoutFlag.value++;
-    });
-    (0, import_vue.watch)(() => props.maxHeight, () => {
-      reLayoutFlag.value++;
-    });
+    (0, import_vue.watch)(
+      () => props.height,
+      () => {
+        reLayoutFlag.value++;
+      }
+    );
+    (0, import_vue.watch)(
+      () => props.minHeight,
+      () => {
+        reLayoutFlag.value++;
+      }
+    );
+    (0, import_vue.watch)(
+      () => props.maxHeight,
+      () => {
+        reLayoutFlag.value++;
+      }
+    );
     (0, import_vue.watch)(computeIsVScrollbar, () => {
       (0, import_vue.nextTick)(() => {
         bindScrollbarResize();
@@ -3513,7 +3730,7 @@ var tree_default = (0, import_comp.defineVxeComponent)({
       if (lazy && !loadMethod) {
         warnLog("vxe.error.reqSupportProp", ["lazy", "load-method"]);
       }
-      const VxeUIContextMenu = import_ui.VxeUI.getComponent("VxeContextMenu");
+      const VxeUIContextMenu = import_core.VxeUI.getComponent("VxeContextMenu");
       if (menuConfig && !VxeUIContextMenu) {
         errLog("vxe.error.reqComp", ["vxe-context-menu"]);
       }