vxe-pc-ui 4.15.15 → 4.15.16

package/dist/all.esm.js

@@ -81,7 +81,7 @@ function checkDynamic() {
 }
 
 const { log } = VxeUI;
-const uiVersion = `ui v${"4.15.15"}`;
+const uiVersion = `ui v${"4.15.16"}`;
 function createComponentLog(name) {
     const tableVersion = VxeUI.tableVersion ? `table v${VxeUI.tableVersion}` : '';
     const ganttVersion = VxeUI.ganttVersion ? `gantt v${VxeUI.ganttVersion}` : '';
@@ -95,7 +95,7 @@ function createComponentLog(name) {
 const warnLog$c = log.create('warn', uiVersion);
 log.create('error', uiVersion);
 
-const version = "4.15.15";
+const version = "4.15.16";
 VxeUI.uiVersion = version;
 VxeUI.dynamicApp = dynamicApp;
 function config(options) {
@@ -39479,7 +39479,7 @@ function createInternalData$2() {
         afterVisibleList: [],
         nodeMaps: {},
         selectCheckboxMaps: {},
-        indeterminateRowMaps: {},
+        indeterminateNodeMaps: {},
         treeExpandedMaps: {},
         treeExpandLazyLoadedMaps: {},
         lastScrollLeft: 0,
@@ -39491,8 +39491,8 @@ function createInternalData$2() {
             offsetSize: 0,
             rowHeight: 0
         },
-        removeRowMaps: {},
-        insertRowMaps: {},
+        removeNodeMaps: {},
+        insertNodeMaps: {},
         // prevDragNode: null,
         // prevDragToChild: false,
         // prevDragPos: ''
@@ -39514,10 +39514,11 @@ function createReactData$2() {
         treeList: [],
         updateExpandedFlag: 1,
         updateCheckboxFlag: 1,
-        insertRowFlag: 1,
-        removeRowFlag: 1,
+        insertNodeFlag: 1,
+        removeNodeFlag: 1,
         dragNode: null,
-        dragTipText: ''
+        dragTipText: '',
+        isCrossDragNode: false
     };
 }
 let crossTreeDragNodeObj = null;
@@ -39705,7 +39706,7 @@ var VxeTreeComponent = defineVxeComponent({
         const computeVirtualYOpts = computed(() => {
             return Object.assign({}, getConfig().tree.virtualYConfig, props.virtualYConfig);
         });
-        const computeIsRowCurrent = computed(() => {
+        const computeIsNodeCurrent = computed(() => {
             const nodeOpts = computeNodeOpts.value;
             const { isCurrent } = nodeOpts;
             if (XEUtils.isBoolean(isCurrent)) {
@@ -39713,7 +39714,7 @@ var VxeTreeComponent = defineVxeComponent({
             }
             return props.isCurrent;
         });
-        const computeIsRowHover = computed(() => {
+        const computeIsNodeHover = computed(() => {
             const nodeOpts = computeNodeOpts.value;
             const { isHover } = nodeOpts;
             if (XEUtils.isBoolean(isHover)) {
@@ -39821,8 +39822,8 @@ var VxeTreeComponent = defineVxeComponent({
         };
         const isIndeterminateByCheckboxNodeid = (nodeid) => {
             const { updateCheckboxFlag } = reactData;
-            const { indeterminateRowMaps } = internalData;
-            return !!(updateCheckboxFlag && indeterminateRowMaps[nodeid]);
+            const { indeterminateNodeMaps } = internalData;
+            return !!(updateCheckboxFlag && indeterminateNodeMaps[nodeid]);
         };
         const isIndeterminateByCheckboxNode = (node) => {
             return isIndeterminateByCheckboxNodeid(getNodeId(node));
@@ -40108,10 +40109,10 @@ var VxeTreeComponent = defineVxeComponent({
             const expandMaps = {};
             if (transform) {
                 const fullData = [];
-                XEUtils.eachTree(afterTreeList, (item, index, items, path, parentRow) => {
+                XEUtils.eachTree(afterTreeList, (item, index, items, path, parentNode) => {
                     const nodeid = getNodeId(item);
-                    const parentNodeid = getNodeId(parentRow);
-                    if (!parentRow || (expandMaps[parentNodeid] && treeExpandedMaps[parentNodeid])) {
+                    const parentNodeid = getNodeId(parentNode);
+                    if (!parentNode || (expandMaps[parentNodeid] && treeExpandedMaps[parentNodeid])) {
                         expandMaps[nodeid] = 1;
                         fullData.push(item);
                     }
@@ -40159,6 +40160,10 @@ var VxeTreeComponent = defineVxeComponent({
                 })
                 : list ? list.slice(0) : [];
             internalData.treeFullData = fullData;
+            internalData.insertNodeMaps = {};
+            reactData.insertNodeFlag++;
+            internalData.removeNodeMaps = {};
+            reactData.removeNodeFlag++;
             Object.assign(scrollYStore, {
                 startIndex: 0,
                 endIndex: 1,
@@ -40376,12 +40381,12 @@ var VxeTreeComponent = defineVxeComponent({
             const { showRadio, showCheckbox, trigger } = props;
             const radioOpts = computeRadioOpts.value;
             const checkboxOpts = computeCheckboxOpts.value;
-            const isRowCurrent = computeIsRowCurrent.value;
+            const isNodeCurrent = computeIsNodeCurrent.value;
             let triggerCurrent = false;
             let triggerRadio = false;
             let triggerCheckbox = false;
             let triggerExpand = false;
-            if (isRowCurrent) {
+            if (isNodeCurrent) {
                 triggerCurrent = true;
                 changeCurrentEvent(evnt, node);
             }
@@ -40407,12 +40412,12 @@ var VxeTreeComponent = defineVxeComponent({
         };
         const handleContextmenuEvent = (evnt, node) => {
             const { menuConfig } = props;
-            const isRowCurrent = computeIsRowCurrent.value;
+            const isNodeCurrent = computeIsNodeCurrent.value;
             const menuOpts = computeMenuOpts.value;
             if (menuConfig ? isEnableConf(menuOpts) : menuOpts.enabled) {
                 const { options, visibleMethod } = menuOpts;
                 if (!visibleMethod || visibleMethod({ $tree: $xeTree, options, node })) {
-                    if (isRowCurrent) {
+                    if (isNodeCurrent) {
                         changeCurrentEvent(evnt, node);
                     }
                     else if (reactData.currentNode) {
@@ -40468,15 +40473,15 @@ var VxeTreeComponent = defineVxeComponent({
                             childRecords = [];
                         }
                         if (childRecords) {
-                            return $xeTree.loadChildrenNode(node, childRecords).then(childRows => {
+                            return $xeTree.loadChildrenNode(node, childRecords).then(childNodes => {
                                 const { treeExpandedMaps } = internalData;
-                                if (childRows.length && !treeExpandedMaps[nodeid]) {
+                                if (childNodes.length && !treeExpandedMaps[nodeid]) {
                                     treeExpandedMaps[nodeid] = true;
                                 }
                                 reactData.updateExpandedFlag++;
                                 // 如果当前节点已选中，则展开后子节点也被选中
                                 if (!checkStrictly && $xeTree.isCheckedByCheckboxNodeId(nodeid)) {
-                                    handleCheckedCheckboxNode(childRows, true);
+                                    handleCheckedCheckboxNode(childNodes, true);
                                 }
                                 dispatchEvent('load-success', { node, data: childRecords }, new Event('load-success'));
                                 return nextTick();
@@ -40575,23 +40580,23 @@ var VxeTreeComponent = defineVxeComponent({
         };
         const updateCheckboxStatus = () => {
             const { transform } = props;
-            const { selectCheckboxMaps, indeterminateRowMaps, afterTreeList } = internalData;
+            const { selectCheckboxMaps, indeterminateNodeMaps, afterTreeList } = internalData;
             const childrenField = computeChildrenField.value;
             const mapChildrenField = computeMapChildrenField.value;
             const checkboxOpts = computeCheckboxOpts.value;
             const { checkStrictly, checkMethod } = checkboxOpts;
             if (!checkStrictly) {
-                const childRowMaps = {};
-                const childRowList = [];
+                const childNodeMaps = {};
+                const childNodeList = [];
                 XEUtils.eachTree(afterTreeList, (node) => {
                     const nodeid = getNodeId(node);
                     const childList = node[childrenField];
-                    if (childList && childList.length && !childRowMaps[nodeid]) {
-                        childRowMaps[nodeid] = 1;
-                        childRowList.unshift([node, nodeid, childList]);
+                    if (childList && childList.length && !childNodeMaps[nodeid]) {
+                        childNodeMaps[nodeid] = 1;
+                        childNodeList.unshift([node, nodeid, childList]);
                     }
                 }, { children: transform ? mapChildrenField : childrenField });
-                childRowList.forEach(vals => {
+                childNodeList.forEach(vals => {
                     const node = vals[0];
                     const nodeid = vals[1];
                     const childList = vals[2];
@@ -40607,7 +40612,7 @@ var VxeTreeComponent = defineVxeComponent({
                                 if (isSelect) {
                                     sLen++;
                                 }
-                                else if (indeterminateRowMaps[childNodeid]) {
+                                else if (indeterminateNodeMaps[childNodeid]) {
                                     hLen++;
                                 }
                                 vLen++;
@@ -40616,7 +40621,7 @@ var VxeTreeComponent = defineVxeComponent({
                                 if (isSelect) {
                                     sLen++;
                                 }
-                                else if (indeterminateRowMaps[childNodeid]) {
+                                else if (indeterminateNodeMaps[childNodeid]) {
                                     hLen++;
                                 }
                             }
@@ -40627,7 +40632,7 @@ var VxeTreeComponent = defineVxeComponent({
                             if (isSelect) {
                                 sLen++;
                             }
-                            else if (indeterminateRowMaps[childNodeid]) {
+                            else if (indeterminateNodeMaps[childNodeid]) {
                                 hLen++;
                             }
                             vLen++;
@@ -40657,8 +40662,8 @@ var VxeTreeComponent = defineVxeComponent({
                     const halfSelect = !isSelected && (sLen > 0 || hLen > 0);
                     if (isSelected) {
                         selectCheckboxMaps[nodeid] = node;
-                        if (indeterminateRowMaps[nodeid]) {
-                            delete indeterminateRowMaps[nodeid];
+                        if (indeterminateNodeMaps[nodeid]) {
+                            delete indeterminateNodeMaps[nodeid];
                         }
                     }
                     else {
@@ -40666,11 +40671,11 @@ var VxeTreeComponent = defineVxeComponent({
                             delete selectCheckboxMaps[nodeid];
                         }
                         if (halfSelect) {
-                            indeterminateRowMaps[nodeid] = node;
+                            indeterminateNodeMaps[nodeid] = node;
                         }
                         else {
-                            if (indeterminateRowMaps[nodeid]) {
-                                delete indeterminateRowMaps[nodeid];
+                            if (indeterminateNodeMaps[nodeid]) {
+                                delete indeterminateNodeMaps[nodeid];
                             }
                         }
                     }
@@ -40791,9 +40796,9 @@ var VxeTreeComponent = defineVxeComponent({
             const mapChildrenField = computeMapChildrenField.value;
             const funcName = isAppend ? 'push' : 'unshift';
             newRecords.forEach((item) => {
-                const parentRowId = item[parentField];
+                const parentNodeId = item[parentField];
                 const nodeid = getNodeId(item);
-                const matchObj = parentRowId ? XEUtils.findTree(treeFullData, (item) => parentRowId === item[keyField], { children: mapChildrenField }) : null;
+                const matchObj = parentNodeId ? XEUtils.findTree(treeFullData, (item) => parentNodeId === item[keyField], { children: mapChildrenField }) : null;
                 const itemRest = getItemCacheObj(item);
                 if (matchObj) {
                     const { item: parentItem } = matchObj;
@@ -40814,7 +40819,7 @@ var VxeTreeComponent = defineVxeComponent({
                     pMapChilds[funcName](item);
                 }
                 else {
-                    if (parentRowId) {
+                    if (parentNodeId) {
                         warnLog$2('vxe.error.unableInsert');
                     }
                     treeFullData[funcName](item);
@@ -40824,7 +40829,7 @@ var VxeTreeComponent = defineVxeComponent({
         };
         const handleInsertNodeAt = (records, targetNodeOrNodeid, isInsertNextNode) => {
             const { transform } = props;
-            const { treeFullData, nodeMaps } = internalData;
+            const { treeFullData, nodeMaps, removeNodeMaps, insertNodeMaps } = internalData;
             const keyField = computeKeyField.value;
             const parentField = computeParentField.value;
             const childrenField = computeChildrenField.value;
@@ -40862,26 +40867,26 @@ var VxeTreeComponent = defineVxeComponent({
                         const parentMapChilds = parentNode ? parentNode[mapChildrenField] : treeFullData;
                         const parentRest = nodeMaps[getNodeId(parentNode)];
                         const parentLevel = parentRest ? parentRest.level : 0;
-                        treeRecords.forEach((row, i) => {
+                        treeRecords.forEach((item, i) => {
                             if (parentNode) {
-                                if (row[parentField] !== parentNode[keyField]) {
-                                    errLog$2('vxe.error.errProp', [`${parentField}=${row[parentField]}`, `${parentField}=${parentNode[keyField]}`]);
-                                    row[parentField] = parentNode[keyField];
+                                if (item[parentField] !== parentNode[keyField]) {
+                                    errLog$2('vxe.error.errProp', [`${parentField}=${item[parentField]}`, `${parentField}=${parentNode[keyField]}`]);
+                                    item[parentField] = parentNode[keyField];
                                 }
                             }
                             else {
-                                if (row[parentField] !== null) {
-                                    if (!XEUtils.eqNull(row[parentField])) {
-                                        errLog$2('vxe.error.errProp', [`${parentField}=${row[parentField]}`, 'null']);
+                                if (item[parentField] !== null) {
+                                    if (!XEUtils.eqNull(item[parentField])) {
+                                        errLog$2('vxe.error.errProp', [`${parentField}=${item[parentField]}`, 'null']);
                                     }
-                                    row[parentField] = null;
+                                    item[parentField] = null;
                                 }
                             }
                             let targetIndex = matchMapObj.index + i;
                             if (isInsertNextNode) {
                                 targetIndex = targetIndex + 1;
                             }
-                            parentMapChilds.splice(targetIndex, 0, row);
+                            parentMapChilds.splice(targetIndex, 0, item);
                         });
                         XEUtils.eachTree(treeRecords, (item) => {
                             const nodeid = getNodeId(item);
@@ -40911,7 +40916,22 @@ var VxeTreeComponent = defineVxeComponent({
                     }
                 }
             }
-            reactData.insertRowFlag++;
+            const handleStatus = (newItem) => {
+                const nodeid = getNodeId(newItem);
+                // 如果是被删除的数据，则还原状态
+                if (removeNodeMaps[nodeid]) {
+                    delete removeNodeMaps[nodeid];
+                    if (insertNodeMaps[nodeid]) {
+                        delete insertNodeMaps[nodeid];
+                    }
+                }
+                else {
+                    insertNodeMaps[nodeid] = newItem;
+                }
+            };
+            XEUtils.eachTree(treeRecords, handleStatus, { children: mapChildrenField });
+            reactData.removeNodeFlag++;
+            reactData.insertNodeFlag++;
             cacheNodeMap();
             handleData(true);
             updateAfterDataIndex();
@@ -40926,6 +40946,27 @@ var VxeTreeComponent = defineVxeComponent({
                 };
             });
         };
+        const handleInsertChildNodeAt = (records, parentNodeOrParentId, targetNodeOrNodeid, isInsertNextNode) => {
+            const { transform } = props;
+            const { nodeMaps } = internalData;
+            const keyField = computeKeyField.value;
+            const parentField = computeParentField.value;
+            if (!transform) {
+                errLog$2('vxe.error.reqSupportProp', ['insertChild() | insertChildAt() | insertChildNextAt()', 'transform']);
+                return Promise.resolve({ node: null, nodes: [] });
+            }
+            if (!XEUtils.isArray(records)) {
+                records = [records];
+            }
+            let parentNode = parentNodeOrParentId;
+            if (XEUtils.isString(parentNodeOrParentId) || XEUtils.isNumber(parentNodeOrParentId)) {
+                const nodeRest = nodeMaps[parentNodeOrParentId];
+                if (nodeRest) {
+                    parentNode = nodeRest.item;
+                }
+            }
+            return handleInsertNodeAt(records.map((item) => Object.assign({}, item, { [parentField]: parentNode[keyField] })), targetNodeOrNodeid, isInsertNextNode);
+        };
         const treeMethods = {
             dispatchEvent,
             getNodeId,
@@ -41047,7 +41088,7 @@ var VxeTreeComponent = defineVxeComponent({
                 return list;
             },
             clearCheckboxNode() {
-                internalData.indeterminateRowMaps = {};
+                internalData.indeterminateNodeMaps = {};
                 internalData.selectCheckboxMaps = {};
                 reactData.updateCheckboxFlag++;
                 emitCheckboxMode([]);
@@ -41071,7 +41112,7 @@ var VxeTreeComponent = defineVxeComponent({
                         selectMaps[nodeid] = true;
                     }, { children: transform ? mapChildrenField : childrenField });
                 }
-                internalData.indeterminateRowMaps = {};
+                internalData.indeterminateNodeMaps = {};
                 internalData.selectCheckboxMaps = selectMaps;
                 reactData.updateCheckboxFlag++;
                 updateCheckboxStatus();
@@ -41251,10 +41292,10 @@ var VxeTreeComponent = defineVxeComponent({
                 const parentLevel = parentNodeItem ? parentNodeItem.level : 0;
                 const parentNodes = parentNodeItem ? parentNodeItem.nodes : [];
                 return createNode(childRecords).then((nodeList) => {
-                    XEUtils.eachTree(nodeList, (childRow, index, items, path, parent, nodes) => {
-                        const itemNodeId = getNodeId(childRow);
+                    XEUtils.eachTree(nodeList, (childNode, index, items, path, parent, nodes) => {
+                        const itemNodeId = getNodeId(childNode);
                         nodeMaps[itemNodeId] = {
-                            item: childRow,
+                            item: childNode,
                             index: -1,
                             $index: -1,
                             _index: -1,
@@ -41282,9 +41323,9 @@ var VxeTreeComponent = defineVxeComponent({
             isIndeterminateByCheckboxNode,
             isCheckedByCheckboxNode,
             getCheckboxIndeterminateNodes() {
-                const { nodeMaps, indeterminateRowMaps } = internalData;
+                const { nodeMaps, indeterminateNodeMaps } = internalData;
                 const list = [];
-                XEUtils.each(indeterminateRowMaps, (item, nodeid) => {
+                XEUtils.each(indeterminateNodeMaps, (item, nodeid) => {
                     const nodeItem = nodeMaps[nodeid];
                     if (nodeItem) {
                         list.push(nodeItem.item);
@@ -41339,9 +41380,30 @@ var VxeTreeComponent = defineVxeComponent({
             insertNextAt(records, targetNodeOrNodeid) {
                 return handleInsertNodeAt(records, targetNodeOrNodeid, true);
             },
+            insertChild(records, parentNodeOrParentId) {
+                return handleInsertChildNodeAt(records, parentNodeOrParentId, null);
+            },
+            insertChildAt(records, parentNodeOrParentId, targetNode) {
+                return handleInsertChildNodeAt(records, parentNodeOrParentId, targetNode);
+            },
+            insertChildNextAt(records, parentNodeOrParentId, targetNode) {
+                return handleInsertChildNodeAt(records, parentNodeOrParentId, targetNode, true);
+            },
+            getInsertRecords() {
+                const { insertNodeMaps } = internalData;
+                const insertRecords = [];
+                XEUtils.each(insertNodeMaps, (item) => {
+                    insertRecords.push(item);
+                });
+                return insertRecords;
+            },
+            isInsertByNode(node) {
+                const nodeid = getNodeId(node);
+                return !!reactData.insertNodeFlag && !!internalData.insertNodeMaps[nodeid];
+            },
             remove(nodes) {
                 const { transform } = props;
-                const { treeFullData } = internalData;
+                const { treeFullData, insertNodeMaps, removeNodeMaps } = internalData;
                 const childrenField = computeChildrenField.value;
                 const mapChildrenField = computeMapChildrenField.value;
                 if (!transform) {
@@ -41358,6 +41420,13 @@ var VxeTreeComponent = defineVxeComponent({
                 if (!nodes.length) {
                     return Promise.resolve({ node: null, nodes: [] });
                 }
+                // 如果是新增，则保存记录
+                nodes.forEach((item) => {
+                    if (!$xeTree.isInsertByNode(item)) {
+                        const nodeid = getNodeId(item);
+                        removeNodeMaps[nodeid] = item;
+                    }
+                });
                 // 从数据源中移除
                 if (treeFullData === nodes) {
                     nodes = delList = treeFullData.slice(0);
@@ -41378,8 +41447,15 @@ var VxeTreeComponent = defineVxeComponent({
                         }
                     });
                 }
-                reactData.removeRowFlag++;
-                reactData.insertRowFlag++;
+                // 从新增中移除已删除的数据
+                nodes.forEach((item) => {
+                    const nodeid = getNodeId(item);
+                    if (insertNodeMaps[nodeid]) {
+                        delete insertNodeMaps[nodeid];
+                    }
+                });
+                reactData.removeNodeFlag++;
+                reactData.insertNodeFlag++;
                 cacheNodeMap();
                 handleData(true);
                 updateAfterDataIndex();
@@ -41393,21 +41469,17 @@ var VxeTreeComponent = defineVxeComponent({
                     return { node: delList.length ? delList[delList.length - 1] : null, nodes: delList };
                 });
             },
-            getInsertRecords() {
-                const { insertRowMaps } = internalData;
-                const insertRecords = [];
-                XEUtils.each(insertRowMaps, (row) => {
-                    insertRecords.push(row);
-                });
-                return insertRecords;
-            },
             getRemoveRecords() {
-                const { removeRowMaps } = internalData;
+                const { removeNodeMaps } = internalData;
                 const removeRecords = [];
-                XEUtils.each(removeRowMaps, (row) => {
-                    removeRecords.push(row);
+                XEUtils.each(removeNodeMaps, (item) => {
+                    removeRecords.push(item);
                 });
                 return removeRecords;
+            },
+            isRemoveByNode(node) {
+                const nodeid = getNodeId(node);
+                return !!reactData.removeNodeFlag && !!internalData.removeNodeMaps[nodeid];
             }
         };
         const handleNodeDragEndClearStatus = () => {
@@ -41435,7 +41507,7 @@ var VxeTreeComponent = defineVxeComponent({
                 });
             }
         };
-        const updateRowDropTipContent = (itemEl) => {
+        const updateNodeDropTipContent = (itemEl) => {
             const { dragNode } = reactData;
             const dragOpts = computeDragOpts.value;
             const { tooltipMethod } = dragOpts;
@@ -41480,20 +41552,26 @@ var VxeTreeComponent = defineVxeComponent({
             evnt.stopPropagation();
             const { node } = params;
             const dragConfig = computeDragOpts.value;
-            const { trigger, dragStartMethod } = dragConfig;
+            const { isCrossTreeDrag, trigger, dragStartMethod } = dragConfig;
             const dragEl = evnt.currentTarget;
             const itemEl = trigger === 'node' ? dragEl : dragEl.parentElement.parentElement;
             clearNodeDropOrigin();
             if (dragStartMethod && !dragStartMethod(params)) {
                 itemEl.draggable = false;
                 reactData.dragNode = null;
+                clearCrossTreeDragStatus();
                 hideDropTip();
                 return;
             }
+            if (isCrossTreeDrag) {
+                crossTreeDragNodeInfo.node = node;
+                crossTreeDragNodeObj = { $oldTree: $xeTree, $newTree: null };
+            }
             reactData.dragNode = node;
+            reactData.isCrossDragNode = false;
             itemEl.draggable = true;
             updateNodeDropOrigin(node);
-            updateRowDropTipContent(itemEl);
+            updateNodeDropTipContent(itemEl);
             dispatchEvent('node-dragstart', params, evnt);
         };
         const handleNodeDragMouseupEvent = () => {
@@ -41561,6 +41639,7 @@ var VxeTreeComponent = defineVxeComponent({
                 status: false
             };
             if (!(el && prevDragNode && dragNode)) {
+                handleNodeDragEndClearStatus();
                 return Promise.resolve(errRest);
             }
             // 判断是否有拖动
@@ -41608,15 +41687,13 @@ var VxeTreeComponent = defineVxeComponent({
                             if (isPeerDrag && !isCrossDrag) {
                                 if (oldRest.item[parentField] !== newRest.item[parentField]) {
                                     // 非同级
-                                    clearNodeDragData();
-                                    clearCrossTreeDragStatus();
+                                    handleNodeDragEndClearStatus();
                                     return errRest;
                                 }
                             }
                             else {
                                 if (!isCrossDrag) {
-                                    clearNodeDragData();
-                                    clearCrossTreeDragStatus();
+                                    handleNodeDragEndClearStatus();
                                     return errRest;
                                 }
                                 if (oldAllMaps[newNodeid]) {
@@ -41628,8 +41705,7 @@ var VxeTreeComponent = defineVxeComponent({
                                                 content: getI18n('vxe.error.treeDragChild')
                                             });
                                         }
-                                        clearNodeDragData();
-                                        clearCrossTreeDragStatus();
+                                        handleNodeDragEndClearStatus();
                                         return errRest;
                                     }
                                 }
@@ -41638,16 +41714,14 @@ var VxeTreeComponent = defineVxeComponent({
                         else if (oldLevel) {
                             // 子到根
                             if (!isCrossDrag) {
-                                clearNodeDragData();
-                                clearCrossTreeDragStatus();
+                                handleNodeDragEndClearStatus();
                                 return errRest;
                             }
                         }
                         else if (newLevel) {
                             // 根到子
                             if (!isCrossDrag) {
-                                clearNodeDragData();
-                                clearCrossTreeDragStatus();
+                                handleNodeDragEndClearStatus();
                                 return errRest;
                             }
                             if (oldAllMaps[newNodeid]) {
@@ -41659,8 +41733,7 @@ var VxeTreeComponent = defineVxeComponent({
                                             content: getI18n('vxe.error.treeDragChild')
                                         });
                                     }
-                                    clearNodeDragData();
-                                    clearCrossTreeDragStatus();
+                                    handleNodeDragEndClearStatus();
                                     return errRest;
                                 }
                             }
@@ -41808,13 +41881,11 @@ var VxeTreeComponent = defineVxeComponent({
                 }).catch(() => {
                     return errRest;
                 }).then((rest) => {
-                    clearNodeDragData();
-                    clearCrossTreeDragStatus();
+                    handleNodeDragEndClearStatus();
                     return rest;
                 });
             }
-            clearNodeDragData();
-            clearCrossTreeDragStatus();
+            handleNodeDragEndClearStatus();
             return Promise.resolve(errRest);
         };
         const handleNodeDragDragstartEvent = (evnt) => {
@@ -41863,7 +41934,7 @@ var VxeTreeComponent = defineVxeComponent({
             const dragConfig = computeDragOpts.value;
             const parentField = computeParentField.value;
             const hasChildField = computeHasChildField.value;
-            const { isCrossDrag, isPeerDrag, isToChildDrag } = dragConfig;
+            const { isCrossTreeDrag, isCrossDrag, isPeerDrag, isToChildDrag } = dragConfig;
             if (!dragNode && !isCrossDrag) {
                 evnt.preventDefault();
             }
@@ -41879,6 +41950,32 @@ var VxeTreeComponent = defineVxeComponent({
                 internalData.prevDragToChild = !!(transform && (isCrossDrag && isToChildDrag) && isControlKey);
                 internalData.prevDragNode = node;
                 internalData.prevDragPos = dragPos;
+                // 跨树拖拽
+                if (isCrossTreeDrag && isCrossDrag && crossTreeDragNodeObj) {
+                    const { $oldTree, $newTree } = crossTreeDragNodeObj;
+                    if ($oldTree) {
+                        const oldTreeReactData = $oldTree.reactData;
+                        if ($oldTree.xID === $xeTree.xID) {
+                            if ($newTree) {
+                                $newTree.hideCrossTreeNodeDropClearStatus();
+                            }
+                            reactData.isCrossDragNode = false;
+                            oldTreeReactData.isCrossDragNode = false;
+                            crossTreeDragNodeObj.$newTree = null;
+                        }
+                        else if (isCrossDrag) {
+                            if ($newTree && $newTree.xID !== $xeTree.xID) {
+                                $newTree.hideCrossTreeNodeDropClearStatus();
+                            }
+                            $oldTree.hideCrossTreeNodeDropClearStatus();
+                            oldTreeReactData.isCrossDragNode = true;
+                            reactData.dragTipText = oldTreeReactData.dragTipText;
+                            crossTreeDragNodeObj.$newTree = $xeTree;
+                            showDropTip(evnt, itemEl, true, dragPos);
+                            return;
+                        }
+                    }
+                }
                 if ((dragNode && getNodeId(dragNode) === nodeid) ||
                     (isControlKey && lazy && node[hasChildField] && nodeItem && !nodeItem.treeLoaded) ||
                     (!isCrossDrag && transform && (isPeerDrag ? dragNode[parentField] !== node[parentField] : nodeItem.level))) {
@@ -42052,9 +42149,9 @@ var VxeTreeComponent = defineVxeComponent({
                             else {
                                 dragNode[parentField] = null;
                             }
-                            dragList.forEach(row => {
-                                row[childrenField] = undefined;
-                                row[mapChildrenField] = undefined;
+                            dragList.forEach(item => {
+                                item[childrenField] = undefined;
+                                item[mapChildrenField] = undefined;
                             });
                             if (prevDragNode) {
                                 if (prevDragPos === 'bottom') {
@@ -42403,7 +42500,7 @@ var VxeTreeComponent = defineVxeComponent({
             const radioOpts = computeRadioOpts.value;
             const checkboxOpts = computeCheckboxOpts.value;
             const loadingOpts = computeLoadingOpts.value;
-            const isRowHover = computeIsRowHover.value;
+            const isNodeHover = computeIsNodeHover.value;
             const treeStyle = computeTreeStyle.value;
             const dragOpts = computeDragOpts.value;
             const loadingSlot = slots.loading;
@@ -42411,14 +42508,14 @@ var VxeTreeComponent = defineVxeComponent({
             const footerSlot = slots.footer;
             const teOns = {};
             if (dragOpts.isCrossTreeDrag && !treeList.length) {
-                teOns.onDragover = $xeTree.handleCrossTreeNodeDragInsertEvent;
+                teOns.onDragover = $xeTree.handleCrossTreeNodeDragoverEmptyEvent;
             }
             return h('div', Object.assign({ ref: refElem, class: ['vxe-tree', {
                         [`size--${vSize}`]: vSize,
                         'show--line': showLine,
                         'checkbox--highlight': checkboxOpts.highlight,
                         'radio--highlight': radioOpts.highlight,
-                        'node--hover': isRowHover,
+                        'node--hover': isNodeHover,
                         'node--trigger': trigger === 'node',
                         'is--loading': loading
                     }] }, teOns), [