vxe-table 3.18.0 → 3.18.1

package/lib/index.umd.js

@@ -2002,7 +2002,7 @@ function getClass(property, params) {
 ;// CONCATENATED MODULE: ./packages/ui/index.ts
 
 
-const version = "3.18.0";
+const version = "3.18.1";
 core_.VxeUI.version = version;
 core_.VxeUI.tableVersion = version;
 core_.VxeUI.setConfig({
@@ -2678,7 +2678,7 @@ function isNodeElement(elem) {
 const {
   log: log_log
 } = core_.VxeUI;
-const log_version = `table v${"3.18.0"}`;
+const log_version = `table v${"3.18.1"}`;
 const warnLog = log_log.create('warn', log_version);
 const errLog = log_log.create('error', log_version);
 ;// CONCATENATED MODULE: ./packages/table/src/columnInfo.ts
@@ -5730,6 +5730,15 @@ function clearColAnimate(elem, clss) {
     }
   }, 500);
 }
+;// CONCATENATED MODULE: ./packages/table/src/store.ts
+// 跨表拖拽
+const crossTableDragRowGlobal = {
+  row: null
+};
+function getCrossTableDragRowInfo($xeTable) {
+  const crossTableDragRowInfo = $xeTable.crossTableDragRowInfo;
+  return crossTableDragRowInfo;
+}
 ;// CONCATENATED MODULE: ./packages/table/src/methods.ts
 
 
@@ -5741,6 +5750,7 @@ function clearColAnimate(elem, clss) {
 
 
 
+
 const {
   getConfig: methods_getConfig,
   getI18n: methods_getI18n,
@@ -5754,6 +5764,7 @@ const supportMaxRow = 5e6;
 const customStorageKey = 'VXE_CUSTOM_STORE';
 const maxYHeight = 5e6;
 const maxXWidth = 5e6;
+let crossTableDragRowObj = null;
 function eqCellValue(row1, row2, field) {
   const val1 = external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().get(row1, field);
   const val2 = external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().get(row2, field);
@@ -7001,20 +7012,25 @@ function updateStyle($xeTable) {
     emptyPlaceholderElem.style.top = `${tHeaderHeight}px`;
     emptyPlaceholderElem.style.height = bodyWrapperElem ? `${bodyWrapperElem.offsetHeight - osbHeight}px` : '';
   }
+  const scrollbarXConf = scrollbarOpts.x || {};
   const scrollbarXToTop = $xeTable.computeScrollbarXToTop;
+  const scrollbarYConf = scrollbarOpts.y || {};
   const scrollbarYToLeft = $xeTable.computeScrollbarYToLeft;
   let xScrollbarVisible = overflowX ? 'visible' : 'hidden';
-  if ($xeGanttView) {
+  if (scrollbarXConf.visible === 'visible' || $xeGanttView) {
     osbHeight = scrollbarHeight;
     xScrollbarVisible = 'visible';
-  } else if (scrollbarOpts.x && scrollbarOpts.x.visible === false) {
+  } else if (scrollbarXConf.visible === 'hidden' || scrollbarXConf.visible === false) {
     osbHeight = 0;
     xScrollbarVisible = 'hidden';
   }
   let yScrollbarVisible = overflowY ? 'visible' : 'hidden';
-  if (scrollbarOpts.y && scrollbarOpts.y.visible === false || $xeGanttView && !scrollbarYToLeft) {
+  if (scrollbarYConf.visible === 'hidden' || scrollbarYConf.visible === false || $xeGanttView && !scrollbarYToLeft) {
     osbWidth = 0;
     yScrollbarVisible = 'hidden';
+  } else if (scrollbarYConf.visible === 'visible') {
+    osbWidth = scrollbarWidth;
+    yScrollbarVisible = 'visible';
   }
   let tbHeight = 0;
   let bodyMaxHeight = 0;
@@ -8587,6 +8603,11 @@ function handleTargetEnterEvent($xeTable, isClear) {
     }
   }
 }
+function clearCrossTableDragStatus($xeTable) {
+  const crossTableDragRowInfo = getCrossTableDragRowInfo($xeTable);
+  crossTableDragRowObj = null;
+  crossTableDragRowInfo.row = null;
+}
 function clearDragStatus($xeTable) {
   const reactData = $xeTable;
   const {
@@ -8597,6 +8618,7 @@ function clearDragStatus($xeTable) {
     clearColDropOrigin($xeTable);
     clearRowDropOrigin($xeTable);
     hideDropTip($xeTable);
+    clearCrossTableDragStatus($xeTable);
     reactData.dragRow = null;
     reactData.dragCol = null;
   }
@@ -8801,6 +8823,26 @@ function hideDropTip($xeTable) {
     cdLineEl.style.display = '';
   }
 }
+function clearRowDragData($xeTable) {
+  const $xeGantt = $xeTable.$xeGantt;
+  const reactData = $xeTable;
+  const internalData = $xeTable;
+  let wrapperEl = $xeTable.$refs.refElem;
+  const dtClss = ['.vxe-body--row'];
+  if ($xeGantt) {
+    const ganttContainerElem = $xeGantt.$refs.refGanttContainerElem;
+    if (ganttContainerElem) {
+      wrapperEl = ganttContainerElem;
+    }
+    dtClss.push('.vxe-gantt-view--body-row', '.vxe-gantt-view--chart-row');
+  }
+  hideDropTip($xeTable);
+  clearRowDropOrigin($xeTable);
+  clearRowAnimate(wrapperEl, dtClss);
+  internalData.prevDragToChild = false;
+  reactData.dragRow = null;
+  reactData.dragCol = null;
+}
 /**
  * 处理显示 tooltip
  * @param {Event} evnt 事件
@@ -11362,7 +11404,9 @@ const Methods = {
         }
       }
     }
-    return $xeTable.handleRowDragSwapEvent(null, true, dragRow, prevDragRow, dragPos || defPos, dragToChild === true);
+    const rest = $xeTable.handleRowDragSwapEvent(null, true, dragRow, prevDragRow, dragPos || defPos, dragToChild === true);
+    clearRowDragData($xeTable);
+    return rest;
   },
   /**
    * 获取表格的全量列
@@ -12946,7 +12990,7 @@ const Methods = {
                 // 如果点击了当前表格之外
                 !getEventTargetNode(evnt, $el).flag) {
                   setTimeout(() => {
-                    this.handleClearEdit(evnt).then(() => {
+                    $xeTable.handleClearEdit(evnt).then(() => {
                       // 如果存在校验，点击了表格之外则清除
                       if (!this.isActivated && editRules && validOpts.autoClear) {
                         this.validErrorMaps = {};
@@ -12961,17 +13005,17 @@ const Methods = {
       }
     } else if (mouseConfig) {
       if (!getEventTargetNode(evnt, $el).flag && !($xeGGWrapper && getEventTargetNode(evnt, $xeGGWrapper.$el).flag) && !(tableMenu && getEventTargetNode(evnt, tableMenu.$el).flag) && !($toolbar && getEventTargetNode(evnt, $toolbar.$el).flag)) {
-        if (this.clearSelected) {
-          this.clearSelected();
+        if ($xeTable.clearSelected) {
+          $xeTable.clearSelected();
         }
         if (areaOpts.autoClear) {
-          if (this.getCellAreas) {
-            const cellAreas = this.getCellAreas();
+          if ($xeTable.getCellAreas) {
+            const cellAreas = $xeTable.getCellAreas();
             if (cellAreas && cellAreas.length && !getEventTargetNode(evnt, document.body, 'vxe-table--ignore-areas-clear').flag) {
-              this.preventEvent(evnt, 'event.clearAreas', {}, () => {
-                this.clearCellAreas();
-                this.clearCopyCellArea();
-                this.emitEvent('clear-cell-area-selection', {
+              $xeTable.preventEvent(evnt, 'event.clearAreas', {}, () => {
+                $xeTable.clearCellAreas();
+                $xeTable.clearCopyCellArea();
+                $xeTable.dispatchEvent('clear-cell-area-selection', {
                   cellAreas
                 }, evnt);
               });
@@ -13010,6 +13054,7 @@ const Methods = {
    * 表格键盘事件
    */
   keydownEvent(evnt) {
+    const $xeTable = this;
     const {
       filterStore,
       ctxMenuStore,
@@ -13028,7 +13073,7 @@ const Methods = {
     const isEsc = keyCode === 27;
     if (isEsc) {
       this.preventEvent(evnt, 'event.keydown', null, () => {
-        this.emitEvent('keydown-start', {}, evnt);
+        $xeTable.dispatchEvent('keydown-start', {}, evnt);
         if (keyboardConfig && mouseConfig && mouseOpts.area && this.handleKeyboardCellAreaEvent) {
           this.handleKeyboardCellAreaEvent(evnt);
         } else if (actived.row || filterStore.visible || ctxMenuStore.visible) {
@@ -13048,8 +13093,8 @@ const Methods = {
             }
           }
         }
-        this.emitEvent('keydown', {}, evnt);
-        this.emitEvent('keydown-end', {}, evnt);
+        $xeTable.dispatchEvent('keydown', {}, evnt);
+        $xeTable.dispatchEvent('keydown-end', {}, evnt);
       });
     }
   },
@@ -13390,6 +13435,7 @@ const Methods = {
     }
   },
   handleGlobalPasteEvent(evnt) {
+    const $xeTable = this;
     const {
       isActivated,
       keyboardConfig,
@@ -13408,10 +13454,11 @@ const Methods = {
           this.handlePasteCellAreaEvent(evnt);
         }
       }
-      this.emitEvent('paste', {}, evnt);
+      $xeTable.dispatchEvent('paste', {}, evnt);
     }
   },
   handleGlobalCopyEvent(evnt) {
+    const $xeTable = this;
     const {
       isActivated,
       keyboardConfig,
@@ -13430,10 +13477,11 @@ const Methods = {
           this.handleCopyCellAreaEvent(evnt);
         }
       }
-      this.emitEvent('copy', {}, evnt);
+      $xeTable.dispatchEvent('copy', {}, evnt);
     }
   },
   handleGlobalCutEvent(evnt) {
+    const $xeTable = this;
     const {
       isActivated,
       keyboardConfig,
@@ -13452,7 +13500,7 @@ const Methods = {
           this.handleCutCellAreaEvent(evnt);
         }
       }
-      this.emitEvent('cut', {}, evnt);
+      $xeTable.dispatchEvent('cut', {}, evnt);
     }
   },
   handleGlobalResizeEvent() {
@@ -14858,7 +14906,8 @@ const Methods = {
     return $xeTable.$nextTick();
   },
   triggerHeaderCellDblclickEvent(evnt, params) {
-    this.emitEvent('header-cell-dblclick', Object.assign({
+    const $xeTable = this;
+    $xeTable.dispatchEvent('header-cell-dblclick', Object.assign({
       cell: evnt.currentTarget
     }, params), evnt);
   },
@@ -15076,7 +15125,7 @@ const Methods = {
         }
       }
     }
-    this.emitEvent('cell-dblclick', params, evnt);
+    $xeTable.dispatchEvent('cell-dblclick', params, evnt);
   },
   handleColumnSortEvent(evnt, column) {
     const $xeTable = this;
@@ -15575,12 +15624,273 @@ const Methods = {
     }
     return Promise.resolve(errRest);
   },
-  handleRowDragDragendEvent(evnt) {
+  /**
+   * 处理跨表拖拽完成
+   */
+  handleCrossTableRowDragFinishEvent(evnt) {
+    const $xeTable = this;
+    const $xeGantt = $xeTable.$xeGantt;
+    const reactData = $xeTable;
+    const internalData = $xeTable;
+    const crossTableDragRowInfo = getCrossTableDragRowInfo($xeTable);
+    const {
+      tableData
+    } = reactData;
+    const {
+      fullAllDataRowIdData
+    } = internalData;
+    const rowOpts = $xeTable.computeRowOpts;
+    const cellOpts = $xeTable.computeCellOpts;
+    const defaultRowHeight = $xeTable.computeDefaultRowHeight;
+    const rowDragOpts = $xeTable.computeRowDragOpts;
+    const {
+      animation,
+      isCrossTableDrag
+    } = rowDragOpts;
+    const treeOpts = $xeTable.computeTreeOpts;
+    const {
+      mapChildrenField
+    } = treeOpts;
+    const el = $xeTable.$refs.refElem;
+    if (isCrossTableDrag && crossTableDragRowObj && crossTableDragRowInfo) {
+      const {
+        row: dragRow
+      } = crossTableDragRowInfo;
+      if (dragRow) {
+        const dragRowid = getRowid($xeTable, dragRow);
+        const dragRowRest = fullAllDataRowIdData[dragRowid];
+        let dragRowHeight = 0;
+        let rsIndex = -1;
+        if (dragRowRest) {
+          if (animation) {
+            dragRowHeight = getCellRestHeight(dragRowRest, cellOpts, rowOpts, defaultRowHeight);
+          }
+          rsIndex = dragRowRest.$index;
+        }
+        const dragRangeList = rsIndex > -1 && rsIndex < tableData.length - 1 ? tableData.slice(rsIndex + 1) : [];
+        const dragList = external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().toTreeArray([dragRow], {
+          updated: true,
+          children: mapChildrenField
+        });
+        $xeTable.remove(dragList).then(() => {
+          if (animation && dragRowHeight && dragRangeList.length) {
+            const $xeGanttView = internalData.xeGanttView;
+            let wrapperEl = el;
+            if ($xeGantt && $xeGanttView) {
+              const ganttContainerElem = $xeGantt.$refs.refGanttContainerElem;
+              if (ganttContainerElem) {
+                wrapperEl = ganttContainerElem;
+              }
+            }
+            const dtClss = [];
+            dragRangeList.forEach(row => {
+              const rowid = getRowid($xeTable, row);
+              dtClss.push(`.vxe-body--row[rowid="${rowid}"]`);
+              if ($xeGantt) {
+                dtClss.push(`.vxe-gantt-view--body-row[rowid="${rowid}"]`, `.vxe-gantt-view--chart-row[rowid="${rowid}"]`);
+              }
+            });
+            const dtTrList = wrapperEl.querySelectorAll(dtClss.join(','));
+            moveRowAnimateToTb(dtTrList, dragRowHeight);
+          }
+        });
+        $xeTable.dispatchEvent('row-remove-dragend', {
+          row: dragRow
+        }, evnt);
+        clearRowDragData($xeTable);
+        clearCrossTableDragStatus($xeTable);
+      }
+    }
+  },
+  /**
+   * 处理跨表拖至新的空表
+   */
+  handleCrossTableRowDragoverEmptyEvent(evnt) {
+    const $xeTable = this;
+    const reactData = $xeTable;
+    const internalData = $xeTable;
+    const {
+      tableData
+    } = reactData;
+    const rowDragOpts = $xeTable.computeRowDragOpts;
+    const {
+      isCrossTableDrag
+    } = rowDragOpts;
+    if (isCrossTableDrag && crossTableDragRowObj && !tableData.length) {
+      const {
+        $oldTable
+      } = crossTableDragRowObj;
+      if ($oldTable && $oldTable.xID !== $xeTable.xID) {
+        evnt.preventDefault();
+        crossTableDragRowObj.$newTable = $xeTable;
+        internalData.prevDragRow = null;
+      }
+    }
+  },
+  /**
+   * 处理跨表拖插入
+   */
+  handleCrossTableRowDragInsertEvent(evnt) {
     const $xeTable = this;
     const $xeGantt = $xeTable.$xeGantt;
     const props = $xeTable;
     const reactData = $xeTable;
     const internalData = $xeTable;
+    const crossTableDragRowInfo = getCrossTableDragRowInfo($xeTable);
+    const {
+      treeConfig
+    } = props;
+    const {
+      prevDragRow,
+      prevDragPos,
+      prevDragToChild
+    } = internalData;
+    const rowDragOpts = $xeTable.computeRowDragOpts;
+    const {
+      animation,
+      isSelfToChildDrag,
+      isCrossTableDrag,
+      dragEndMethod,
+      dragToChildMethod
+    } = rowDragOpts;
+    const rowOpts = $xeTable.computeRowOpts;
+    const cellOpts = $xeTable.computeCellOpts;
+    const defaultRowHeight = $xeTable.computeDefaultRowHeight;
+    const treeOpts = $xeTable.computeTreeOpts;
+    const {
+      parentField,
+      mapChildrenField
+    } = treeOpts;
+    const childrenField = treeOpts.children || treeOpts.childrenField;
+    // 跨表拖拽
+    if (isCrossTableDrag && crossTableDragRowObj && crossTableDragRowInfo) {
+      const {
+        row: oldRow
+      } = crossTableDragRowInfo;
+      const {
+        $oldTable
+      } = crossTableDragRowObj;
+      const el = $xeTable.$refs.refElem;
+      if ($oldTable && oldRow) {
+        const dragRow = oldRow;
+        let dragOffsetIndex = -1;
+        if (prevDragRow) {
+          dragOffsetIndex = prevDragPos === 'bottom' ? 1 : 0;
+        }
+        const dragParams = {
+          oldRow: dragRow,
+          newRow: prevDragRow,
+          dragRow,
+          dragPos: prevDragPos,
+          dragToChild: !!prevDragToChild,
+          offsetIndex: dragOffsetIndex
+        };
+        const isDragToChildFlag = isSelfToChildDrag && dragToChildMethod ? dragToChildMethod(dragParams) : prevDragToChild;
+        const errRest = {
+          status: false
+        };
+        Promise.resolve(dragEndMethod ? dragEndMethod(dragParams) : true).then(status => {
+          if (!status) {
+            return errRest;
+          }
+          let insertRest = Promise.resolve();
+          if (treeConfig) {
+            const dragList = external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().toTreeArray([dragRow], {
+              updated: true,
+              children: mapChildrenField
+            });
+            $oldTable.handleCrossTableRowDragFinishEvent(evnt);
+            if (prevDragRow) {
+              dragRow[parentField] = prevDragRow[parentField];
+            } else {
+              dragRow[parentField] = null;
+            }
+            dragList.forEach(row => {
+              row[childrenField] = undefined;
+              row[mapChildrenField] = undefined;
+            });
+            if (prevDragRow) {
+              if (prevDragPos === 'bottom') {
+                insertRest = $xeTable.insertNextAt(dragList, prevDragRow);
+              } else {
+                insertRest = $xeTable.insertAt(dragList, prevDragRow);
+              }
+            } else {
+              insertRest = $xeTable.insert(dragList);
+            }
+          } else {
+            $oldTable.handleCrossTableRowDragFinishEvent(evnt);
+            if (prevDragRow) {
+              if (prevDragPos === 'bottom') {
+                insertRest = $xeTable.insertNextAt(dragRow, prevDragRow);
+              } else {
+                insertRest = $xeTable.insertAt(dragRow, prevDragRow);
+              }
+            } else {
+              insertRest = $xeTable.insert(dragRow);
+            }
+          }
+          $xeTable.dispatchEvent('row-insert-dragend', {
+            oldRow,
+            newRow: prevDragRow,
+            dragRow,
+            dragPos: prevDragPos,
+            dragToChild: isDragToChildFlag,
+            offsetIndex: dragOffsetIndex
+          }, evnt);
+          clearRowDragData($xeTable);
+          insertRest.then(() => {
+            const {
+              tableData
+            } = reactData;
+            const {
+              fullAllDataRowIdData
+            } = internalData;
+            const oldRowid = getRowid($xeTable, dragRow);
+            const oldRowRest = fullAllDataRowIdData[oldRowid];
+            let dragRowHeight = 0;
+            let rsIndex = -1;
+            if (oldRowRest) {
+              if (animation) {
+                dragRowHeight = getCellRestHeight(oldRowRest, cellOpts, rowOpts, defaultRowHeight);
+              }
+              rsIndex = oldRowRest.$index;
+            }
+            const dragRangeList = rsIndex > -1 ? tableData.slice(rsIndex) : [];
+            if (animation && dragRowHeight && dragRangeList.length) {
+              const $xeGanttView = internalData.xeGanttView;
+              let wrapperEl = el;
+              if ($xeGantt && $xeGanttView) {
+                const ganttContainerElem = $xeGantt.$refs.refGanttContainerElem;
+                if (ganttContainerElem) {
+                  wrapperEl = ganttContainerElem;
+                }
+              }
+              const dtClss = [];
+              dragRangeList.forEach(row => {
+                const rowid = getRowid($xeTable, row);
+                dtClss.push(`.vxe-body--row[rowid="${rowid}"]`);
+                if ($xeGantt) {
+                  dtClss.push(`.vxe-gantt-view--body-row[rowid="${rowid}"]`, `.vxe-gantt-view--chart-row[rowid="${rowid}"]`);
+                }
+              });
+              const dtTrList = wrapperEl.querySelectorAll(dtClss.join(','));
+              moveRowAnimateToTb(dtTrList, -dragRowHeight);
+            }
+          });
+        });
+      }
+    }
+  },
+  hideCrossTableRowDropClearStatus() {
+    const $xeTable = this;
+    hideDropTip($xeTable);
+  },
+  handleRowDragDragendEvent(evnt) {
+    const $xeTable = this;
+    const props = $xeTable;
+    const reactData = $xeTable;
+    const internalData = $xeTable;
     const {
       treeConfig
     } = props;
@@ -15600,7 +15910,23 @@ const Methods = {
       prevDragRow,
       prevDragPos
     } = internalData;
-    let wrapperEl = $xeTable.$refs.refElem;
+    const rowDragOpts = $xeTable.computeRowDragOpts;
+    const {
+      isCrossTableDrag,
+      isCrossDrag
+    } = rowDragOpts;
+    // 跨表拖拽
+    if (isCrossTableDrag && crossTableDragRowObj) {
+      const {
+        $newTable
+      } = crossTableDragRowObj;
+      if ($newTable && $newTable.xID !== $xeTable.xID) {
+        if (!treeConfig || isCrossDrag) {
+          $newTable.handleCrossTableRowDragInsertEvent(evnt);
+        }
+        return;
+      }
+    }
     if (treeConfig && lazy && prevDragToChild) {
       // 懒加载
       const newRowid = getRowid($xeTable, prevDragRow);
@@ -15615,20 +15941,8 @@ const Methods = {
     } else {
       $xeTable.handleRowDragSwapEvent(evnt, true, dragRow, prevDragRow, prevDragPos, prevDragToChild);
     }
-    const dtClss = ['.vxe-body--row'];
-    if ($xeGantt) {
-      const ganttContainerElem = $xeGantt.$refs.refGanttContainerElem;
-      if (ganttContainerElem) {
-        wrapperEl = ganttContainerElem;
-      }
-      dtClss.push('.vxe-gantt-view--body-row', '.vxe-gantt-view--chart-row');
-    }
-    hideDropTip($xeTable);
-    clearRowDropOrigin($xeTable);
-    clearRowAnimate(wrapperEl, dtClss);
-    internalData.prevDragToChild = false;
-    reactData.dragRow = null;
-    reactData.dragCol = null;
+    clearRowDragData($xeTable);
+    clearCrossTableDragStatus($xeTable);
   },
   handleRowDragDragoverEvent(evnt) {
     const $xeTable = this;
@@ -15655,9 +15969,10 @@ const Methods = {
     const {
       isPeerDrag,
       isCrossDrag,
-      isToChildDrag
+      isToChildDrag,
+      isCrossTableDrag
     } = rowDragOpts;
-    if (!dragRow) {
+    if (!dragRow && !(isCrossTableDrag && (!treeConfig || isCrossDrag) && crossTableDragRowObj)) {
       evnt.preventDefault();
       return;
     }
@@ -15666,18 +15981,40 @@ const Methods = {
     const rowid = trEl.getAttribute('rowid') || '';
     const rest = fullAllDataRowIdData[rowid];
     if (rest) {
+      evnt.preventDefault();
       const row = rest.row;
       const rowid = getRowid($xeTable, row);
       const rowRest = fullAllDataRowIdData[rowid];
-      evnt.preventDefault();
-      const {
-        dragRow
-      } = reactData;
       const offsetY = evnt.clientY - trEl.getBoundingClientRect().y;
       const dragPos = offsetY < trEl.clientHeight / 2 ? 'top' : 'bottom';
-      internalData.prevDragToChild = !!(treeConfig && transform && isToChildDrag && isControlKey);
+      internalData.prevDragToChild = !!(treeConfig && transform && isCrossDrag && isToChildDrag && isControlKey);
       internalData.prevDragRow = row;
       internalData.prevDragPos = dragPos;
+      // 跨表拖拽
+      if (isCrossTableDrag && (!treeConfig || isCrossDrag) && crossTableDragRowObj) {
+        const {
+          $oldTable,
+          $newTable
+        } = crossTableDragRowObj;
+        if ($oldTable) {
+          const oldTableReactData = $oldTable;
+          if ($oldTable.xID === $xeTable.xID) {
+            if ($newTable) {
+              $newTable.hideCrossTableRowDropClearStatus();
+            }
+            reactData.isCrossDragRow = false;
+            oldTableReactData.isCrossDragRow = false;
+            crossTableDragRowObj.$newTable = null;
+          } else if (!treeConfig || isCrossDrag) {
+            $oldTable.hideCrossTableRowDropClearStatus();
+            oldTableReactData.isCrossDragRow = true;
+            reactData.dragTipText = oldTableReactData.dragTipText;
+            crossTableDragRowObj.$newTable = $xeTable;
+            showDropTip($xeTable, evnt, trEl, null, true, dragPos);
+            return;
+          }
+        }
+      }
       if ($xeTable.eqRow(dragRow, row) || isControlKey && treeConfig && lazy && row[hasChildField] && rowRest && !rowRest.treeLoaded || !isCrossDrag && treeConfig && transform && (isPeerDrag ? dragRow[parentField] !== row[parentField] : rest.level)) {
         showDropTip($xeTable, evnt, trEl, null, false, dragPos);
         return;
@@ -15694,12 +16031,14 @@ const Methods = {
     const $xeTable = this;
     const props = $xeTable;
     const reactData = $xeTable;
+    const crossTableDragRowInfo = getCrossTableDragRowInfo($xeTable);
     evnt.stopPropagation();
     const {
       dragConfig
     } = props;
     const rowDragOpts = $xeTable.computeRowDragOpts;
     const {
+      isCrossTableDrag,
       trigger,
       dragStartMethod
     } = rowDragOpts;
@@ -15715,10 +16054,19 @@ const Methods = {
       trEl.draggable = false;
       reactData.dragRow = null;
       reactData.dragCol = null;
+      clearCrossTableDragStatus($xeTable);
       hideDropTip($xeTable);
       return;
     }
+    if (isCrossTableDrag) {
+      crossTableDragRowInfo.row = row;
+      crossTableDragRowObj = {
+        $oldTable: $xeTable,
+        $newTable: null
+      };
+    }
     reactData.dragRow = row;
+    reactData.isCrossDragRow = false;
     reactData.dragCol = null;
     trEl.draggable = true;
     updateRowDropOrigin($xeTable, row);
@@ -16064,6 +16412,7 @@ const Methods = {
     internalData.prevDragToChild = false;
     reactData.dragRow = null;
     reactData.dragCol = null;
+    clearCrossTableDragStatus($xeTable);
   },
   handleHeaderCellDragDragoverEvent(evnt) {
     const $xeTable = this;
@@ -16157,11 +16506,13 @@ const Methods = {
       reactData.dragRow = null;
       reactData.dragCol = null;
       hideDropTip($xeTable);
+      clearCrossTableDragStatus($xeTable);
       return;
     }
     reactData.dragCol = column;
     reactData.dragRow = null;
     thEl.draggable = true;
+    clearCrossTableDragStatus($xeTable);
     updateColDropOrigin($xeTable, column);
     updateColDropTipContent($xeTable, thEl);
     $xeTable.dispatchEvent('column-dragstart', params, evnt);
@@ -16171,6 +16522,7 @@ const Methods = {
     const reactData = $xeTable;
     clearColDropOrigin($xeTable);
     hideDropTip($xeTable);
+    clearCrossTableDragStatus($xeTable);
     reactData.dragRow = null;
     reactData.dragCol = null;
   },
@@ -18575,14 +18927,7 @@ const Methods = {
   // 已废弃，使用 dispatchEvent
   emitEvent(type, params, evnt) {
     const $xeTable = this;
-    const $xeGrid = $xeTable.$xeGrid;
-    const $xeGantt = $xeTable.$xeGantt;
-    $xeTable.$emit(type, createEvent(evnt, {
-      $table: $xeTable,
-      $grid: $xeGrid,
-      $gantt: $xeGantt,
-      $event: evnt
-    }));
+    $xeTable.dispatchEvent(type, params, evnt);
   },
   focus() {
     this.isActivated = true;
@@ -23041,6 +23386,7 @@ const {
      * @param column
      */
     _openFilter(fieldOrColumn) {
+      const $xeTable = this;
       const column = handleFieldOrColumn(this, fieldOrColumn);
       if (column && column.filters) {
         const {
@@ -23049,7 +23395,7 @@ const {
         const {
           fixed
         } = column;
-        return this.scrollToColumn(column).then(() => {
+        return $xeTable.scrollToColumn(column).then(() => {
           const headerWrapperElem = elemStore[`${fixed || 'main'}-header-wrapper`] || elemStore['main-header-wrapper'];
           if (headerWrapperElem) {
             const filterBtnElem = headerWrapperElem.querySelector(`.vxe-header--column.${column.id} .vxe-cell--filter`);
@@ -23057,7 +23403,7 @@ const {
           }
         });
       }
-      return this.$nextTick();
+      return $xeTable.$nextTick();
     },
     /**
      * 修改筛选条件列表
@@ -23278,9 +23624,9 @@ const {
           datas.push(item.data);
         }
       });
-      const filterList = this.getCheckedFilters();
+      const filterList = $xeTable.getCheckedFilters();
       const params = {
-        $table: this,
+        $table: $xeTable,
         $event: evnt,
         column,
         field,
@@ -23292,21 +23638,21 @@ const {
       };
       // 如果是服务端筛选，则跳过本地筛选处理
       if (!filterOpts.remote) {
-        this.handleTableData(true);
-        this.checkSelectionStatus();
+        $xeTable.handleTableData(true);
+        $xeTable.checkSelectionStatus();
       }
-      if (mouseConfig && mouseOpts.area && this.handleFilterEvent) {
+      if (mouseConfig && mouseOpts.area && $xeTable.handleFilterEvent) {
         $xeTable.handleFilterEvent(evnt, params);
       }
       if (evnt) {
-        $xeTable.emitEvent('filter-change', params, evnt);
+        $xeTable.dispatchEvent('filter-change', params, evnt);
       }
       $xeTable.closeFilter();
       return $xeTable.updateFooter().then(() => {
         const {
           scrollXLoad,
           scrollYLoad
-        } = this;
+        } = reactData;
         if (oldScrollXLoad || scrollXLoad || oldScrollYLoad || scrollYLoad) {
           if (oldScrollXLoad || scrollXLoad) {
             $xeTable.updateScrollXSpace();
@@ -23341,6 +23687,7 @@ const {
       $xeTable.handleColumnConfirmFilter(column, evnt);
     },
     handleClearFilter(column) {
+      const $xeTable = this;
       if (column) {
         const {
           filters,
@@ -23360,7 +23707,7 @@ const {
             filterResetMethod({
               options: filters,
               column,
-              $table: this
+              $table: $xeTable
             });
           }
         }
@@ -23563,26 +23910,33 @@ const {
           };
           if (columnTargetNode.flag) {
             const cell = columnTargetNode.targetElem;
-            const column = this.getColumnNode(cell).item;
+            const columnNodeRest = $xeTable.getColumnNode(cell);
+            const column = columnNodeRest ? columnNodeRest.item : null;
             let typePrefix = `${layout}-`;
-            Object.assign(params, {
-              column,
-              columnIndex: this.getColumnIndex(column),
-              cell
-            });
+            if (column) {
+              Object.assign(params, {
+                column,
+                columnIndex: $xeTable.getColumnIndex(column),
+                cell
+              });
+            }
             if (layout === 'body') {
-              const row = this.getRowNode(cell.parentNode).item;
+              const rowNodeRest = $xeTable.getRowNode(cell.parentNode);
+              const row = rowNodeRest ? rowNodeRest.item : null;
               typePrefix = '';
-              params.row = row;
-              params.rowIndex = this.getRowIndex(row);
+              if (row) {
+                params.row = row;
+                params.rowIndex = $xeTable.getRowIndex(row);
+              }
             }
+            const eventType = `${typePrefix}cell-menu`;
             this.handleOpenMenuEvent(evnt, layout, params);
             // 在 v4 中废弃事件 cell-context-menu、header-cell-context-menu、footer-cell-context-menu
             if (this.$listeners[`${typePrefix}cell-context-menu`]) {
               warnLog('vxe.error.delEvent', [`${typePrefix}cell-context-menu`, `${typePrefix}cell-menu`]);
-              this.emitEvent(`${typePrefix}cell-context-menu`, params, evnt);
+              $xeTable.dispatchEvent(`${typePrefix}cell-context-menu`, params, evnt);
             } else {
-              this.emitEvent(`${typePrefix}cell-menu`, params, evnt);
+              $xeTable.dispatchEvent(eventType, params, evnt);
             }
             return;
           } else if (getEventTargetNode(evnt, this.$el, `vxe-table--${layout}-wrapper`, target => target.getAttribute('xid') === tId).flag) {
@@ -23765,9 +24119,9 @@ const {
         // 在 v4 中废弃事件 context-menu-click
         if (this.$listeners['context-menu-click']) {
           warnLog('vxe.error.delEvent', ['context-menu-click', 'menu-click']);
-          this.emitEvent('context-menu-click', params, evnt);
+          $xeTable.dispatchEvent('context-menu-click', params, evnt);
         } else {
-          this.emitEvent('menu-click', params, evnt);
+          $xeTable.dispatchEvent('menu-click', params, evnt);
         }
         this.closeMenu();
       }
@@ -23944,11 +24298,13 @@ function handleInsertRowAt($xeTable, records, targetRow, isInsertNextRow) {
     tableFullData,
     fullDataRowIdData,
     fullAllDataRowIdData,
-    insertRowMaps
+    insertRowMaps,
+    removeRowMaps
   } = internalData;
   const treeOpts = $xeTable.computeTreeOpts;
   const {
     transform,
+    parentField,
     rowField,
     mapChildrenField
   } = treeOpts;
@@ -23960,6 +24316,14 @@ function handleInsertRowAt($xeTable, records, targetRow, isInsertNextRow) {
     [mapChildrenField]: [],
     [childrenField]: []
   } : {}, record)));
+  let treeRecords = [];
+  if (treeConfig && transform) {
+    treeRecords = external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().toArrayTree(newRecords, {
+      key: rowField,
+      parentKey: parentField,
+      children: childrenField
+    });
+  }
   if (external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().eqNull(targetRow)) {
     // 如果为虚拟树
     if (treeConfig && transform) {
@@ -24057,21 +24421,26 @@ function handleInsertRowAt($xeTable, records, targetRow, isInsertNextRow) {
           const parentMapChilds = parentRow ? parentRow[mapChildrenField] : tableFullTreeData;
           const parentRest = fullAllDataRowIdData[getRowid($xeTable, parentRow)];
           const parentLevel = parentRest ? parentRest.level : 0;
-          newRecords.forEach((item, i) => {
-            const rowid = getRowid($xeTable, item);
-            if (item[treeOpts.parentField]) {
-              if (parentRow && item[treeOpts.parentField] !== parentRow[rowField]) {
-                errLog('vxe.error.errProp', [`${treeOpts.parentField}=${item[treeOpts.parentField]}`, `${treeOpts.parentField}=${parentRow[rowField]}`]);
-              }
-            }
+          treeRecords.forEach((row, i) => {
             if (parentRow) {
-              item[treeOpts.parentField] = parentRow[rowField];
+              if (row[parentField] !== parentRow[rowField]) {
+                row[parentField] = parentRow[rowField];
+                errLog('vxe.error.errProp', [`${parentField}=${row[parentField]}`, `${parentField}=${parentRow[rowField]}`]);
+              }
+            } else {
+              if (row[parentField] !== null) {
+                row[parentField] = null;
+                errLog('vxe.error.errProp', [`${parentField}=${row[parentField]}`, 'null']);
+              }
             }
             let targetIndex = matchMapObj.index + i;
             if (isInsertNextRow) {
               targetIndex = targetIndex + 1;
             }
-            parentMapChilds.splice(targetIndex, 0, item);
+            parentMapChilds.splice(targetIndex, 0, row);
+          });
+          external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().eachTree(treeRecords, item => {
+            const rowid = getRowid($xeTable, item);
             const rest = {
               row: item,
               rowid,
@@ -24089,8 +24458,13 @@ function handleInsertRowAt($xeTable, records, targetRow, isInsertNextRow) {
               oTop: 0,
               expandHeight: 0
             };
+            if (item[childrenField]) {
+              item[mapChildrenField] = item[childrenField];
+            }
             fullDataRowIdData[rowid] = rest;
             fullAllDataRowIdData[rowid] = rest;
+          }, {
+            children: childrenField
           });
           // 源
           if (parentRow) {
@@ -24103,7 +24477,7 @@ function handleInsertRowAt($xeTable, records, targetRow, isInsertNextRow) {
               if (isInsertNextRow) {
                 targetIndex = targetIndex + 1;
               }
-              parentChilds.splice(targetIndex, 0, ...newRecords);
+              parentChilds.splice(targetIndex, 0, ...treeRecords);
             }
           }
         } else {
@@ -24134,7 +24508,7 @@ function handleInsertRowAt($xeTable, records, targetRow, isInsertNextRow) {
           afIndex = Math.min(afterFullData.length, afIndex + 1);
         }
         if (afIndex === -1) {
-          throw new Error(errLog('vxe.error.unableInsert'));
+          throw new Error(mixin_getI18n('vxe.error.unableInsert'));
         }
         afterFullData.splice(afIndex, 0, ...newRecords);
         const tfIndex = $xeTable.findRowIndexOf(tableFullData, targetRow);
@@ -24158,10 +24532,27 @@ function handleInsertRowAt($xeTable, records, targetRow, isInsertNextRow) {
       }
     }
   }
-  newRecords.forEach(newRow => {
+  const handleStatus = newRow => {
     const rowid = getRowid($xeTable, newRow);
-    insertRowMaps[rowid] = newRow;
-  });
+    // 如果是被删除的数据，则还原状态
+    if (removeRowMaps[rowid]) {
+      delete removeRowMaps[rowid];
+      if (insertRowMaps[rowid]) {
+        delete insertRowMaps[rowid];
+      }
+    } else {
+      insertRowMaps[rowid] = newRow;
+    }
+  };
+  // 如果为虚拟树
+  if (treeConfig && transform) {
+    external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().eachTree(treeRecords, handleStatus, {
+      children: mapChildrenField
+    });
+  } else {
+    newRecords.forEach(handleStatus);
+  }
+  reactData.removeRowFlag++;
   reactData.insertRowFlag++;
   $xeTable.cacheRowMap(false);
   $xeTable.updateScrollYStatus();
@@ -24812,7 +25203,9 @@ function handleEditCell($xeTable, row, fieldOrColumn, isPos) {
       if (column && row) {
         return {
           row,
-          column
+          rowIndex: $xeTable.getRowIndex(row),
+          column,
+          columnIndex: $xeTable.getColumnIndex(column)
         };
       }
       return null;
@@ -27783,12 +28176,13 @@ function checkRuleStatus(rule, val) {
      * 聚焦到校验通过的单元格并弹出校验错误提示
      */
     handleValidError(params) {
+      const $xeTable = this;
       const {
         validOpts
       } = this;
       return new Promise(resolve => {
         if (validOpts.autoPos === false) {
-          this.emitEvent('valid-error', params);
+          $xeTable.dispatchEvent('valid-error', params, null);
           resolve();
         } else {
           this.handleEdit(params, {
@@ -28201,6 +28595,7 @@ function checkRuleStatus(rule, val) {
      * 弹出校验错误提示
      */
     showValidTooltip(params) {
+      const $xeTable = this;
       const {
         $refs,
         height,
@@ -28237,7 +28632,7 @@ function checkRuleStatus(rule, val) {
           }
         });
       }
-      this.emitEvent('valid-error', params, null);
+      $xeTable.dispatchEvent('valid-error', params, null);
       if (validTip) {
         if (validTip && (validOpts.message === 'tooltip' || validOpts.message === 'default' && !height && tableData.length < 2)) {
           return validTip.open(cell, content);
@@ -28700,6 +29095,7 @@ function emitCustomEvent($xeTable, type, evnt) {
 
 
 
+
 
 
 const {
@@ -28811,6 +29207,7 @@ function renderEmptyBody(h, $xeTable) {
 const renderDragTipContents = (h, $xeTable) => {
   const props = $xeTable;
   const reactData = $xeTable;
+  const crossTableDragRowInfo = getCrossTableDragRowInfo($xeTable);
   const {
     dragConfig
   } = props;
@@ -28825,9 +29222,10 @@ const renderDragTipContents = (h, $xeTable) => {
   const rTipSlot = rowDragSlots.tip || (dragConfig && dragConfig.slots ? dragConfig.slots.rowTip : null);
   const columnDragSlots = columnDragOpts.slots || {};
   const cTipSlot = columnDragSlots.tip;
-  if (dragRow && rTipSlot) {
+  const dRow = dragRow || (rowDragOpts.isCrossTableDrag ? crossTableDragRowInfo.row : null);
+  if (dRow && rTipSlot) {
     return $xeTable.callSlot(rTipSlot, {
-      row: dragRow
+      row: dRow
     }, h);
   }
   if (dragCol && cTipSlot) {
@@ -28839,6 +29237,7 @@ const renderDragTipContents = (h, $xeTable) => {
 };
 const table_renderDragTip = (h, $xeTable) => {
   const reactData = $xeTable;
+  const crossTableDragRowInfo = getCrossTableDragRowInfo($xeTable);
   const {
     dragRow,
     dragCol
@@ -28847,6 +29246,7 @@ const table_renderDragTip = (h, $xeTable) => {
   const columnOpts = $xeTable.computeColumnOpts;
   const rowDragOpts = $xeTable.computeRowDragOpts;
   const columnDragOpts = $xeTable.computeColumnDragOpts;
+  const dRow = dragRow || (rowDragOpts.isCrossTableDrag ? crossTableDragRowInfo.row : null);
   if (rowOpts.drag || columnOpts.drag) {
     return h('div', {
       class: 'vxe-table--drag-wrapper'
@@ -28860,7 +29260,7 @@ const table_renderDragTip = (h, $xeTable) => {
       class: ['vxe-table--drag-col-line', {
         'is--guides': columnDragOpts.showGuidesStatus
       }]
-    }), dragRow && rowDragOpts.showDragTip || dragCol && columnDragOpts.showDragTip ? h('div', {
+    }), dRow && rowDragOpts.showDragTip || dragCol && columnDragOpts.showDragTip ? h('div', {
       ref: 'refDragTipElem',
       class: 'vxe-table--drag-sort-tip'
     }, [h('div', {
@@ -28868,7 +29268,7 @@ const table_renderDragTip = (h, $xeTable) => {
     }, [h('div', {
       class: 'vxe-table--drag-sort-tip-status'
     }, [h('span', {
-      class: ['vxe-table--drag-sort-tip-normal-status', dragRow ? table_getIcon().TABLE_DRAG_STATUS_ROW : table_getIcon().TABLE_DRAG_STATUS_COLUMN]
+      class: ['vxe-table--drag-sort-tip-normal-status', dRow ? table_getIcon().TABLE_DRAG_STATUS_ROW : table_getIcon().TABLE_DRAG_STATUS_COLUMN]
     }), h('span', {
       class: ['vxe-table--drag-sort-tip-sub-status', table_getIcon().TABLE_DRAG_STATUS_SUB_ROW]
     }), h('span', {
@@ -29373,9 +29773,9 @@ function renderBody(h, $xeTable) {
       resizeHeightFlag: 1,
       resizeWidthFlag: 1,
       isCustomStatus: false,
-      isDragRowMove: false,
+      isCrossDragRow: false,
       dragRow: null,
-      isDragColMove: false,
+      isCrossDragCol: false,
       dragCol: null,
       dragTipText: '',
       isDragResize: false,
@@ -29383,7 +29783,8 @@ function renderBody(h, $xeTable) {
       isColLoading: false,
       reScrollFlag: 0,
       reLayoutFlag: 0,
-      footFlag: 0
+      footFlag: 0,
+      crossTableDragRowInfo: crossTableDragRowGlobal
     };
   },
   computed: {
@@ -30207,6 +30608,7 @@ function renderBody(h, $xeTable) {
     const currentColumnOpts = $xeTable.computeCurrentColumnOpts;
     const keyboardOpts = $xeTable.computeKeyboardOpts;
     const aggregateOpts = $xeTable.computeAggregateOpts;
+    const rowDragOpts = $xeTable.computeRowDragOpts;
     const {
       groupFields
     } = aggregateOpts;
@@ -30314,7 +30716,10 @@ function renderBody(h, $xeTable) {
       }
     }
     if (treeConfig && rowOpts.drag && !treeOpts.transform) {
-      warnLog('vxe.error.notSupportProp', ['column-config.drag', 'tree-config.transform=false', 'tree-config.transform=true']);
+      warnLog('vxe.error.notSupportProp', ['row-config.drag', 'tree-config.transform=false', 'tree-config.transform=true']);
+    }
+    if (treeConfig && rowDragOpts.isCrossTableDrag && !rowDragOpts.isCrossDrag) {
+      errLog('vxe.error.reqSupportProp', ['tree-config & row-drag-config.isCrossTableDrag', 'row-drag-config.isCrossDrag']);
     }
     if (props.dragConfig) {
       warnLog('vxe.error.delProp', ['drag-config', 'row-drag-config']);
@@ -30641,6 +31046,7 @@ function renderBody(h, $xeTable) {
       rightList
     } = columnStore;
     const loadingSlot = slots.loading;
+    const rowDragOpts = $xeTable.computeRowDragOpts;
     const tableTipConfig = $xeTable.computeTableTipConfig;
     const validTipConfig = $xeTable.computeValidTipConfig;
     const validOpts = $xeTable.computeValidOpts;
@@ -30660,6 +31066,13 @@ function renderBody(h, $xeTable) {
     const columnDragOpts = $xeTable.computeColumnDragOpts;
     const scrollbarXToTop = $xeTable.computeScrollbarXToTop;
     const scrollbarYToLeft = $xeTable.computeScrollbarYToLeft;
+    const {
+      isCrossTableDrag
+    } = rowDragOpts;
+    const rwOns = {};
+    if (isCrossTableDrag && !tableData.length) {
+      rwOns.onDragover = $xeTable.handleCrossTableRowDragoverEmptyEvent;
+    }
     return h('div', {
       ref: 'refElem',
       class: ['vxe-table', 'vxe-table--render-default', `tid_${xID}`, `border--${tableBorder}`, `sx-pos--${scrollbarXToTop ? 'top' : 'bottom'}`, `sy-pos--${scrollbarYToLeft ? 'left' : 'right'}`, {
@@ -30719,7 +31132,8 @@ function renderBody(h, $xeTable) {
       class: 'vxe-table-var-mini'
     })]), h('div', {
       key: 'tw',
-      class: 'vxe-table--render-wrapper'
+      class: 'vxe-table--render-wrapper',
+      on: rwOns
     }, scrollbarXToTop ? [renderScrollX(h, $xeTable), renderBody(h, $xeTable)] : [renderBody(h, $xeTable), renderScrollX(h, $xeTable)]),
     /**
      * 空数据