vxe-table 3.12.10-beta.9 → 3.12.10

package/es/table/src/methods.js

@@ -1,5 +1,5 @@
 import XEUtils from 'xe-utils';
-import { browse, getTpImg, isPx, isScale, hasClass, addClass, removeClass, getEventTargetNode, getPaddingTopBottomSize, setScrollTop, setScrollLeft } from '../../ui/src/dom';
+import { browse, getTpImg, isPx, isScale, hasClass, addClass, removeClass, getEventTargetNode, getPaddingTopBottomSize, getOffsetPos, setScrollTop, setScrollLeft } from '../../ui/src/dom';
 import { getLastZIndex, nextZIndex, hasChildrenList, getFuncText, isEnableConf, formatText, eqEmptyValue } from '../../ui/src/utils';
 import { VxeUI } from '../../ui';
 import Cell from './cell';
@@ -308,7 +308,7 @@ function updateAfterListIndex($xeTable) {
             rowRest._index = index;
         }
         else {
-            const rest = { row, rowid, seq, index: -1, $index: -1, _index: index, treeIndex: -1, items: [], parent: null, level: 0, height: 0, oTop: 0 };
+            const rest = { row, rowid, seq, index: -1, $index: -1, _index: index, treeIndex: -1, items: [], parent: null, level: 0, height: 0, resizeHeight: 0, oTop: 0 };
             fullAllDataRowIdData[rowid] = rest;
             fullDataRowIdData[rowid] = rest;
         }
@@ -339,7 +339,7 @@ function updateAfterDataIndex($xeTable) {
                 rowRest.treeIndex = index;
             }
             else {
-                const rest = { row, rowid, seq, index: -1, $index: -1, _index: -1, treeIndex: -1, items: [], parent: null, level: 0, height: 0, oTop: 0 };
+                const rest = { row, rowid, seq, index: -1, $index: -1, _index: -1, treeIndex: -1, items: [], parent: null, level: 0, height: 0, resizeHeight: 0, oTop: 0 };
                 fullAllDataRowIdData[rowid] = rest;
                 fullDataRowIdData[rowid] = rest;
             }
@@ -390,14 +390,16 @@ function updateStyle($xeTable) {
     const props = $xeTable;
     const reactData = $xeTable;
     const internalData = $xeTable;
-    const { border, showOverflow: allColumnOverflow, showHeaderOverflow: allColumnHeaderOverflow, showFooterOverflow: allColumnFooterOverflow, mouseConfig, spanMethod, footerSpanMethod } = props;
-    const { isGroup, currentRow, tableColumn, scrollXLoad, scrollYLoad, scrollbarWidth, scrollbarHeight, columnStore, editStore, isAllOverflow, expandColumn } = reactData;
+    const { border, showHeaderOverflow: allColumnHeaderOverflow, showFooterOverflow: allColumnFooterOverflow, mouseConfig, spanMethod, footerSpanMethod } = props;
+    const { isGroup, currentRow, tableColumn, scrollXLoad, scrollYLoad, overflowX, scrollbarWidth, overflowY, scrollbarHeight, columnStore, editStore, isAllOverflow, expandColumn } = reactData;
     const { visibleColumn, fullColumnIdData, tableHeight, tableWidth, headerHeight, footerHeight, elemStore, customHeight, customMinHeight, customMaxHeight } = internalData;
     const el = $xeTable.$refs.refElem;
     if (!el) {
         return;
     }
     const containerList = ['main', 'left', 'right'];
+    const osbWidth = overflowY ? scrollbarWidth : 0;
+    const osbHeight = overflowX ? scrollbarHeight : 0;
     const emptyPlaceholderElem = $xeTable.$refs.refEmptyPlaceholder;
     const cellOffsetWidth = $xeTable.computeCellOffsetWidth;
     const mouseOpts = $xeTable.computeMouseOpts;
@@ -405,16 +407,16 @@ function updateStyle($xeTable) {
     const bodyTableElem = getRefElem(elemStore['main-body-table']);
     if (emptyPlaceholderElem) {
         emptyPlaceholderElem.style.top = `${headerHeight}px`;
-        emptyPlaceholderElem.style.height = bodyWrapperElem ? `${bodyWrapperElem.offsetHeight - scrollbarHeight}px` : '';
+        emptyPlaceholderElem.style.height = bodyWrapperElem ? `${bodyWrapperElem.offsetHeight - osbHeight}px` : '';
     }
     let bodyHeight = 0;
     let bodyMaxHeight = 0;
-    const bodyMinHeight = customMinHeight - headerHeight - footerHeight - scrollbarHeight;
+    const bodyMinHeight = customMinHeight - headerHeight - footerHeight - osbHeight;
     if (customMaxHeight) {
-        bodyMaxHeight = Math.max(bodyMinHeight, customMaxHeight - headerHeight - footerHeight - scrollbarHeight);
+        bodyMaxHeight = Math.max(bodyMinHeight, customMaxHeight - headerHeight - footerHeight - osbHeight);
     }
     if (customHeight) {
-        bodyHeight = customHeight - headerHeight - footerHeight - scrollbarHeight;
+        bodyHeight = customHeight - headerHeight - footerHeight - osbHeight;
     }
     if (!bodyHeight) {
         if (bodyTableElem) {
@@ -432,27 +434,27 @@ function updateStyle($xeTable) {
     const scrollbarXToTop = $xeTable.computeScrollbarXToTop;
     const scrollXVirtualEl = $xeTable.$refs.refScrollXVirtualElem;
     if (scrollXVirtualEl) {
-        scrollXVirtualEl.style.height = `${scrollbarHeight}px`;
-        scrollXVirtualEl.style.visibility = scrollbarHeight ? 'visible' : 'hidden';
+        scrollXVirtualEl.style.height = `${osbHeight}px`;
+        scrollXVirtualEl.style.visibility = overflowX ? 'visible' : 'hidden';
     }
     const xWrapperEl = $xeTable.$refs.refScrollXWrapperElem;
     if (xWrapperEl) {
-        xWrapperEl.style.left = scrollbarXToTop ? `${scrollbarWidth}px` : '';
-        xWrapperEl.style.width = `${el.clientWidth - scrollbarWidth}px`;
+        xWrapperEl.style.left = scrollbarXToTop ? `${osbWidth}px` : '';
+        xWrapperEl.style.width = `${el.clientWidth - osbWidth}px`;
     }
     if (xLeftCornerEl) {
-        xLeftCornerEl.style.width = scrollbarXToTop ? `${scrollbarWidth}px` : '';
-        xLeftCornerEl.style.display = scrollbarXToTop ? (scrollbarWidth && scrollbarHeight ? 'block' : '') : '';
+        xLeftCornerEl.style.width = scrollbarXToTop ? `${osbWidth}px` : '';
+        xLeftCornerEl.style.display = scrollbarXToTop ? (osbWidth && osbHeight ? 'block' : '') : '';
     }
     if (xRightCornerEl) {
-        xRightCornerEl.style.width = scrollbarXToTop ? '' : `${scrollbarWidth}px`;
-        xRightCornerEl.style.display = scrollbarXToTop ? '' : (scrollbarWidth && scrollbarHeight ? 'block' : '');
+        xRightCornerEl.style.width = scrollbarXToTop ? '' : `${osbWidth}px`;
+        xRightCornerEl.style.display = scrollbarXToTop ? '' : (osbWidth && osbHeight ? 'block' : '');
     }
     const scrollYVirtualEl = $xeTable.$refs.refScrollYVirtualElem;
     if (scrollYVirtualEl) {
-        scrollYVirtualEl.style.width = `${scrollbarWidth}px`;
+        scrollYVirtualEl.style.width = `${osbWidth}px`;
         scrollYVirtualEl.style.height = `${bodyHeight + headerHeight + footerHeight}px`;
-        scrollYVirtualEl.style.visibility = scrollbarWidth ? 'visible' : 'hidden';
+        scrollYVirtualEl.style.visibility = overflowY ? 'visible' : 'hidden';
     }
     const yTopCornerEl = $xeTable.$refs.refScrollYTopCornerElem;
     if (yTopCornerEl) {
@@ -570,14 +572,14 @@ function updateStyle($xeTable) {
                     if (wrapperElem) {
                         wrapperElem.style.top = `${headerHeight}px`;
                     }
-                    fixedWrapperElem.style.height = `${customHeight > 0 ? customHeight : (tableHeight + headerHeight + footerHeight + scrollbarHeight)}px`;
+                    fixedWrapperElem.style.height = `${customHeight > 0 ? customHeight : (tableHeight + headerHeight + footerHeight + osbHeight)}px`;
                     fixedWrapperElem.style.width = `${fixedColumn.reduce((previous, column) => previous + column.renderWidth, 0)}px`;
                 }
                 let tWidth = tableWidth;
                 let renderColumnList = tableColumn;
                 let isOptimizeMode = false;
                 // 如果是使用优化模式
-                if (scrollXLoad || scrollYLoad || (allColumnOverflow && isAllOverflow)) {
+                if (scrollXLoad || scrollYLoad || isAllOverflow) {
                     if (expandColumn || spanMethod || footerSpanMethod) {
                         // 如果不支持优化模式
                     }
@@ -600,7 +602,7 @@ function updateStyle($xeTable) {
                 if (tableElem) {
                     tableElem.style.width = tWidth ? `${tWidth}px` : '';
                     // 兼容性处理
-                    tableElem.style.paddingRight = scrollbarWidth && fixedType && (browse['-moz'] || browse.safari) ? `${scrollbarWidth}px` : '';
+                    tableElem.style.paddingRight = osbWidth && fixedType && (browse['-moz'] || browse.safari) ? `${osbWidth}px` : '';
                 }
                 const emptyBlockElem = getRefElem(elemStore[`${name}-${layout}-emptyBlock`]);
                 if (emptyBlockElem) {
@@ -637,7 +639,7 @@ function updateStyle($xeTable) {
                     // 如果是固定列
                     if (fixedWrapperElem) {
                         if (wrapperElem) {
-                            wrapperElem.style.top = `${customHeight > 0 ? customHeight - footerHeight - scrollbarHeight : tableHeight + headerHeight}px`;
+                            wrapperElem.style.top = `${customHeight > 0 ? customHeight - footerHeight - osbHeight : tableHeight + headerHeight}px`;
                         }
                     }
                 }
@@ -662,7 +664,7 @@ function updateStyle($xeTable) {
                             cellOverflow = XEUtils.isUndefined(showFooterOverflow) || XEUtils.isNull(showFooterOverflow) ? allColumnFooterOverflow : showFooterOverflow;
                         }
                         else {
-                            cellOverflow = XEUtils.isUndefined(showOverflow) || XEUtils.isNull(showOverflow) ? allColumnOverflow : showOverflow;
+                            cellOverflow = XEUtils.isUndefined(showOverflow) || XEUtils.isNull(showOverflow) ? isAllOverflow : showOverflow;
                         }
                         const showEllipsis = cellOverflow === 'ellipsis';
                         const showTitle = cellOverflow === 'title';
@@ -706,14 +708,14 @@ function updateStyle($xeTable) {
     return $xeTable.$nextTick();
 }
 function computeRowHeight($xeTable) {
-    const props = $xeTable;
-    const { showOverflow } = props;
+    const reactData = $xeTable;
+    const { isAllOverflow } = reactData;
     const tableHeader = $xeTable.$refs.refTableHeader;
     const tableBody = $xeTable.$refs.refTableBody;
     const tableBodyElem = tableBody ? tableBody.$el : null;
     const defaultRowHeight = $xeTable.computeDefaultRowHeight;
     let rowHeight = 0;
-    if (showOverflow) {
+    if (isAllOverflow) {
         if (tableBodyElem) {
             const tableHeaderElem = tableHeader ? tableHeader.$el : null;
             let firstTrElem;
@@ -735,30 +737,33 @@ function computeRowHeight($xeTable) {
     // 最低支持 18px 行高
     return Math.max(18, rowHeight);
 }
-function handleVirtualYVisible($xeTable) {
-    const props = $xeTable;
+function handleVirtualYVisible($xeTable, currScrollTop) {
     const reactData = $xeTable;
     const internalData = $xeTable;
-    const { showOverflow } = props;
-    const { rowHeight } = reactData;
-    const { elemStore, afterFullData, fullAllDataRowIdData } = internalData;
+    const { isAllOverflow } = reactData;
+    const { elemStore, isResizeCellHeight, afterFullData, fullAllDataRowIdData } = internalData;
+    const rowOpts = $xeTable.computeRowOpts;
+    const cellOpts = $xeTable.computeCellOpts;
+    const defaultRowHeight = $xeTable.computeDefaultRowHeight;
     const bodyScrollElem = getRefElem(elemStore['main-body-scroll']);
     if (bodyScrollElem) {
-        const { scrollTop, clientHeight } = bodyScrollElem;
+        const clientHeight = bodyScrollElem.clientHeight;
+        const scrollTop = XEUtils.isNumber(currScrollTop) ? currScrollTop : bodyScrollElem.scrollTop;
         const endHeight = scrollTop + clientHeight;
         let toVisibleIndex = -1;
         let offsetTop = 0;
         let visibleSize = 0;
-        if (showOverflow) {
-            toVisibleIndex = Math.floor(scrollTop / rowHeight);
-            visibleSize = Math.ceil(clientHeight / rowHeight) + 1;
+        const isCustomCellHeight = isResizeCellHeight || cellOpts.height || rowOpts.height;
+        if (!isCustomCellHeight && isAllOverflow) {
+            toVisibleIndex = Math.floor(scrollTop / defaultRowHeight);
+            visibleSize = Math.ceil(clientHeight / defaultRowHeight) + 1;
         }
         else {
             for (let rIndex = 0, rLen = afterFullData.length; rIndex < rLen; rIndex++) {
                 const row = afterFullData[rIndex];
                 const rowid = getRowid($xeTable, row);
-                const rowRest = fullAllDataRowIdData[rowid];
-                offsetTop += rowRest ? (rowRest.height || rowHeight) : rowHeight;
+                const rowRest = fullAllDataRowIdData[rowid] || {};
+                offsetTop += rowRest.resizeHeight || rowRest.height || cellOpts.height || rowOpts.height || defaultRowHeight;
                 if (toVisibleIndex === -1 && scrollTop < offsetTop) {
                     toVisibleIndex = rIndex;
                 }
@@ -1010,7 +1015,7 @@ function autoCellWidth($xeTable) {
     }
     const tableHeight = bodyElem.offsetHeight;
     const overflowY = yHandleEl.scrollHeight > yHandleEl.clientHeight;
-    reactData.scrollbarWidth = overflowY ? Math.max(scrollbarOpts.width || 0, yHandleEl.offsetWidth - yHandleEl.clientWidth) : 0;
+    reactData.scrollbarWidth = Math.max(scrollbarOpts.width || 0, yHandleEl.offsetWidth - yHandleEl.clientWidth);
     reactData.overflowY = overflowY;
     internalData.tableWidth = tableWidth;
     internalData.tableHeight = tableHeight;
@@ -1019,7 +1024,7 @@ function autoCellWidth($xeTable) {
     const headerHeight = headerTableElem ? headerTableElem.clientHeight : 0;
     const overflowX = tableWidth > bodyWidth;
     const footerHeight = footerTableElem ? footerTableElem.clientHeight : 0;
-    reactData.scrollbarHeight = overflowX ? Math.max(scrollbarOpts.height || 0, xHandleEl.offsetHeight - xHandleEl.clientHeight) : 0;
+    reactData.scrollbarHeight = Math.max(scrollbarOpts.height || 0, xHandleEl.offsetHeight - xHandleEl.clientHeight);
     internalData.headerHeight = headerHeight;
     internalData.footerHeight = footerHeight;
     reactData.overflowX = overflowX;
@@ -1029,61 +1034,36 @@ function autoCellWidth($xeTable) {
         $xeTable.checkScrolling();
     }
 }
-// const updateCellOffset = ($xeTable: VxeTableConstructor) => {
-//   const internalData = $xeTable as unknown as TableInternalData
-//   const { chTimeout, chRunTime } = internalData
-//   if (chTimeout) {
-//     clearTimeout(chTimeout)
-//   }
-//   if (!chRunTime || chRunTime + 10 < Date.now()) {
-//     internalData.chRunTime = Date.now()
-//   }
-//   internalData.chTimeout = setTimeout(() => {
-//     internalData.chRunTime = undefined
-//     internalData.chTimeout = undefined
-//   }, 80)
-// }
+const calcCellAutoHeight = (rowRest, wrapperEl) => {
+    const cellElemList = wrapperEl.querySelectorAll(`.vxe-cell--wrapper[rowid="${rowRest.rowid}"]`);
+    let colHeight = rowRest.height;
+    for (let i = 0; i < cellElemList.length; i++) {
+        const cellElem = cellElemList[i];
+        const tdEl = cellElem.parentElement;
+        const topBottomPadding = Math.ceil(XEUtils.toNumber(tdEl.style.paddingTop) + XEUtils.toNumber(tdEl.style.paddingBottom));
+        const cellHeight = cellElem ? cellElem.clientHeight : 0;
+        colHeight = Math.max(colHeight - topBottomPadding, Math.ceil(cellHeight));
+    }
+    return colHeight;
+};
 const calcCellHeight = ($xeTable) => {
-    const props = $xeTable;
     const reactData = $xeTable;
     const internalData = $xeTable;
-    const { showOverflow } = props;
-    const { tableData, scrollXLoad } = reactData;
+    const { tableData, isAllOverflow, scrollYLoad, scrollXLoad } = reactData;
     const { fullAllDataRowIdData } = internalData;
+    const defaultRowHeight = $xeTable.computeDefaultRowHeight;
     const el = $xeTable.$refs.refElem;
-    if (!showOverflow && el) {
-        let paddingTop = 0;
-        let paddingBottom = 0;
-        let calcPadding = false;
+    if (!isAllOverflow && scrollYLoad && el) {
         tableData.forEach(row => {
             const rowid = getRowid($xeTable, row);
             const rowRest = fullAllDataRowIdData[rowid];
-            const cellList = el.querySelectorAll(`.vxe-body--row[rowid="${rowid}"]>.vxe-body--column>.vxe-cell>.vxe-cell--auto-wrapper`);
-            if (rowRest && cellList.length) {
-                let height = 0;
-                for (let i = 0; i < cellList.length; i++) {
-                    const cellElem = cellList[i];
-                    const tdEl = cellElem.parentElement;
-                    if (!tdEl || !tdEl.clientWidth) {
-                        break;
-                    }
-                    if (!calcPadding) {
-                        paddingTop = XEUtils.toNumber(getComputedStyle(tdEl).paddingTop);
-                        paddingBottom = XEUtils.toNumber(getComputedStyle(tdEl).paddingBottom);
-                        calcPadding = true;
-                    }
-                    let cellHeight = paddingTop + paddingBottom;
-                    if (cellElem) {
-                        cellHeight += cellElem.clientHeight;
-                    }
-                    height = Math.max(height, cellHeight);
-                }
-                rowRest.height = scrollXLoad ? Math.max(rowRest.height, height) : height;
+            if (rowRest) {
+                const height = calcCellAutoHeight(rowRest, el);
+                rowRest.height = Math.max(defaultRowHeight, scrollXLoad ? Math.max(rowRest.height, height) : height);
             }
         });
-        reactData.isCalcCellHeight++;
+        reactData.calcCellHeightFlag++;
     }
-    // updateCellOffset()
 };
 function getOrderField(_vm, column) {
     const { sortBy, sortType } = column;
@@ -1107,6 +1087,19 @@ function getOrderField(_vm, column) {
         return cellValue;
     };
 }
+function handleTargetEnterEvent($xeTable, isClear) {
+    const internalData = $xeTable;
+    const $tooltip = $xeTable.$refs.refTooltip;
+    clearTimeout(internalData.tooltipTimeout);
+    if (isClear) {
+        $xeTable.closeTooltip();
+    }
+    else {
+        if ($tooltip && $tooltip.setActived) {
+            $tooltip.setActived(true);
+        }
+    }
+}
 function clearDragStatus($xeTable) {
     const reactData = $xeTable;
     const { dragRow, dragCol } = reactData;
@@ -1205,9 +1198,11 @@ function showDropTip($xeTable, evnt, trEl, thEl, showLine, dragPos) {
     if (!el) {
         return;
     }
-    const { scrollbarWidth, scrollbarHeight } = reactData;
+    const { overflowX, scrollbarWidth, overflowY, scrollbarHeight } = reactData;
     const { prevDragToChild } = internalData;
     const wrapperRect = el.getBoundingClientRect();
+    const osbWidth = overflowY ? scrollbarWidth : 0;
+    const osbHeight = overflowX ? scrollbarHeight : 0;
     const tableWidth = el.clientWidth;
     const tableHeight = el.clientHeight;
     if (trEl) {
@@ -1218,14 +1213,14 @@ function showDropTip($xeTable, evnt, trEl, thEl, showLine, dragPos) {
                 const trRect = trEl.getBoundingClientRect();
                 let trHeight = trEl.clientHeight;
                 const offsetTop = Math.max(1, trRect.y - wrapperRect.y);
-                if (offsetTop + trHeight > tableHeight - scrollbarHeight) {
-                    trHeight = tableHeight - offsetTop - scrollbarHeight;
+                if (offsetTop + trHeight > tableHeight - osbHeight) {
+                    trHeight = tableHeight - offsetTop - osbHeight;
                 }
                 rdLineEl.style.display = 'block';
-                rdLineEl.style.left = `${scrollbarYToLeft ? scrollbarWidth : 0}px`;
+                rdLineEl.style.left = `${scrollbarYToLeft ? osbWidth : 0}px`;
                 rdLineEl.style.top = `${offsetTop}px`;
                 rdLineEl.style.height = `${trHeight}px`;
-                rdLineEl.style.width = `${tableWidth - scrollbarWidth}px`;
+                rdLineEl.style.width = `${tableWidth - osbWidth}px`;
                 rdLineEl.setAttribute('drag-pos', dragPos);
                 rdLineEl.setAttribute('drag-to-child', prevDragToChild ? 'y' : 'n');
             }
@@ -1252,7 +1247,7 @@ function showDropTip($xeTable, evnt, trEl, thEl, showLine, dragPos) {
                     thWidth -= startX - offsetLeft;
                     offsetLeft = startX;
                 }
-                const endX = tableWidth - rightContainerWidth - (rightContainerWidth ? 0 : scrollbarWidth);
+                const endX = tableWidth - rightContainerWidth - (rightContainerWidth ? 0 : osbWidth);
                 if (offsetLeft + thWidth > endX) {
                     thWidth = endX - offsetLeft;
                 }
@@ -1264,7 +1259,7 @@ function showDropTip($xeTable, evnt, trEl, thEl, showLine, dragPos) {
                     cdLineEl.style.height = `${thRect.height}px`;
                 }
                 else {
-                    cdLineEl.style.height = `${tableHeight - offsetTop - (scrollbarXToTop ? 0 : scrollbarHeight)}px`;
+                    cdLineEl.style.height = `${tableHeight - offsetTop - (scrollbarXToTop ? 0 : osbHeight)}px`;
                 }
                 cdLineEl.setAttribute('drag-pos', dragPos);
                 cdLineEl.setAttribute('drag-to-child', prevDragToChild ? 'y' : 'n');
@@ -1296,6 +1291,41 @@ function hideDropTip($xeTable) {
         cdLineEl.style.display = '';
     }
 }
+/**
+ * 处理显示 tooltip
+ * @param {Event} evnt 事件
+ * @param {Row} row 行对象
+ */
+function handleTooltip($xeTable, evnt, tdEl, overflowElem, tipElem, params) {
+    const reactData = $xeTable;
+    if (!overflowElem) {
+        return $xeTable.$nextTick();
+    }
+    params.cell = tdEl;
+    const { tooltipStore } = reactData;
+    const tooltipOpts = $xeTable.computeTooltipOpts;
+    const { column, row } = params;
+    const { showAll, contentMethod } = tooltipOpts;
+    const customContent = contentMethod ? contentMethod(params) : null;
+    const useCustom = contentMethod && !XEUtils.eqNull(customContent);
+    const content = useCustom ? customContent : XEUtils.toString(column.type === 'html' ? overflowElem.innerText : overflowElem.textContent).trim();
+    const isCellOverflow = overflowElem.scrollWidth > overflowElem.clientWidth;
+    if (content && (showAll || useCustom || isCellOverflow)) {
+        Object.assign(tooltipStore, {
+            row,
+            column,
+            visible: true,
+            currOpts: {}
+        });
+        $xeTable.$nextTick(() => {
+            const $tooltip = $xeTable.$refs.refTooltip;
+            if ($tooltip && $tooltip.open) {
+                $tooltip.open(isCellOverflow ? overflowElem : (tipElem || overflowElem), formatText(content));
+            }
+        });
+    }
+    return $xeTable.$nextTick();
+}
 function handleScrollToRowColumn($xeTable, fieldOrColumn, row) {
     const internalData = $xeTable;
     const { fullColumnIdData } = internalData;
@@ -1583,11 +1613,10 @@ function handleColumn($xeTable, collectColumn) {
     internalData.collectColumn = collectColumn;
     const tableFullColumn = getColumnList(collectColumn);
     internalData.tableFullColumn = tableFullColumn;
-    reactData.isLoading = true;
+    reactData.isColLoading = true;
     reactData.isDragColMove = false;
     initColumnSort($xeTable);
     return Promise.resolve(restoreCustomStorage($xeTable)).then(() => {
-        reactData.isLoading = false;
         cacheColumnMap($xeTable);
         parseColumns($xeTable, true).then(() => {
             if (reactData.scrollXLoad) {
@@ -1612,6 +1641,7 @@ function handleColumn($xeTable, collectColumn) {
             if ($xeTable.handleUpdateCustomColumn) {
                 $xeTable.handleUpdateCustomColumn();
             }
+            reactData.isColLoading = false;
             return $xeTable.recalculate();
         });
     });
@@ -1619,16 +1649,14 @@ function handleColumn($xeTable, collectColumn) {
 /**
  * 纵向 Y 可视渲染处理
  */
-function loadScrollYData($xeTable) {
-    const props = $xeTable;
+function loadScrollYData($xeTable, scrollTop) {
     const reactData = $xeTable;
     const internalData = $xeTable;
-    const { showOverflow } = props;
-    const { mergeList } = reactData;
+    const { mergeList, isAllOverflow } = reactData;
     const { scrollYStore } = internalData;
     const { preloadSize, startIndex, endIndex, offsetSize } = scrollYStore;
-    const autoOffsetYSize = showOverflow ? offsetSize : offsetSize + 1;
-    const { toVisibleIndex, visibleSize } = handleVirtualYVisible($xeTable);
+    const autoOffsetYSize = isAllOverflow ? offsetSize : offsetSize + 1;
+    const { toVisibleIndex, visibleSize } = handleVirtualYVisible($xeTable, scrollTop);
     const offsetItem = {
         startIndex: Math.max(0, toVisibleIndex - 1 - offsetSize - preloadSize),
         endIndex: toVisibleIndex + visibleSize + autoOffsetYSize + preloadSize
@@ -1645,6 +1673,42 @@ function loadScrollYData($xeTable) {
         }
     }
 }
+function lazyScrollXData($xeTable) {
+    const internalData = $xeTable;
+    const { lxTimeout, lxRunTime, scrollXStore } = internalData;
+    const { visibleSize } = scrollXStore;
+    const fpsTime = Math.max(5, Math.min(10, Math.floor(visibleSize / 3)));
+    if (lxTimeout) {
+        clearTimeout(lxTimeout);
+    }
+    if (!lxRunTime || lxRunTime + fpsTime < Date.now()) {
+        internalData.lxRunTime = Date.now();
+        loadScrollXData($xeTable);
+    }
+    internalData.lxTimeout = setTimeout(() => {
+        internalData.lxTimeout = undefined;
+        internalData.lxRunTime = undefined;
+        loadScrollXData($xeTable);
+    }, fpsTime);
+}
+function lazyScrollYData($xeTable) {
+    const internalData = $xeTable;
+    const { lyTimeout, lyRunTime, scrollYStore } = internalData;
+    const { visibleSize } = scrollYStore;
+    const fpsTime = Math.floor(Math.max(4, Math.min(10, visibleSize / 3)));
+    if (lyTimeout) {
+        clearTimeout(lyTimeout);
+    }
+    if (!lyRunTime || lyRunTime + fpsTime < Date.now()) {
+        internalData.lyRunTime = Date.now();
+        loadScrollYData($xeTable);
+    }
+    internalData.lyTimeout = setTimeout(() => {
+        internalData.lyTimeout = undefined;
+        internalData.lyRunTime = undefined;
+        loadScrollYData($xeTable);
+    }, fpsTime);
+}
 function checkLastSyncScroll($xeTable, isRollX, isRollY) {
     const reactData = $xeTable;
     const internalData = $xeTable;
@@ -1656,6 +1720,7 @@ function checkLastSyncScroll($xeTable, isRollX, isRollY) {
     internalData.lcsTimeout = setTimeout(() => {
         internalData.lcsRunTime = Date.now();
         internalData.lcsTimeout = undefined;
+        internalData.intoRunScroll = false;
         internalData.inVirtualScroll = false;
         internalData.inWheelScroll = false;
         internalData.inHeaderScroll = false;
@@ -1675,6 +1740,48 @@ function checkLastSyncScroll($xeTable, isRollX, isRollY) {
         $xeTable.updateCellAreas();
     }, 200);
 }
+const getWheelSpeed = (lastScrollTime) => {
+    let multiple = 1;
+    const currTime = Date.now();
+    if (lastScrollTime + 25 > currTime) {
+        multiple = 1.18;
+    }
+    else if (lastScrollTime + 30 > currTime) {
+        multiple = 1.15;
+    }
+    else if (lastScrollTime + 40 > currTime) {
+        multiple = 1.12;
+    }
+    else if (lastScrollTime + 55 > currTime) {
+        multiple = 1.09;
+    }
+    else if (lastScrollTime + 75 > currTime) {
+        multiple = 1.06;
+    }
+    else if (lastScrollTime + 100 > currTime) {
+        multiple = 1.03;
+    }
+    return multiple;
+};
+const wheelScrollTo = (diffNum, cb) => {
+    const duration = Math.abs(diffNum);
+    const startTime = performance.now();
+    let countTop = 0;
+    const step = (timestamp) => {
+        let progress = (timestamp - startTime) / duration;
+        if (progress > 1) {
+            progress = 1;
+        }
+        const easedProgress = Math.pow(progress, 2);
+        const offsetTop = Math.floor((diffNum * easedProgress)) - countTop;
+        countTop += offsetTop;
+        cb(offsetTop);
+        if (progress < 1) {
+            requestAnimationFrame(step);
+        }
+    };
+    requestAnimationFrame(step);
+};
 function updateHeight($xeTable) {
     const internalData = $xeTable;
     internalData.customHeight = calcTableHeight($xeTable, 'height');
@@ -1682,58 +1789,60 @@ function updateHeight($xeTable) {
     internalData.customMaxHeight = calcTableHeight($xeTable, 'maxHeight');
 }
 function calcColumnAutoWidth(column, wrapperEl) {
-    const cellElList = wrapperEl.querySelectorAll(`.vxe-header--column.${column.id}>.vxe-cell,.vxe-body--column.${column.id}>.vxe-cell,.vxe-footer--column.${column.id}>.vxe-cell`);
-    const firstCellEl = cellElList[0];
-    let paddingSize = 0;
-    if (firstCellEl) {
-        const cellStyle = getComputedStyle(firstCellEl);
-        paddingSize = Math.floor(XEUtils.toNumber(cellStyle.paddingLeft) + XEUtils.toNumber(cellStyle.paddingRight)) + 2;
+    const cellElemList = wrapperEl.querySelectorAll(`.vxe-cell--wrapper[colid="${column.id}"]`);
+    let leftRightPadding = 0;
+    const firstCellEl = cellElemList[0];
+    if (firstCellEl && firstCellEl.parentElement) {
+        const cellStyle = getComputedStyle(firstCellEl.parentElement);
+        leftRightPadding = Math.ceil(XEUtils.toNumber(cellStyle.paddingLeft) + XEUtils.toNumber(cellStyle.paddingRight));
     }
-    let colWidth = column.renderAutoWidth - paddingSize;
-    XEUtils.arrayEach(cellElList, (itemEl) => {
-        const cellEl = itemEl;
-        const thElem = cellEl.parentElement;
-        let titleWidth = 0;
-        if (`${thElem.tagName}`.toLowerCase() === 'th') {
-            XEUtils.arrayEach(cellEl.children, (btnEl) => {
-                titleWidth += btnEl.offsetWidth + 1;
-            });
-        }
-        else {
-            const labelEl = cellEl.firstElementChild;
-            if (labelEl) {
-                titleWidth = labelEl.offsetWidth;
-            }
-        }
-        if (titleWidth) {
-            colWidth = Math.max(colWidth, Math.ceil(titleWidth) + 4);
-        }
-    });
-    return colWidth + paddingSize;
+    let colWidth = column.renderAutoWidth - leftRightPadding;
+    for (let i = 0; i < cellElemList.length; i++) {
+        const celEl = cellElemList[i];
+        colWidth = Math.max(colWidth, celEl ? Math.ceil(celEl.scrollWidth) + 4 : 0);
+    }
+    return colWidth + leftRightPadding;
 }
 function calcCellWidth($xeTable) {
-    const reactData = $xeTable;
     const internalData = $xeTable;
     const autoWidthColumnList = $xeTable.computeAutoWidthColumnList;
-    reactData.isCalcColumn = true;
-    return $xeTable.$nextTick().then(() => {
-        const { fullColumnIdData } = internalData;
-        const el = $xeTable.$refs.refElem;
-        if (el) {
-            autoWidthColumnList.forEach(column => {
-                const colid = column.id;
-                const colRest = fullColumnIdData[colid];
-                const colWidth = calcColumnAutoWidth(column, el);
-                if (colRest) {
-                    colRest.width = Math.max(colWidth, colRest.width);
-                }
-                column.renderAutoWidth = colWidth;
-            });
-            $xeTable.analyColumnWidth();
-        }
-        reactData.isCalcColumn = false;
-    });
+    const { fullColumnIdData } = internalData;
+    const el = $xeTable.$refs.refElem;
+    if (el) {
+        el.setAttribute('data-calc-col', 'Y');
+        autoWidthColumnList.forEach(column => {
+            const colid = column.id;
+            const colRest = fullColumnIdData[colid];
+            const colWidth = calcColumnAutoWidth(column, el);
+            if (colRest) {
+                colRest.width = Math.max(colWidth, colRest.width);
+            }
+            column.renderAutoWidth = colWidth;
+        });
+        $xeTable.analyColumnWidth();
+        el.removeAttribute('data-calc-col');
+    }
 }
+const handleUpdateColResize = ($xeTable, evnt, params) => {
+    $xeTable.analyColumnWidth();
+    $xeTable.recalculate(true).then(() => {
+        $xeTable.saveCustomStore('update:width');
+        $xeTable.updateCellAreas();
+        $xeTable.dispatchEvent('column-resizable-change', params, evnt);
+        // 已废弃 resizable-change
+        $xeTable.dispatchEvent('resizable-change', params, evnt);
+        setTimeout(() => $xeTable.recalculate(true), 300);
+    });
+};
+const handleUpdateRowResize = ($xeTable, evnt, params) => {
+    const reactData = $xeTable;
+    reactData.resizeHeightFlag++;
+    $xeTable.recalculate(true).then(() => {
+        $xeTable.updateCellAreas();
+        $xeTable.dispatchEvent('row-resizable-change', params, evnt);
+        setTimeout(() => $xeTable.recalculate(true), 300);
+    });
+};
 const Methods = {
     callSlot(slotFunc, params, h, vNodes) {
         if (slotFunc) {
@@ -1787,7 +1896,7 @@ const Methods = {
         warnLog('vxe.error.delFunc', ['syncData', 'getData']);
         return this.$nextTick().then(() => {
             this.tableData = [];
-            return this.$nextTick().then(() => this.loadTableData(this.tableFullData));
+            return this.$nextTick().then(() => this.loadTableData(this.tableFullData, true));
         });
     },
     /**
@@ -1841,11 +1950,12 @@ const Methods = {
      * 加载表格数据
      * @param {Array} datas 数据
      */
-    loadTableData(datas) {
+    loadTableData(datas, isReset) {
         const $xeTable = this;
-        const { keepSource, showOverflow, treeConfig, treeOpts, editStore, scrollYStore, scrollXStore, lastScrollLeft, lastScrollTop, scrollYLoad: oldScrollYLoad, sXOpts, sYOpts } = this;
+        const reactData = $xeTable;
+        const internalData = $xeTable;
+        const { keepSource, treeConfig, treeOpts, editStore, scrollYStore, scrollXStore, lastScrollLeft, lastScrollTop, scrollYLoad: oldScrollYLoad, sXOpts, sYOpts } = this;
         const childrenField = treeOpts.children || treeOpts.childrenField;
-        const rowOpts = $xeTable.computeRowOpts;
         let treeData = [];
         let fullData = datas ? datas.slice(0) : [];
         if (treeConfig) {
@@ -1889,42 +1999,30 @@ const Methods = {
         scrollYStore.endIndex = 1;
         scrollXStore.startIndex = 0;
         scrollXStore.endIndex = 1;
+        reactData.isRowLoading = true;
+        reactData.scrollVMLoading = false;
         editStore.insertMaps = {};
-        editStore.removeList = [];
         editStore.removeMaps = {};
         const sYLoad = updateScrollYStatus($xeTable, fullData);
-        this.isDragRowMove = false;
+        reactData.isDragColMove = false;
+        reactData.isDragRowMove = false;
         // 全量数据
-        this.tableFullData = fullData;
-        this.tableFullTreeData = treeData;
+        internalData.tableFullData = fullData;
+        internalData.tableFullTreeData = treeData;
         // 缓存数据
-        this.cacheRowMap(true);
+        $xeTable.cacheRowMap(true, isReset);
         // 原始数据
-        this.tableSynchData = datas;
+        internalData.tableSynchData = datas;
+        if (isReset) {
+            internalData.isResizeCellHeight = false;
+            reactData.rowExpandedMaps = {};
+            reactData.rowExpandLazyLoadedMaps = {};
+            reactData.treeExpandedMaps = {};
+            reactData.treeExpandLazyLoadedMaps = {};
+        }
         // 克隆原数据，用于显示编辑状态，与编辑值做对比
         if (keepSource) {
-            this.cacheSourceMap(fullData);
-        }
-        if (sYLoad) {
-            if (showOverflow) {
-                if (!rowOpts.height) {
-                    const errColumn = this.tableFullColumn.find((column) => column.showOverflow === false);
-                    if (errColumn) {
-                        errLog('vxe.error.errProp', [`column[field="${errColumn.field}"].show-overflow=false`, 'show-overflow=true']);
-                    }
-                }
-            }
-            if (process.env.NODE_ENV === 'development') {
-                if (!(this.height || this.maxHeight)) {
-                    errLog('vxe.error.reqProp', ['table.height | table.max-height | table.scroll-y={enabled: false}']);
-                }
-                // if (!this.showOverflow) {
-                //   warnLog('vxe.error.reqProp', ['table.show-overflow'])
-                // }
-                if (this.spanMethod) {
-                    warnLog('vxe.error.scrollErrProp', ['table.span-method']);
-                }
-            }
+            $xeTable.cacheSourceMap(fullData);
         }
         if (this.clearCellAreas && this.mouseConfig) {
             this.clearCellAreas();
@@ -1944,6 +2042,27 @@ const Methods = {
             if (sYLoad) {
                 scrollYStore.endIndex = scrollYStore.visibleSize;
             }
+            if (sYLoad) {
+                // if (showOverflow) {
+                //   if (!rowOpts.height) {
+                //     const errColumn = this.tableFullColumn.find((column: any) => column.showOverflow === false)
+                //     if (errColumn) {
+                //       errLog('vxe.error.errProp', [`column[field="${errColumn.field}"].show-overflow=false`, 'show-overflow=true'])
+                //     }
+                //   }
+                // }
+                if (process.env.NODE_ENV === 'development') {
+                    if (!(this.height || this.maxHeight)) {
+                        errLog('vxe.error.reqProp', ['table.height | table.max-height | table.scroll-y={enabled: false}']);
+                    }
+                    // if (!this.showOverflow) {
+                    //   warnLog('vxe.error.reqProp', ['table.show-overflow'])
+                    // }
+                    if (this.spanMethod) {
+                        warnLog('vxe.error.scrollErrProp', ['table.span-method']);
+                    }
+                }
+            }
             this.handleReserveStatus();
             this.checkSelectionStatus();
             return new Promise(resolve => {
@@ -1959,6 +2078,7 @@ const Methods = {
                     if (sYOpts.scrollToTopOnChange) {
                         targetScrollTop = 0;
                     }
+                    reactData.isRowLoading = false;
                     calcCellHeight($xeTable);
                     // 是否变更虚拟滚动
                     if (oldScrollYLoad === sYLoad) {
@@ -1985,7 +2105,7 @@ const Methods = {
      */
     loadData(datas) {
         const { initStatus } = this;
-        return this.loadTableData(datas).then(() => {
+        return this.loadTableData(datas, false).then(() => {
             this.inited = true;
             this.initStatus = true;
             if (!initStatus) {
@@ -2003,7 +2123,7 @@ const Methods = {
             .then(() => {
             this.inited = true;
             this.initStatus = true;
-            return this.loadTableData(datas);
+            return this.loadTableData(datas, true);
         })
             .then(() => {
             this.handleLoadDefaults();
@@ -2081,9 +2201,8 @@ const Methods = {
     },
     /**
      * 更新数据行的 Map
-     * 牺牲数据组装的耗时，用来换取使用过程中的流畅
      */
-    cacheRowMap(isSource) {
+    cacheRowMap(isReset, isSource) {
         const { treeConfig, treeOpts, tableFullData, fullAllDataRowIdData, tableFullTreeData } = this;
         const childrenField = treeOpts.children || treeOpts.childrenField;
         const hasChildField = treeOpts.hasChild || treeOpts.hasChildField;
@@ -2103,8 +2222,8 @@ const Methods = {
                 row[childrenField] = null;
             }
             let cacheItem = fullAllDataRowIdData[rowid];
-            if (!cacheItem) {
-                cacheItem = { row, rowid, seq, index: -1, _index: -1, $index: -1, treeIndex: index, items, parent: parentRow, level, height: 0, oTop: 0 };
+            if (isReset || !cacheItem) {
+                cacheItem = { row, rowid, seq, index: -1, _index: -1, $index: -1, treeIndex: index, items, parent: parentRow, level, height: 0, resizeHeight: 0, oTop: 0 };
             }
             cacheItem.row = row;
             cacheItem.items = items;
@@ -2178,7 +2297,7 @@ const Methods = {
             XEUtils.eachTree(rows, (childRow, index, items, path, parentItem, nodes) => {
                 const rowid = getRowid($xeTable, childRow);
                 const parentRow = parentItem || parentRest.row;
-                const rest = { row: childRow, rowid, seq: -1, index, _index: -1, $index: -1, treeIndex: -1, items, parent: parentRow, level: parentLevel + nodes.length, height: 0, oTop: 0 };
+                const rest = { row: childRow, rowid, seq: -1, index, _index: -1, $index: -1, treeIndex: -1, items, parent: parentRow, level: parentLevel + nodes.length, height: 0, resizeHeight: 0, oTop: 0 };
                 fullDataRowIdData[rowid] = rest;
                 fullAllDataRowIdData[rowid] = rest;
             }, { children: childrenField });
@@ -2534,18 +2653,37 @@ const Methods = {
         return this.$nextTick();
     },
     getCellElement(row, fieldOrColumn) {
-        const column = handleFieldOrColumn(this, fieldOrColumn);
+        const $xeTable = this;
+        const internalData = $xeTable;
+        const { elemStore } = internalData;
+        const column = handleFieldOrColumn($xeTable, fieldOrColumn);
         if (!column) {
             return null;
         }
-        const { $refs } = this;
-        const rowid = getRowid(this, row);
-        let bodyElem = null;
+        const rowid = getRowid($xeTable, row);
+        const bodyScrollElem = getRefElem(elemStore['main-body-scroll']);
+        const leftScrollElem = getRefElem(elemStore['left-body-scroll']);
+        const rightScrollElem = getRefElem(elemStore['right-body-scroll']);
+        let bodyElem;
         if (column) {
-            bodyElem = $refs[`${column.fixed || 'table'}Body`] || $refs.refTableBody;
-        }
-        if (bodyElem && bodyElem.$el) {
-            return bodyElem.$el.querySelector(`.vxe-body--row[rowid="${rowid}"] .${column.id}`);
+            if (column.fixed) {
+                if (column.fixed === 'left') {
+                    if (leftScrollElem) {
+                        bodyElem = leftScrollElem;
+                    }
+                }
+                else {
+                    if (rightScrollElem) {
+                        bodyElem = rightScrollElem;
+                    }
+                }
+            }
+            if (!bodyElem) {
+                bodyElem = bodyScrollElem;
+            }
+            if (bodyElem) {
+                return bodyElem.querySelector(`.vxe-body--row[rowid="${rowid}"] .${column.id}`);
+            }
         }
         return null;
     },
@@ -2948,7 +3086,9 @@ const Methods = {
      * @param {String/Number} rowid 行主键
      */
     getRowById(cellValue) {
-        const fullDataRowIdData = this.fullDataRowIdData;
+        const $xeTable = this;
+        const internalData = $xeTable;
+        const { fullDataRowIdData } = internalData;
         const rowid = XEUtils.eqNull(cellValue) ? '' : encodeURIComponent(cellValue);
         return fullDataRowIdData[rowid] ? fullDataRowIdData[rowid].row : null;
     },
@@ -2956,12 +3096,9 @@ const Methods = {
      * 根据行获取行的唯一主键
      * @param {Row} row 行对象
      */
-    getRowid(cellValue) {
+    getRowid(row) {
         const $xeTable = this;
-        const internalData = $xeTable;
-        const { fullDataRowIdData } = internalData;
-        const rowid = XEUtils.eqNull(cellValue) ? '' : encodeURIComponent(cellValue || '');
-        return fullDataRowIdData[rowid] ? fullDataRowIdData[rowid].row : null;
+        return getRowid($xeTable, row);
     },
     /**
      * 获取处理后的表格数据
@@ -3146,29 +3283,35 @@ const Methods = {
     },
     setColumnWidth(fieldOrColumn, width) {
         const $xeTable = this;
+        const internalData = $xeTable;
+        const { elemStore } = internalData;
         let status = false;
         const cols = XEUtils.isArray(fieldOrColumn) ? fieldOrColumn : [fieldOrColumn];
-        cols.forEach(item => {
-            const column = handleFieldOrColumn($xeTable, item);
-            if (column) {
-                const colWidth = XEUtils.toInteger(width);
-                let rdWidth = colWidth;
-                if (isScale(width)) {
-                    const refTableBody = $xeTable.$refs.refTableBody;
-                    const bodyElem = refTableBody ? refTableBody.$el : null;
-                    const bodyWidth = bodyElem ? bodyElem.clientWidth - 1 : 0;
-                    rdWidth = Math.floor(colWidth * bodyWidth);
-                }
-                column.resizeWidth = rdWidth;
-                if (!status) {
-                    status = true;
+        let cWidth = XEUtils.toInteger(width);
+        if (isScale(width)) {
+            const bodyScrollElem = getRefElem(elemStore['main-body-scroll']);
+            const bodyWidth = bodyScrollElem ? bodyScrollElem.clientWidth - 1 : 0;
+            cWidth = Math.floor(cWidth * bodyWidth);
+        }
+        if (cWidth) {
+            cols.forEach(item => {
+                const column = handleFieldOrColumn($xeTable, item);
+                if (column) {
+                    column.resizeWidth = cWidth;
+                    if (!status) {
+                        status = true;
+                    }
                 }
+            });
+            if (status) {
+                return $xeTable.refreshColumn().then(() => {
+                    return { status };
+                });
             }
-        });
-        if (status) {
-            return $xeTable.refreshColumn();
         }
-        return $xeTable.$nextTick();
+        return $xeTable.$nextTick().then(() => {
+            return { status };
+        });
     },
     getColumnWidth(fieldOrColumn) {
         const column = handleFieldOrColumn(this, fieldOrColumn);
@@ -3461,7 +3604,151 @@ const Methods = {
         });
         Object.assign(this.columnStore, { resizeList, pxList, pxMinList, autoMinList, scaleList, scaleMinList, autoList, remainList });
     },
-    handleResizeDblclickEvent(evnt, params) {
+    handleColResizeMousedownEvent(evnt, fixedType, params) {
+        const $xeTable = this;
+        const reactData = $xeTable;
+        const internalData = $xeTable;
+        evnt.stopPropagation();
+        evnt.preventDefault();
+        const { column } = params;
+        const { overflowX, scrollbarHeight } = reactData;
+        const { elemStore, visibleColumn } = internalData;
+        const resizableOpts = $xeTable.computeResizableOpts;
+        const osbHeight = overflowX ? scrollbarHeight : 0;
+        const tableEl = $xeTable.$refs.refElem;
+        const leftContainerElem = $xeTable.$refs.refLeftContainer;
+        const rightContainerElem = $xeTable.$refs.refRightContainer;
+        const resizeBarElem = $xeTable.$refs.refColResizeBar;
+        if (!resizeBarElem) {
+            return;
+        }
+        const resizeTipElem = resizeBarElem.firstElementChild;
+        const scrollbarXToTop = $xeTable.computeScrollbarXToTop;
+        const { clientX: dragClientX } = evnt;
+        const wrapperElem = $xeTable.$refs.refElem;
+        const dragBtnElem = evnt.target;
+        let resizeColumn = column;
+        if (column.children && column.children.length) {
+            XEUtils.eachTree(column.children, childColumn => {
+                resizeColumn = childColumn;
+            });
+        }
+        const cell = dragBtnElem.parentNode;
+        const cellParams = Object.assign(params, { cell });
+        let dragLeft = 0;
+        const bodyScrollElem = getRefElem(elemStore['main-body-scroll']);
+        if (!bodyScrollElem) {
+            return;
+        }
+        const pos = getOffsetPos(dragBtnElem, wrapperElem);
+        const dragBtnWidth = dragBtnElem.clientWidth;
+        const dragBtnOffsetWidth = Math.floor(dragBtnWidth / 2);
+        const minInterval = getColReMinWidth(cellParams) - dragBtnOffsetWidth; // 列之间的最小间距
+        let dragMinLeft = pos.left - cell.clientWidth + dragBtnWidth + minInterval;
+        let dragPosLeft = pos.left + dragBtnOffsetWidth;
+        const isLeftFixed = fixedType === 'left';
+        const isRightFixed = fixedType === 'right';
+        // 计算左右侧固定列偏移量
+        let fixedOffsetWidth = 0;
+        if (isLeftFixed || isRightFixed) {
+            const siblingProp = isLeftFixed ? 'nextElementSibling' : 'previousElementSibling';
+            let tempCellElem = cell[siblingProp];
+            while (tempCellElem) {
+                if (hasClass(tempCellElem, 'fixed--hidden')) {
+                    break;
+                }
+                else if (!hasClass(tempCellElem, 'col--group')) {
+                    fixedOffsetWidth += tempCellElem.offsetWidth;
+                }
+                tempCellElem = tempCellElem[siblingProp];
+            }
+            if (isRightFixed && rightContainerElem) {
+                dragPosLeft = rightContainerElem.offsetLeft + fixedOffsetWidth;
+            }
+        }
+        // 处理拖动事件
+        const updateEvent = (evnt) => {
+            evnt.stopPropagation();
+            evnt.preventDefault();
+            const tableHeight = tableEl.clientHeight;
+            const offsetX = evnt.clientX - dragClientX;
+            let left = dragPosLeft + offsetX;
+            const scrollLeft = fixedType ? 0 : bodyScrollElem.scrollLeft;
+            if (isLeftFixed) {
+                // 左固定列（不允许超过右侧固定列、不允许超过右边距）
+                left = Math.min(left, (rightContainerElem ? rightContainerElem.offsetLeft : bodyScrollElem.clientWidth) - fixedOffsetWidth - minInterval);
+            }
+            else if (isRightFixed) {
+                // 右侧固定列（不允许超过左侧固定列、不允许超过左边距）
+                dragMinLeft = (leftContainerElem ? leftContainerElem.clientWidth : 0) + fixedOffsetWidth + minInterval;
+                left = Math.min(left, dragPosLeft + cell.clientWidth - minInterval);
+            }
+            else {
+                dragMinLeft = Math.max(bodyScrollElem.scrollLeft, dragMinLeft);
+                // left = Math.min(left, bodyScrollElem.clientWidth + bodyScrollElem.scrollLeft - 40)
+            }
+            dragLeft = Math.max(left, dragMinLeft);
+            const resizeBarLeft = Math.max(1, dragLeft - scrollLeft);
+            resizeBarElem.style.left = `${resizeBarLeft}px`;
+            resizeBarElem.style.top = `${scrollbarXToTop ? osbHeight : 0}px`;
+            resizeBarElem.style.height = `${scrollbarXToTop ? tableHeight - osbHeight : tableHeight}px`;
+            if (resizableOpts.showDragTip && resizeTipElem) {
+                resizeTipElem.textContent = getI18n('vxe.table.resizeColTip', [resizeColumn.renderWidth + (isRightFixed ? dragPosLeft - dragLeft : dragLeft - dragPosLeft)]);
+                const tableWidth = tableEl.clientWidth;
+                const wrapperRect = wrapperElem.getBoundingClientRect();
+                const resizeBarWidth = resizeBarElem.clientWidth;
+                const resizeTipWidth = resizeTipElem.clientWidth;
+                const resizeTipHeight = resizeTipElem.clientHeight;
+                let resizeTipLeft = -resizeTipWidth;
+                if (resizeBarLeft < resizeTipWidth + resizeBarWidth) {
+                    resizeTipLeft = 0;
+                }
+                else if (resizeBarLeft > tableWidth) {
+                    resizeTipLeft += tableWidth - resizeBarLeft;
+                }
+                resizeTipElem.style.left = `${resizeTipLeft}px`;
+                resizeTipElem.style.top = `${Math.min(tableHeight - resizeTipHeight, Math.max(0, evnt.clientY - wrapperRect.y - resizeTipHeight / 2))}px`;
+            }
+            reactData.isDragResize = true;
+        };
+        reactData.isDragResize = true;
+        addClass(tableEl, 'col-drag--resize');
+        resizeBarElem.style.display = 'block';
+        document.onmousemove = updateEvent;
+        document.onmouseup = function (evnt) {
+            document.onmousemove = null;
+            document.onmouseup = null;
+            resizeBarElem.style.display = 'none';
+            internalData._lastResizeTime = Date.now();
+            setTimeout(() => {
+                reactData.isDragResize = false;
+            }, 50);
+            const resizeWidth = resizeColumn.renderWidth + (isRightFixed ? dragPosLeft - dragLeft : dragLeft - dragPosLeft);
+            const resizeParams = Object.assign(Object.assign({}, params), { resizeWidth, resizeColumn });
+            if (resizableOpts.dragMode === 'fixed') {
+                visibleColumn.forEach(item => {
+                    if (item.id !== resizeColumn.id) {
+                        if (!item.resizeWidth) {
+                            item.resizeWidth = item.renderWidth;
+                        }
+                    }
+                });
+            }
+            if ($xeTable.handleColResizeCellAreaEvent) {
+                $xeTable.handleColResizeCellAreaEvent(evnt, resizeParams);
+            }
+            else {
+                resizeColumn.resizeWidth = resizeWidth;
+                handleUpdateColResize($xeTable, evnt, resizeParams);
+            }
+            removeClass(tableEl, 'col-drag--resize');
+        };
+        updateEvent(evnt);
+        if ($xeTable.closeMenu) {
+            $xeTable.closeMenu();
+        }
+    },
+    handleColResizeDblclickEvent(evnt, params) {
         const $xeTable = this;
         const reactData = $xeTable;
         const internalData = $xeTable;
@@ -3469,6 +3756,8 @@ const Methods = {
         const { isDblclickAutoWidth } = resizableOpts;
         const el = $xeTable.$refs.refElem;
         if (isDblclickAutoWidth && el) {
+            evnt.stopPropagation();
+            evnt.preventDefault();
             const { fullColumnIdData } = internalData;
             const { column } = params;
             let resizeColumn = column;
@@ -3483,21 +3772,266 @@ const Methods = {
             const cell = dragBtnElem.parentNode;
             const cellParams = Object.assign(params, { cell });
             const colMinWidth = getColReMinWidth(cellParams);
+            el.setAttribute('data-calc-col', 'Y');
             let resizeWidth = calcColumnAutoWidth(resizeColumn, el);
+            el.removeAttribute('data-calc-col');
             if (colRest) {
                 resizeWidth = Math.max(resizeWidth, colRest.width);
             }
-            resizeColumn.resizeWidth = Math.max(colMinWidth, resizeWidth);
-            reactData._isResize = false;
+            resizeWidth = Math.max(colMinWidth, resizeWidth);
+            const resizeParams = Object.assign(Object.assign({}, params), { resizeWidth, resizeColumn });
+            reactData.isDragResize = false;
             internalData._lastResizeTime = Date.now();
-            $xeTable.analyColumnWidth();
-            $xeTable.recalculate(true).then(() => {
-                $xeTable.saveCustomStore('update:visible');
-                $xeTable.updateCellAreas();
-                $xeTable.dispatchEvent('resizable-change', Object.assign(Object.assign({}, params), { resizeWidth }), evnt);
-                setTimeout(() => $xeTable.recalculate(true), 300);
+            if ($xeTable.handleColResizeDblclickCellAreaEvent) {
+                $xeTable.handleColResizeDblclickCellAreaEvent(evnt, resizeParams);
+            }
+            else {
+                resizeColumn.resizeWidth = resizeWidth;
+                handleUpdateColResize($xeTable, evnt, resizeParams);
+            }
+        }
+    },
+    handleRowResizeMousedownEvent(evnt, params) {
+        const $xeTable = this;
+        const reactData = $xeTable;
+        const internalData = $xeTable;
+        evnt.stopPropagation();
+        evnt.preventDefault();
+        const { row } = params;
+        const { overflowX, scrollbarWidth, overflowY, scrollbarHeight } = reactData;
+        const { elemStore, fullAllDataRowIdData } = internalData;
+        const osbWidth = overflowY ? scrollbarWidth : 0;
+        const osbHeight = overflowX ? scrollbarHeight : 0;
+        const scrollbarYToLeft = $xeTable.computeScrollbarYToLeft;
+        const resizableOpts = $xeTable.computeResizableOpts;
+        const rowOpts = $xeTable.computeRowOpts;
+        const cellOpts = $xeTable.computeCellOpts;
+        const tableEl = $xeTable.$refs.refElem;
+        const resizeBarElem = $xeTable.$refs.refRowResizeBar;
+        if (!resizeBarElem) {
+            return;
+        }
+        const { clientY: dragClientY } = evnt;
+        const resizeTipElem = resizeBarElem.firstElementChild;
+        const dragBtnElem = evnt.currentTarget;
+        const tdEl = dragBtnElem.parentNode;
+        const trEl = tdEl.parentNode;
+        const bodyScrollElem = getRefElem(elemStore['main-body-scroll']);
+        if (!bodyScrollElem) {
+            return;
+        }
+        const rowid = getRowid($xeTable, row);
+        const rowRest = fullAllDataRowIdData[rowid];
+        if (!rowRest) {
+            return;
+        }
+        const defaultRowHeight = $xeTable.computeDefaultRowHeight;
+        const currCellHeight = rowRest.resizeHeight || cellOpts.height || rowOpts.height || defaultRowHeight;
+        const tableRect = tableEl.getBoundingClientRect();
+        const trRect = trEl.getBoundingClientRect();
+        const targetOffsetY = dragClientY - trRect.y - trEl.clientHeight;
+        let resizeHeight = currCellHeight;
+        const cellEl = tdEl.querySelector('.vxe-cell');
+        let cellMinHeight = 0;
+        if (cellEl) {
+            const cellStyle = getComputedStyle(cellEl);
+            cellMinHeight = Math.max(1, Math.ceil(XEUtils.toNumber(cellStyle.paddingTop) + XEUtils.toNumber(cellStyle.paddingBottom)));
+        }
+        const minTop = trRect.y - tableRect.y + cellMinHeight;
+        // 处理拖动事件
+        const updateEvent = (evnt) => {
+            evnt.stopPropagation();
+            evnt.preventDefault();
+            const tableWidth = tableEl.clientWidth - osbWidth;
+            const tableHeight = tableEl.clientHeight - osbHeight;
+            let dragTop = evnt.clientY - tableRect.y - targetOffsetY;
+            if (dragTop < minTop) {
+                dragTop = minTop;
+            }
+            else {
+                resizeHeight = Math.max(cellMinHeight, currCellHeight + evnt.clientY - dragClientY);
+            }
+            resizeBarElem.style.left = `${scrollbarYToLeft ? osbWidth : 0}px`;
+            resizeBarElem.style.top = `${dragTop}px`;
+            resizeBarElem.style.width = `${tableWidth}px`;
+            if (resizableOpts.showDragTip && resizeTipElem) {
+                resizeTipElem.textContent = getI18n('vxe.table.resizeRowTip', [resizeHeight]);
+                const resizeTipWidth = resizeTipElem.clientWidth;
+                const resizeTipHeight = resizeTipElem.clientHeight;
+                let resizeBarLeft = Math.max(2, evnt.clientX - tableRect.x);
+                let resizeBarTop = 0;
+                if (resizeBarLeft + resizeTipWidth >= tableWidth - 2) {
+                    resizeBarLeft = tableWidth - resizeTipWidth - 2;
+                }
+                if (dragTop + resizeTipHeight >= tableHeight) {
+                    resizeBarTop = tableHeight - (dragTop + resizeTipHeight);
+                }
+                resizeTipElem.style.left = `${resizeBarLeft}px`;
+                resizeTipElem.style.top = `${resizeBarTop}px`;
+            }
+            reactData.isDragResize = true;
+        };
+        reactData.isDragResize = true;
+        addClass(tableEl, 'row-drag--resize');
+        resizeBarElem.style.display = 'block';
+        document.onmousemove = updateEvent;
+        document.onmouseup = function (evnt) {
+            document.onmousemove = null;
+            document.onmouseup = null;
+            resizeBarElem.style.display = 'none';
+            internalData._lastResizeTime = Date.now();
+            setTimeout(() => {
+                reactData.isDragResize = false;
+            }, 50);
+            if (resizeHeight !== currCellHeight) {
+                const resizeParams = Object.assign(Object.assign({}, params), { resizeHeight, resizeRow: row });
+                internalData.isResizeCellHeight = true;
+                if ($xeTable.handleRowResizeCellAreaEvent) {
+                    $xeTable.handleRowResizeCellAreaEvent(evnt, resizeParams);
+                }
+                else {
+                    rowRest.resizeHeight = resizeHeight;
+                    handleUpdateRowResize($xeTable, evnt, resizeParams);
+                }
+            }
+            removeClass(tableEl, 'row-drag--resize');
+        };
+        updateEvent(evnt);
+    },
+    handleRowResizeDblclickEvent(evnt, params) {
+        const $xeTable = this;
+        const reactData = $xeTable;
+        const internalData = $xeTable;
+        const resizableOpts = $xeTable.computeResizableOpts;
+        const { isDblclickAutoHeight } = resizableOpts;
+        const el = $xeTable.$refs.refElem;
+        if (isDblclickAutoHeight && el) {
+            evnt.stopPropagation();
+            evnt.preventDefault();
+            const { editStore } = reactData;
+            const { fullAllDataRowIdData } = internalData;
+            const { actived } = editStore;
+            const { row } = params;
+            const rowid = getRowid($xeTable, row);
+            const rowRest = fullAllDataRowIdData[rowid];
+            if (!rowRest) {
+                return;
+            }
+            const handleRsHeight = () => {
+                const resizeHeight = calcCellAutoHeight(rowRest, el);
+                const resizeParams = Object.assign(Object.assign({}, params), { resizeHeight, resizeRow: row });
+                reactData.isDragResize = false;
+                internalData._lastResizeTime = Date.now();
+                if ($xeTable.handleRowResizeDblclickCellAreaEvent) {
+                    $xeTable.handleRowResizeDblclickCellAreaEvent(evnt, resizeParams);
+                }
+                else {
+                    rowRest.resizeHeight = resizeHeight;
+                    handleUpdateRowResize($xeTable, evnt, resizeParams);
+                }
+            };
+            if (actived.row || actived.column) {
+                $xeTable.clearEdit().then(handleRsHeight);
+            }
+            else {
+                handleRsHeight();
+            }
+        }
+    },
+    setRowHeightConf(heightConf) {
+        const $xeTable = this;
+        const reactData = $xeTable;
+        const internalData = $xeTable;
+        const { fullAllDataRowIdData } = internalData;
+        let status = false;
+        if (heightConf) {
+            XEUtils.each(heightConf, (height, rowid) => {
+                const rowRest = fullAllDataRowIdData[rowid];
+                if (rowRest) {
+                    const rHeight = XEUtils.toInteger(height);
+                    if (rHeight) {
+                        rowRest.resizeHeight = rHeight;
+                        if (!status) {
+                            status = true;
+                        }
+                    }
+                }
+            });
+            if (status) {
+                internalData.isResizeCellHeight = true;
+                reactData.resizeHeightFlag++;
+            }
+        }
+        return $xeTable.$nextTick().then(() => {
+            return { status };
+        });
+    },
+    getRowHeightConf(isFull) {
+        const $xeTable = this;
+        const internalData = $xeTable;
+        const { fullAllDataRowIdData, afterFullData } = internalData;
+        const rowOpts = $xeTable.computeRowOpts;
+        const cellOpts = $xeTable.computeCellOpts;
+        const defaultRowHeight = $xeTable.computeDefaultRowHeight;
+        const rest = {};
+        afterFullData.forEach(row => {
+            const rowid = getRowid($xeTable, row);
+            const rowRest = fullAllDataRowIdData[rowid];
+            if (rowRest) {
+                const resizeHeight = rowRest.resizeHeight;
+                if (resizeHeight || isFull) {
+                    const currCellHeight = resizeHeight || rowRest.height || cellOpts.height || rowOpts.height || defaultRowHeight;
+                    rest[rowid] = currCellHeight;
+                }
+            }
+        });
+        return rest;
+    },
+    setRowHeight(rowOrId, height) {
+        const $xeTable = this;
+        const reactData = $xeTable;
+        const internalData = $xeTable;
+        const { fullAllDataRowIdData } = internalData;
+        let status = false;
+        const rows = XEUtils.isArray(rowOrId) ? rowOrId : [rowOrId];
+        let rHeight = XEUtils.toInteger(height);
+        if (isScale(height)) {
+            const tableBody = $xeTable.$refs.refTableBody;
+            const bodyElem = tableBody ? tableBody.$el : null;
+            const bodyHeight = bodyElem ? bodyElem.clientHeight - 1 : 0;
+            rHeight = Math.floor(rHeight * bodyHeight);
+        }
+        if (rHeight) {
+            rows.forEach(row => {
+                const rowid = XEUtils.isString(row) || XEUtils.isNumber(row) ? row : getRowid($xeTable, row);
+                const rowRest = fullAllDataRowIdData[rowid];
+                if (rowRest) {
+                    rowRest.resizeHeight = rHeight;
+                    if (!status) {
+                        status = true;
+                    }
+                }
             });
+            if (status) {
+                internalData.isResizeCellHeight = true;
+                reactData.resizeHeightFlag++;
+            }
+        }
+        return $xeTable.$nextTick();
+    },
+    getRowHeight(rowOrId) {
+        const $xeTable = this;
+        const internalData = $xeTable;
+        const { fullAllDataRowIdData } = internalData;
+        const rowOpts = $xeTable.computeRowOpts;
+        const cellOpts = $xeTable.computeCellOpts;
+        const defaultRowHeight = $xeTable.computeDefaultRowHeight;
+        const rowid = XEUtils.isString(rowOrId) || XEUtils.isNumber(rowOrId) ? rowOrId : getRowid($xeTable, rowOrId);
+        const rowRest = fullAllDataRowIdData[rowid];
+        if (rowRest) {
+            return rowRest.resizeHeight || rowRest.height || cellOpts.height || rowOpts.height || defaultRowHeight;
         }
+        return 0;
     },
     /**
      * 刷新滚动操作，手动同步滚动相关位置（对于某些特殊的操作，比如滚动条错位、固定列不同步）
@@ -3878,10 +4412,10 @@ const Methods = {
                 }
                 else if (isContextMenu) {
                     // 如果按下上下文键
-                    this._keyCtx = selected.row && selected.column && bodyCtxMenu.length;
+                    internalData._keyCtx = selected.row && selected.column && bodyCtxMenu.length;
                     clearTimeout(internalData.keyCtxTimeout);
                     internalData.keyCtxTimeout = setTimeout(() => {
-                        this._keyCtx = false;
+                        internalData._keyCtx = false;
                     }, 1000);
                 }
                 else if (isEnter && !hasAltKey && keyboardConfig && keyboardOpts.isEnter && (selected.row || actived.row || (treeConfig && (rowOpts.isCurrent || highlightCurrentRow) && currentRow))) {
@@ -4130,50 +4664,42 @@ const Methods = {
         this.updateCellAreas();
         this.recalculate(true);
     },
-    handleTargetEnterEvent(isClear) {
-        const $tooltip = this.$refs.tooltip;
-        clearTimeout(this.tooltipTimeout);
-        if (isClear) {
-            this.closeTooltip();
-        }
-        else {
-            if ($tooltip) {
-                $tooltip.setActived(true);
-            }
-        }
-    },
     handleTargetLeaveEvent() {
-        const tooltipOpts = this.tooltipOpts;
-        let $tooltip = this.$refs.tooltip;
-        if ($tooltip) {
+        const $xeTable = this;
+        const internalData = $xeTable;
+        const tooltipOpts = $xeTable.computeTooltipOpts;
+        let $tooltip = $xeTable.$refs.refTooltip;
+        if ($tooltip && $tooltip.setActived) {
             $tooltip.setActived(false);
         }
         if (tooltipOpts.enterable) {
-            this.tooltipTimeout = setTimeout(() => {
-                $tooltip = this.$refs.tooltip;
-                if ($tooltip && !$tooltip.isActived()) {
-                    this.closeTooltip();
+            internalData.tooltipTimeout = setTimeout(() => {
+                $tooltip = $xeTable.$refs.refTooltip;
+                if ($tooltip && $tooltip.isActived && !$tooltip.isActived()) {
+                    $xeTable.closeTooltip();
                 }
             }, tooltipOpts.leaveDelay);
         }
         else {
-            this.closeTooltip();
+            $xeTable.closeTooltip();
         }
     },
     triggerHeaderTitleEvent(evnt, iconParams, params) {
+        const $xeTable = this;
+        const reactData = $xeTable;
         const tipContent = iconParams.content || iconParams.message;
         if (tipContent) {
-            const { $refs, tooltipStore } = this;
+            const { tooltipStore } = reactData;
             const { column } = params;
             const content = getFuncText(tipContent);
-            this.handleTargetEnterEvent(true);
+            handleTargetEnterEvent($xeTable, true);
             tooltipStore.row = null;
             tooltipStore.column = column;
             tooltipStore.visible = true;
             tooltipStore.currOpts = iconParams;
-            this.$nextTick(() => {
-                const $tooltip = $refs.tooltip;
-                if ($tooltip) {
+            $xeTable.$nextTick(() => {
+                const $tooltip = $xeTable.$refs.refTooltip;
+                if ($tooltip && $tooltip.open) {
                     $tooltip.open(evnt.currentTarget, content);
                 }
             });
@@ -4183,23 +4709,42 @@ const Methods = {
      * 触发表头 tooltip 事件
      */
     triggerHeaderTooltipEvent(evnt, params) {
-        const { tooltipStore } = this;
+        const $xeTable = this;
+        const reactData = $xeTable;
+        const { tooltipStore } = reactData;
         const { column } = params;
+        handleTargetEnterEvent($xeTable, true);
         const titleElem = evnt.currentTarget;
-        this.handleTargetEnterEvent(tooltipStore.column !== column || tooltipStore.row);
+        if (!titleElem) {
+            return;
+        }
+        const cellEl = titleElem.parentElement;
+        if (!cellEl) {
+            return;
+        }
+        const thEl = cellEl.parentElement;
+        if (!thEl) {
+            return;
+        }
         if (tooltipStore.column !== column || !tooltipStore.visible) {
-            this.handleTooltip(evnt, titleElem, titleElem, null, params);
+            handleTooltip($xeTable, evnt, thEl, cellEl, null, params);
         }
     },
     /**
      * 触发单元格 tooltip 事件
      */
     triggerBodyTooltipEvent(evnt, params) {
-        const { editConfig, editOpts, editStore, tooltipStore } = this;
+        const $xeTable = this;
+        const props = $xeTable;
+        const reactData = $xeTable;
+        const { editConfig } = props;
+        const { editStore } = reactData;
+        const { tooltipStore } = reactData;
+        const editOpts = $xeTable.computeEditOpts;
         const { actived } = editStore;
         const { row, column } = params;
-        const cell = evnt.currentTarget;
-        this.handleTargetEnterEvent(tooltipStore.column !== column || tooltipStore.row !== row);
+        const tdEl = evnt.currentTarget;
+        handleTargetEnterEvent($xeTable, tooltipStore.column !== column || tooltipStore.row !== row);
         // 单元格处于编辑状态时不触发提示框
         if (column.editRender && isEnableConf(editConfig)) {
             // 如果是行编辑模式
@@ -4212,67 +4757,23 @@ const Methods = {
             }
         }
         if (tooltipStore.column !== column || tooltipStore.row !== row || !tooltipStore.visible) {
-            let overflowElem;
-            let tipElem;
-            if (column.treeNode) {
-                overflowElem = cell.querySelector('.vxe-tree-cell');
-                if (column.type === 'html') {
-                    tipElem = cell.querySelector('.vxe-cell--html');
-                }
-            }
-            else {
-                tipElem = cell.querySelector(column.type === 'html' ? '.vxe-cell--html' : '.vxe-cell--label');
-            }
-            this.handleTooltip(evnt, cell, overflowElem || cell.children[0], tipElem, params);
+            handleTooltip($xeTable, evnt, tdEl, tdEl.querySelector('.vxe-cell--wrapper'), null, params);
         }
     },
     /**
      * 触发表尾 tooltip 事件
      */
     triggerFooterTooltipEvent(evnt, params) {
+        const $xeTable = this;
+        const reactData = $xeTable;
         const { column } = params;
-        const { tooltipStore } = this;
+        const { tooltipStore } = reactData;
         const cell = evnt.currentTarget;
-        this.handleTargetEnterEvent(true);
+        handleTargetEnterEvent($xeTable, tooltipStore.column !== column || !!tooltipStore.row);
         if (tooltipStore.column !== column || !tooltipStore.visible) {
-            this.handleTooltip(evnt, cell, cell.querySelector('.vxe-cell--item') || cell.children[0], null, params);
+            handleTooltip($xeTable, evnt, cell, cell.querySelector('.vxe-cell--wrapper') || cell.children[0], null, params);
         }
     },
-    /**
-     * 处理显示 tooltip
-     * @param {Event} evnt 事件
-     * @param {ColumnInfo} column 列配置
-     * @param {Row} row 行对象
-     */
-    handleTooltip(evnt, cell, overflowElem, tipElem, params) {
-        const $xeTable = this;
-        if (!overflowElem) {
-            return $xeTable.$nextTick();
-        }
-        params.cell = cell;
-        const { $refs, tooltipOpts, tooltipStore } = this;
-        const { column, row } = params;
-        const { showAll, enabled, contentMethod } = tooltipOpts;
-        const customContent = contentMethod ? contentMethod(params) : null;
-        const useCustom = contentMethod && !XEUtils.eqNull(customContent);
-        const content = useCustom ? customContent : (column.type === 'html' ? overflowElem.innerText : overflowElem.textContent).trim();
-        const isCellOverflow = overflowElem.scrollWidth > overflowElem.clientWidth;
-        if (content && (showAll || enabled || useCustom || isCellOverflow)) {
-            Object.assign(tooltipStore, {
-                row,
-                column,
-                visible: true,
-                currOpts: {}
-            });
-            this.$nextTick(() => {
-                const $tooltip = $refs.tooltip;
-                if ($tooltip) {
-                    $tooltip.open(isCellOverflow ? overflowElem : (tipElem || overflowElem), formatText(content));
-                }
-            });
-        }
-        return this.$nextTick();
-    },
     openTooltip(target, content) {
         const { $refs } = this;
         const commTip = $refs.refCommTooltip;
@@ -4285,9 +4786,11 @@ const Methods = {
      * 关闭 tooltip
      */
     closeTooltip() {
-        const { $refs, tooltipStore } = this;
-        const tooltip = $refs.tooltip;
-        const commTip = $refs.refCommTooltip;
+        const $xeTable = this;
+        const reactData = $xeTable;
+        const { tooltipStore } = reactData;
+        const tooltip = $xeTable.$refs.refTooltip;
+        const commTip = $xeTable.$refs.refCommTooltip;
         if (tooltipStore.visible) {
             Object.assign(tooltipStore, {
                 row: null,
@@ -5289,20 +5792,24 @@ const Methods = {
         this.hoverRow = null;
     },
     triggerHeaderCellClickEvent(evnt, params) {
-        const { _lastResizeTime, sortOpts } = this;
+        const $xeTable = this;
+        const internalData = $xeTable;
+        const { _lastResizeTime } = internalData;
+        const sortOpts = $xeTable.computeSortOpts;
+        const columnOpts = $xeTable.computeColumnOpts;
         const { column } = params;
         const cell = evnt.currentTarget;
         const triggerResizable = _lastResizeTime && _lastResizeTime > Date.now() - 300;
         const triggerSort = getEventTargetNode(evnt, cell, 'vxe-cell--sort').flag;
         const triggerFilter = getEventTargetNode(evnt, cell, 'vxe-cell--filter').flag;
         if (sortOpts.trigger === 'cell' && !(triggerResizable || triggerSort || triggerFilter)) {
-            this.triggerSortEvent(evnt, column, getNextSortOrder(this, column));
+            $xeTable.triggerSortEvent(evnt, column, getNextSortOrder($xeTable, column));
         }
-        this.emitEvent('header-cell-click', Object.assign({ triggerResizable, triggerSort, triggerFilter, cell }, params), evnt);
-        if (this.columnOpts.isCurrent || this.highlightCurrentColumn) {
-            this.triggerCurrentColumnEvent(evnt, params);
+        $xeTable.dispatchEvent('header-cell-click', Object.assign({ triggerResizable, triggerSort, triggerFilter, cell }, params), evnt);
+        if (columnOpts.isCurrent || $xeTable.highlightCurrentColumn) {
+            $xeTable.triggerCurrentColumnEvent(evnt, params);
         }
-        return this.$nextTick();
+        return $xeTable.$nextTick();
     },
     triggerHeaderCellDblclickEvent(evnt, params) {
         this.emitEvent('header-cell-dblclick', Object.assign({ cell: evnt.currentTarget }, params), evnt);
@@ -5356,7 +5863,20 @@ const Methods = {
      */
     triggerCellClickEvent(evnt, params) {
         const $xeTable = this;
-        const { highlightCurrentRow, editStore, radioOpts, expandOpts, treeOpts, keyboardOpts, editConfig, editOpts, checkboxOpts, rowOpts } = this;
+        const props = $xeTable;
+        const reactData = $xeTable;
+        const { highlightCurrentRow, editConfig } = props;
+        const { editStore, isDragResize } = reactData;
+        if (isDragResize) {
+            return;
+        }
+        const expandOpts = $xeTable.computeExpandOpts;
+        const editOpts = $xeTable.computeEditOpts;
+        const treeOpts = $xeTable.computeTreeOpts;
+        const radioOpts = $xeTable.computeRadioOpts;
+        const checkboxOpts = $xeTable.computeCheckboxOpts;
+        const keyboardOpts = $xeTable.computeKeyboardOpts;
+        const rowOpts = $xeTable.computeRowOpts;
         const { actived, focused } = editStore;
         const { row, column } = params;
         const { type, treeNode } = column;
@@ -5443,7 +5963,15 @@ const Methods = {
      * 如果是双击模式，则激活为编辑状态
      */
     triggerCellDblclickEvent(evnt, params) {
-        const { editStore, editConfig, editOpts } = this;
+        const $xeTable = this;
+        const props = $xeTable;
+        const reactData = $xeTable;
+        const { editConfig } = props;
+        const { editStore, isDragResize } = reactData;
+        if (isDragResize) {
+            return;
+        }
+        const editOpts = $xeTable.computeEditOpts;
         const { actived } = editStore;
         const cell = evnt.currentTarget;
         params = Object.assign({ cell }, params);
@@ -5512,10 +6040,13 @@ const Methods = {
     triggerSortEvent(evnt, column, order) {
         const $xeTable = this;
         const sortOpts = $xeTable.computeSortOpts;
+        const { multiple, allowClear } = sortOpts;
         const { field, sortable, remoteSort } = column;
         if (sortable || remoteSort) {
             if (!order || column.order === order) {
-                $xeTable.clearSort(sortOpts.multiple ? column : null);
+                if (allowClear) {
+                    $xeTable.clearSort(multiple ? column : null);
+                }
             }
             else {
                 $xeTable.sort({ field, order });
@@ -5616,7 +6147,7 @@ const Methods = {
         const { treeConfig, dragConfig } = props;
         const rowDragOpts = $xeTable.computeRowDragOpts;
         const { fullAllDataRowIdData } = internalData;
-        const { isPeerDrag, isCrossDrag, isSelfToChildDrag, dragEndMethod } = rowDragOpts;
+        const { isPeerDrag, isCrossDrag, isSelfToChildDrag, dragEndMethod, dragToChildMethod } = rowDragOpts;
         const treeOpts = $xeTable.computeTreeOpts;
         const { transform, rowField, mapChildrenField, parentField } = treeOpts;
         const childrenField = treeOpts.children || treeOpts.childrenField;
@@ -5626,15 +6157,15 @@ const Methods = {
         if (prevDragRow && dragRow) {
             // 判断是否有拖动
             if (prevDragRow !== dragRow) {
-                return Promise.resolve(dEndMethod
-                    ? dEndMethod({
-                        oldRow: dragRow,
-                        newRow: prevDragRow,
-                        dragPos: prevDragPos,
-                        dragToChild: !!prevDragToChild,
-                        offsetIndex: dragOffsetIndex
-                    })
-                    : true).then((status) => {
+                const dragParams = {
+                    oldRow: dragRow,
+                    newRow: prevDragRow,
+                    dragPos: prevDragPos,
+                    dragToChild: !!prevDragToChild,
+                    offsetIndex: dragOffsetIndex
+                };
+                const isDragToChildFlag = isSelfToChildDrag && dragToChildMethod ? dragToChildMethod(dragParams) : prevDragToChild;
+                return Promise.resolve(dEndMethod ? dEndMethod(dragParams) : true).then((status) => {
                     if (!status) {
                         return;
                     }
@@ -5709,7 +6240,11 @@ const Methods = {
                                 else {
                                     // 根到根
                                 }
-                                const fullList = XEUtils.toTreeArray(internalData.afterTreeFullData, { children: childrenField });
+                                const fullList = XEUtils.toTreeArray(internalData.afterTreeFullData, {
+                                    key: rowField,
+                                    parentKey: parentField,
+                                    children: mapChildrenField
+                                });
                                 // 移出
                                 const otfIndex = $xeTable.findRowIndexOf(fullList, dragRow);
                                 fullList.splice(otfIndex, 1);
@@ -5723,12 +6258,12 @@ const Methods = {
                                         childRow[parentField] = dragRow[parentField];
                                     });
                                 }
-                                dragRow[parentField] = prevDragToChild ? prevDragRow[rowField] : prevDragRow[parentField];
+                                dragRow[parentField] = isDragToChildFlag ? prevDragRow[rowField] : prevDragRow[parentField];
                                 internalData.tableFullTreeData = XEUtils.toArrayTree(fullList, {
-                                    key: treeOpts.rowField,
-                                    parentKey: treeOpts.parentField,
+                                    key: rowField,
+                                    parentKey: parentField,
                                     children: childrenField,
-                                    mapChildren: treeOpts.mapChildrenField
+                                    mapChildren: mapChildrenField
                                 });
                             }
                         }
@@ -5749,7 +6284,7 @@ const Methods = {
                     }
                     reactData.isDragRowMove = true;
                     $xeTable.handleTableData(treeConfig && transform);
-                    $xeTable.cacheRowMap();
+                    $xeTable.cacheRowMap(false);
                     updateScrollYStatus($xeTable);
                     if (!(treeConfig && transform)) {
                         updateAfterDataIndex($xeTable);
@@ -5766,7 +6301,7 @@ const Methods = {
                         oldRow: dragRow,
                         newRow: prevDragRow,
                         dragPos: prevDragPos,
-                        dragToChild: !!prevDragToChild,
+                        dragToChild: isDragToChildFlag,
                         offsetIndex: dragOffsetIndex,
                         _index: {
                             newIndex: nafIndex,
@@ -5791,20 +6326,18 @@ const Methods = {
         const { lazy } = treeOpts;
         const hasChildField = treeOpts.hasChild || treeOpts.hasChildField;
         const { prevDragRow, prevDragPos } = internalData;
-        if (treeConfig && prevDragToChild) {
+        if (treeConfig && lazy && prevDragToChild) {
             // 懒加载
-            if (lazy) {
-                const newRowid = getRowid($xeTable, prevDragRow);
-                const rowRest = fullAllDataRowIdData[newRowid];
-                if (prevDragRow[hasChildField]) {
-                    if (rowRest && rowRest.treeLoaded) {
-                        $xeTable.handleRowDragSwapEvent(evnt, true, dragRow, prevDragRow, prevDragPos, prevDragToChild);
-                    }
-                }
-                else {
+            const newRowid = getRowid($xeTable, prevDragRow);
+            const rowRest = fullAllDataRowIdData[newRowid];
+            if (prevDragRow[hasChildField]) {
+                if (rowRest && rowRest.treeLoaded) {
                     $xeTable.handleRowDragSwapEvent(evnt, true, dragRow, prevDragRow, prevDragPos, prevDragToChild);
                 }
             }
+            else {
+                $xeTable.handleRowDragSwapEvent(evnt, true, dragRow, prevDragRow, prevDragPos, prevDragToChild);
+            }
         }
         else {
             $xeTable.handleRowDragSwapEvent(evnt, true, dragRow, prevDragRow, prevDragPos, prevDragToChild);
@@ -5921,7 +6454,7 @@ const Methods = {
         const internalData = $xeTable;
         const { mouseConfig } = props;
         const columnDragOpts = $xeTable.computeColumnDragOpts;
-        const { isPeerDrag, isCrossDrag, isSelfToChildDrag, isToChildDrag, dragEndMethod } = columnDragOpts;
+        const { isPeerDrag, isCrossDrag, isSelfToChildDrag, isToChildDrag, dragEndMethod, dragToChildMethod } = columnDragOpts;
         const { collectColumn } = internalData;
         const dragOffsetIndex = prevDragPos === 'right' ? 1 : 0;
         if (prevDragCol && dragCol) {
@@ -5929,15 +6462,15 @@ const Methods = {
             if (prevDragCol !== dragCol) {
                 const oldColumn = dragCol;
                 const newColumn = prevDragCol;
-                return Promise.resolve(dragEndMethod
-                    ? dragEndMethod({
-                        oldColumn,
-                        newColumn,
-                        dragPos: prevDragPos,
-                        dragToChild: !!prevDragToChild,
-                        offsetIndex: dragOffsetIndex
-                    })
-                    : true).then((status) => {
+                const dragParams = {
+                    oldColumn,
+                    newColumn,
+                    dragPos: prevDragPos,
+                    dragToChild: !!prevDragToChild,
+                    offsetIndex: dragOffsetIndex
+                };
+                const isDragToChildFlag = isSelfToChildDrag && dragToChildMethod ? dragToChildMethod(dragParams) : prevDragToChild;
+                return Promise.resolve(dragEndMethod ? dragEndMethod(dragParams) : true).then((status) => {
                     if (!status) {
                         return;
                     }
@@ -6027,7 +6560,7 @@ const Methods = {
                     if (newMatchRest) {
                         const { items: nCols, index: nIndex, parent: nParent } = newMatchRest;
                         // 转子级
-                        if ((isCrossDrag && isToChildDrag) && prevDragToChild) {
+                        if ((isCrossDrag && isToChildDrag) && isDragToChildFlag) {
                             oldColumn.parentId = newColumn.id;
                             newColumn.children = (newColumn.children || []).concat([oldColumn]);
                         }
@@ -6059,7 +6592,7 @@ const Methods = {
                         oldColumn,
                         newColumn,
                         dragPos: prevDragPos,
-                        dragToChild: !!prevDragToChild,
+                        dragToChild: isDragToChildFlag,
                         offsetIndex: dragOffsetIndex,
                         _index: {
                             newIndex: nafIndex,
@@ -7084,13 +7617,17 @@ const Methods = {
      * 获取表格的滚动状态
      */
     getScroll() {
-        const { $refs, scrollXLoad, scrollYLoad } = this;
-        const bodyElem = $refs.refTableBody.$el;
+        const $xeTable = this;
+        const reactData = $xeTable;
+        const internalData = $xeTable;
+        const { scrollXLoad, scrollYLoad } = reactData;
+        const { elemStore } = internalData;
+        const bodyScrollElem = getRefElem(elemStore['main-body-scroll']);
         return {
             virtualX: scrollXLoad,
             virtualY: scrollYLoad,
-            scrollTop: bodyElem.scrollTop,
-            scrollLeft: bodyElem.scrollLeft
+            scrollTop: bodyScrollElem ? bodyScrollElem.scrollTop : 0,
+            scrollLeft: bodyScrollElem ? bodyScrollElem.scrollLeft : 0
         };
     },
     handleScrollEvent(evnt, isRollY, isRollX, scrollTop, scrollLeft, params) {
@@ -7190,46 +7727,6 @@ const Methods = {
         }
         $xeTable.dispatchEvent('scroll', evntParams, evnt);
     },
-    lazyScrollXData() {
-        const $xeTable = this;
-        const internalData = $xeTable;
-        const { lxTimeout, lxRunTime, scrollXStore } = internalData;
-        const { visibleSize } = scrollXStore;
-        const fpsTime = Math.max(5, Math.min(80, Math.floor(visibleSize * 3)));
-        if (lxTimeout) {
-            clearTimeout(lxTimeout);
-        }
-        if (!lxRunTime || lxRunTime + fpsTime < Date.now()) {
-            internalData.lxRunTime = Date.now();
-            loadScrollXData($xeTable);
-        }
-        internalData.lxTimeout = setTimeout(() => {
-            internalData.lxTimeout = undefined;
-            internalData.lxRunTime = undefined;
-            loadScrollXData($xeTable);
-        }, fpsTime);
-    },
-    lazyScrollYData() {
-        const $xeTable = this;
-        const props = $xeTable;
-        const internalData = $xeTable;
-        const { showOverflow } = props;
-        const { lyTimeout, lyRunTime, scrollYStore } = internalData;
-        const { visibleSize } = scrollYStore;
-        const fpsTime = showOverflow ? 5 : Math.max(5, Math.min(80, Math.floor(visibleSize / 2)));
-        if (lyTimeout) {
-            clearTimeout(lyTimeout);
-        }
-        if (!lyRunTime || lyRunTime + fpsTime < Date.now()) {
-            internalData.lyRunTime = Date.now();
-            loadScrollYData($xeTable);
-        }
-        internalData.lyTimeout = setTimeout(() => {
-            internalData.lyTimeout = undefined;
-            internalData.lyRunTime = undefined;
-            loadScrollYData($xeTable);
-        }, fpsTime);
-    },
     /**
      * 横向 X 可视渲染事件处理
      */
@@ -7240,7 +7737,7 @@ const Methods = {
             loadScrollXData($xeTable);
         }
         else {
-            $xeTable.lazyScrollXData();
+            lazyScrollXData($xeTable);
         }
     },
     /**
@@ -7253,13 +7750,13 @@ const Methods = {
             loadScrollYData($xeTable);
         }
         else {
-            $xeTable.lazyScrollYData();
+            lazyScrollYData($xeTable);
         }
     },
     triggerBodyScrollEvent(evnt, fixedType) {
         const $xeTable = this;
         const internalData = $xeTable;
-        const { elemStore, lastScrollTop, lastScrollLeft, inWheelScroll, inVirtualScroll, inHeaderScroll, inBodyScroll, scrollRenderType, inFooterScroll } = internalData;
+        const { elemStore, intoRunScroll, lastScrollTop, lastScrollLeft, inWheelScroll, inVirtualScroll, inHeaderScroll, inBodyScroll, scrollRenderType, inFooterScroll } = internalData;
         const xHandleEl = $xeTable.$refs.refScrollXHandleElem;
         const yHandleEl = $xeTable.$refs.refScrollYHandleElem;
         const leftScrollElem = getRefElem(elemStore['left-body-scroll']);
@@ -7270,6 +7767,9 @@ const Methods = {
         if (inWheelScroll || inVirtualScroll || inHeaderScroll || inFooterScroll) {
             return;
         }
+        if (intoRunScroll) {
+            return;
+        }
         if (!bodyScrollElem) {
             return;
         }
@@ -7330,22 +7830,16 @@ const Methods = {
     triggerHeaderScrollEvent(evnt, fixedType) {
         const $xeTable = this;
         const internalData = $xeTable;
-        const { elemStore, inWheelScroll, inVirtualScroll, inBodyScroll, inFooterScroll } = internalData;
+        const { elemStore, intoRunScroll, inWheelScroll, inVirtualScroll, inBodyScroll, inFooterScroll } = internalData;
         const xHandleEl = $xeTable.$refs.refScrollXHandleElem;
         const yHandleEl = $xeTable.$refs.refScrollYHandleElem;
         const bodyScrollElem = getRefElem(elemStore['main-body-scroll']);
         const headerScrollElem = getRefElem(elemStore['main-header-scroll']);
         const footerScrollElem = getRefElem(elemStore['main-footer-scroll']);
-        if (inWheelScroll) {
-            return;
-        }
-        if (inVirtualScroll) {
-            return;
-        }
-        if (inBodyScroll) {
+        if (inWheelScroll || inVirtualScroll || inBodyScroll || inFooterScroll) {
             return;
         }
-        if (inFooterScroll) {
+        if (intoRunScroll) {
             return;
         }
         if (!headerScrollElem) {
@@ -7374,22 +7868,16 @@ const Methods = {
     triggerFooterScrollEvent(evnt, fixedType) {
         const $xeTable = this;
         const internalData = $xeTable;
-        const { elemStore, inWheelScroll, inVirtualScroll, inHeaderScroll, inBodyScroll } = internalData;
+        const { elemStore, intoRunScroll, inWheelScroll, inVirtualScroll, inHeaderScroll, inBodyScroll } = internalData;
         const xHandleEl = $xeTable.$refs.refScrollXHandleElem;
         const yHandleEl = $xeTable.$refs.refScrollYHandleElem;
         const bodyScrollElem = getRefElem(elemStore['main-body-scroll']);
         const headerScrollElem = getRefElem(elemStore['main-header-scroll']);
         const footerScrollElem = getRefElem(elemStore['main-footer-scroll']);
-        if (inWheelScroll) {
-            return;
-        }
-        if (inVirtualScroll) {
+        if (inWheelScroll || inVirtualScroll || inHeaderScroll || inBodyScroll) {
             return;
         }
-        if (inHeaderScroll) {
-            return;
-        }
-        if (inBodyScroll) {
+        if (intoRunScroll) {
             return;
         }
         if (!footerScrollElem) {
@@ -7420,7 +7908,10 @@ const Methods = {
         const tableProps = $xeTable;
         const reactData = $xeTable;
         const internalData = $xeTable;
-        const { deltaY, deltaX } = evnt;
+        const { target, deltaY, deltaX } = evnt;
+        if (target && /^textarea$/i.test(target.tagName)) {
+            return;
+        }
         const { highlightHoverRow } = tableProps;
         const { elemStore, lastScrollTop, lastScrollLeft } = internalData;
         const rowOpts = $xeTable.computeRowOpts;
@@ -7438,31 +7929,13 @@ const Methods = {
         if (!bodyScrollElem) {
             return;
         }
-        let multiple = 1;
-        if (reactData.lastScrollTime + 25 > Date.now()) {
-            multiple = 1.18;
-        }
-        else if (reactData.lastScrollTime + 30 > Date.now()) {
-            multiple = 1.15;
-        }
-        else if (reactData.lastScrollTime + 40 > Date.now()) {
-            multiple = 1.12;
-        }
-        else if (reactData.lastScrollTime + 55 > Date.now()) {
-            multiple = 1.09;
-        }
-        else if (reactData.lastScrollTime + 75 > Date.now()) {
-            multiple = 1.06;
-        }
-        else if (reactData.lastScrollTime + 100 > Date.now()) {
-            multiple = 1.03;
-        }
-        const deltaTop = deltaY * multiple;
-        const deltaLeft = deltaX * multiple;
+        const wheelSpeed = getWheelSpeed(reactData.lastScrollTime);
+        const deltaTop = deltaY * wheelSpeed;
+        const deltaLeft = deltaX * wheelSpeed;
         const isTopWheel = deltaTop < 0;
-        const currScrollTop = yHandleEl.scrollTop;
+        const currScrollTop = bodyScrollElem.scrollTop;
         // 如果滚动位置已经是顶部或底部，则不需要触发
-        if (isTopWheel ? currScrollTop <= 0 : currScrollTop >= yHandleEl.scrollHeight - yHandleEl.clientHeight) {
+        if (isTopWheel ? currScrollTop <= 0 : currScrollTop >= bodyScrollElem.scrollHeight - bodyScrollElem.clientHeight) {
             return;
         }
         const scrollTop = bodyScrollElem.scrollTop + deltaTop;
@@ -7475,16 +7948,29 @@ const Methods = {
             if (rowOpts.isHover || highlightHoverRow) {
                 $xeTable.clearHoverRow();
             }
-            internalData.inWheelScroll = true;
-            setScrollTop(yHandleEl, scrollTop);
-            setScrollTop(bodyScrollElem, scrollTop);
-            setScrollTop(leftScrollElem, scrollTop);
-            setScrollTop(rightScrollElem, scrollTop);
-            $xeTable.triggerScrollYEvent(evnt);
-            $xeTable.handleScrollEvent(evnt, isRollY, isRollX, scrollTop, scrollLeft, {
-                type: 'footer',
-                fixed: ''
+            wheelScrollTo(scrollTop - bodyScrollElem.scrollTop, (offsetTop) => {
+                const currTopNum = bodyScrollElem.scrollTop + offsetTop;
+                internalData.inWheelScroll = true;
+                setScrollTop(yHandleEl, currTopNum);
+                setScrollTop(bodyScrollElem, currTopNum);
+                setScrollTop(leftScrollElem, currTopNum);
+                setScrollTop(rightScrollElem, currTopNum);
+                $xeTable.triggerScrollYEvent(evnt);
+                $xeTable.handleScrollEvent(evnt, isRollY, isRollX, currTopNum, scrollLeft, {
+                    type: 'table',
+                    fixed: ''
+                });
             });
+            // internalData.inWheelScroll = true
+            // setScrollTop(yHandleEl, scrollTop)
+            // setScrollTop(bodyScrollElem, scrollTop)
+            // setScrollTop(leftScrollElem, scrollTop)
+            // setScrollTop(rightScrollElem, scrollTop)
+            // loadScrollYData($xeTable, scrollTop)
+            // $xeTable.handleScrollEvent(evnt, isRollY, isRollX, scrollTop, scrollLeft, {
+            //   type: 'footer',
+            //   fixed: ''
+            // })
         }
     },
     triggerVirtualScrollXEvent(evnt) {
@@ -7555,13 +8041,13 @@ const Methods = {
     },
     updateScrollXData() {
         const $xeTable = this;
-        const props = $xeTable;
-        const { showOverflow } = props;
+        const reactData = $xeTable;
+        const { isAllOverflow } = reactData;
         handleTableColumn($xeTable);
         return $xeTable.$nextTick().then(() => {
             handleTableColumn($xeTable);
             $xeTable.updateScrollXSpace();
-            if (!showOverflow) {
+            if (!isAllOverflow) {
                 $xeTable.updateScrollYSpace();
             }
         });
@@ -7625,38 +8111,36 @@ const Methods = {
     // 更新纵向 Y 可视渲染上下剩余空间大小
     updateScrollYSpace() {
         const $xeTable = this;
-        const props = $xeTable;
         const reactData = $xeTable;
         const internalData = $xeTable;
-        const { showOverflow } = props;
-        const { scrollYLoad, rowHeight } = reactData;
-        const { scrollYStore, elemStore, afterFullData, fullAllDataRowIdData } = internalData;
+        const { isAllOverflow, scrollYLoad } = reactData;
+        const { scrollYStore, elemStore, isResizeCellHeight, afterFullData, fullAllDataRowIdData } = internalData;
         const { startIndex } = scrollYStore;
+        const rowOpts = $xeTable.computeRowOpts;
+        const cellOpts = $xeTable.computeCellOpts;
+        const defaultRowHeight = $xeTable.computeDefaultRowHeight;
         const bodyTableElem = getRefElem(elemStore['main-body-table']);
         const containerList = ['main', 'left', 'right'];
         let topSpaceHeight = 0;
         let ySpaceHeight = 0;
         if (scrollYLoad) {
-            if (showOverflow) {
-                ySpaceHeight = afterFullData.length * rowHeight;
-                topSpaceHeight = Math.max(0, startIndex * rowHeight);
+            const isCustomCellHeight = isResizeCellHeight || cellOpts.height || rowOpts.height;
+            if (!isCustomCellHeight && isAllOverflow) {
+                ySpaceHeight = afterFullData.length * defaultRowHeight;
+                topSpaceHeight = Math.max(0, startIndex * defaultRowHeight);
             }
             else {
                 for (let i = 0; i < afterFullData.length; i++) {
                     const row = afterFullData[i];
                     const rowid = getRowid($xeTable, row);
-                    const rowRest = fullAllDataRowIdData[rowid];
-                    if (rowRest) {
-                        ySpaceHeight += rowRest.height || rowHeight;
-                    }
+                    const rowRest = fullAllDataRowIdData[rowid] || {};
+                    ySpaceHeight += rowRest.resizeHeight || rowRest.height || cellOpts.height || rowOpts.height || defaultRowHeight;
                 }
                 for (let i = 0; i < startIndex; i++) {
                     const row = afterFullData[i];
                     const rowid = getRowid($xeTable, row);
-                    const rowRest = fullAllDataRowIdData[rowid];
-                    if (rowRest) {
-                        topSpaceHeight += rowRest.height || rowHeight;
-                    }
+                    const rowRest = fullAllDataRowIdData[rowid] || {};
+                    topSpaceHeight += rowRest.resizeHeight || rowRest.height || cellOpts.height || rowOpts.height || defaultRowHeight;
                 }
             }
         }
@@ -7682,7 +8166,7 @@ const Methods = {
         if (scrollYSpaceEl) {
             scrollYSpaceEl.style.height = ySpaceHeight ? `${ySpaceHeight}px` : '';
         }
-        $xeTable.$nextTick(() => {
+        return $xeTable.$nextTick().then(() => {
             updateStyle($xeTable);
         });
     },
@@ -7747,10 +8231,8 @@ const Methods = {
      */
     scrollToRow(row, fieldOrColumn) {
         const $xeTable = this;
-        const props = $xeTable;
         const reactData = $xeTable;
-        const { showOverflow } = props;
-        const { scrollYLoad, scrollXLoad } = reactData;
+        const { isAllOverflow, scrollYLoad, scrollXLoad } = reactData;
         const rest = [];
         if (row) {
             if (this.treeConfig) {
@@ -7765,7 +8247,7 @@ const Methods = {
         }
         return Promise.all(rest).then(() => {
             if (row) {
-                if (!showOverflow && (scrollYLoad || scrollXLoad)) {
+                if (!isAllOverflow && (scrollYLoad || scrollXLoad)) {
                     calcCellHeight($xeTable);
                     calcCellWidth($xeTable);
                 }