vxe-table 3.12.10-beta.8 → 3.12.10

package/packages/table/src/methods.ts

@@ -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'
@@ -329,7 +329,7 @@ function updateAfterListIndex ($xeTable: VxeTableConstructor) {
       rowRest.seq = seq
       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
     }
@@ -361,7 +361,7 @@ function updateAfterDataIndex ($xeTable: VxeTableConstructor) {
         rowRest.seq = seq
         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
       }
@@ -417,14 +417,16 @@ function updateStyle ($xeTable: VxeTableConstructor & VxeTablePrivateMethods) {
   const reactData = $xeTable as unknown as TableReactData
   const internalData = $xeTable as unknown as TableInternalData
 
-  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 as HTMLDivElement
   if (!el) {
     return
   }
   const containerList = ['main', 'left', 'right']
+  const osbWidth = overflowY ? scrollbarWidth : 0
+  const osbHeight = overflowX ? scrollbarHeight : 0
   const emptyPlaceholderElem = $xeTable.$refs.refEmptyPlaceholder as HTMLDivElement
   const cellOffsetWidth = $xeTable.computeCellOffsetWidth
   const mouseOpts = $xeTable.computeMouseOpts
@@ -432,17 +434,17 @@ function updateStyle ($xeTable: VxeTableConstructor & VxeTablePrivateMethods) {
   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) {
@@ -461,28 +463,28 @@ function updateStyle ($xeTable: VxeTableConstructor & VxeTablePrivateMethods) {
   const scrollbarXToTop = $xeTable.computeScrollbarXToTop
   const scrollXVirtualEl = $xeTable.$refs.refScrollXVirtualElem as HTMLDivElement
   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 as HTMLDivElement
   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 as HTMLDivElement
   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 as HTMLDivElement
   if (yTopCornerEl) {
@@ -608,7 +610,7 @@ function updateStyle ($xeTable: VxeTableConstructor & VxeTablePrivateMethods) {
           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`
         }
 
@@ -617,7 +619,7 @@ function updateStyle ($xeTable: VxeTableConstructor & VxeTablePrivateMethods) {
 
         let isOptimizeMode = false
         // 如果是使用优化模式
-        if (scrollXLoad || scrollYLoad || (allColumnOverflow && isAllOverflow)) {
+        if (scrollXLoad || scrollYLoad || isAllOverflow) {
           if (expandColumn || spanMethod || footerSpanMethod) {
             // 如果不支持优化模式
           } else {
@@ -643,7 +645,7 @@ function updateStyle ($xeTable: VxeTableConstructor & VxeTablePrivateMethods) {
         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) {
@@ -683,7 +685,7 @@ function updateStyle ($xeTable: VxeTableConstructor & VxeTablePrivateMethods) {
           // 如果是固定列
           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`
             }
           }
         }
@@ -706,7 +708,7 @@ function updateStyle ($xeTable: VxeTableConstructor & VxeTablePrivateMethods) {
             } else if (layout === 'footer') {
               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'
@@ -751,53 +753,63 @@ function updateStyle ($xeTable: VxeTableConstructor & VxeTablePrivateMethods) {
 }
 
 function computeRowHeight ($xeTable: VxeTableConstructor) {
+  const reactData = $xeTable as unknown as TableReactData
+
+  const { isAllOverflow } = reactData
   const tableHeader = $xeTable.$refs.refTableHeader
   const tableBody = $xeTable.$refs.refTableBody
   const tableBodyElem = tableBody ? (tableBody as any).$el as HTMLDivElement : null
   const defaultRowHeight = $xeTable.computeDefaultRowHeight
   let rowHeight = 0
-  if (tableBodyElem) {
-    const tableHeaderElem = tableHeader ? (tableHeader as any).$el as HTMLDivElement : null
-    let firstTrElem
-    firstTrElem = tableBodyElem.querySelector('tr')
-    if (!firstTrElem && tableHeaderElem) {
-      firstTrElem = tableHeaderElem.querySelector('tr')
+  if (isAllOverflow) {
+    if (tableBodyElem) {
+      const tableHeaderElem = tableHeader ? (tableHeader as any).$el as HTMLDivElement : null
+      let firstTrElem
+      firstTrElem = tableBodyElem.querySelector('tr')
+      if (!firstTrElem && tableHeaderElem) {
+        firstTrElem = tableHeaderElem.querySelector('tr')
+      }
+      if (firstTrElem) {
+        rowHeight = firstTrElem.clientHeight
+      }
     }
-    if (firstTrElem) {
-      rowHeight = firstTrElem.clientHeight
+    if (!rowHeight) {
+      rowHeight = defaultRowHeight
     }
-  }
-  if (!rowHeight) {
+  } else {
     rowHeight = defaultRowHeight
   }
   // 最低支持 18px 行高
   return Math.max(18, rowHeight)
 }
 
-function handleVirtualYVisible ($xeTable: VxeTableConstructor) {
-  const props = $xeTable
+function handleVirtualYVisible ($xeTable: VxeTableConstructor, currScrollTop?: number) {
   const reactData = $xeTable as unknown as TableReactData
   const internalData = $xeTable as unknown as TableInternalData
 
-  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
         }
@@ -1053,7 +1065,7 @@ function autoCellWidth ($xeTable: VxeTableConstructor & VxeTablePrivateMethods)
   }
   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
@@ -1063,7 +1075,7 @@ function autoCellWidth ($xeTable: VxeTableConstructor & VxeTablePrivateMethods)
   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
@@ -1074,64 +1086,38 @@ function autoCellWidth ($xeTable: VxeTableConstructor & VxeTablePrivateMethods)
   }
 }
 
-// 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: VxeTableDefines.RowCacheItem, wrapperEl: HTMLDivElement) => {
+  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] as HTMLElement
+    const tdEl = cellElem.parentElement as HTMLTableCellElement
+    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: VxeTableConstructor) => {
-  const props = $xeTable
   const reactData = $xeTable as unknown as TableReactData
   const internalData = $xeTable as unknown as TableInternalData
 
-  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 as HTMLDivElement
-  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`)
-      if (rowRest && cellList.length) {
-        let height = 0
-        for (let i = 0; i < cellList.length; i++) {
-          const cellElem = cellList[i] as HTMLElement
-          const tdEl = cellElem.parentElement as HTMLTableCellElement
-          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: any, column: any) {
@@ -1154,6 +1140,20 @@ function getOrderField (_vm: any, column: any) {
   }
 }
 
+function handleTargetEnterEvent ($xeTable: VxeTableConstructor, isClear: boolean) {
+  const internalData = $xeTable as unknown as TableInternalData
+
+  const $tooltip = $xeTable.$refs.refTooltip as VxeTooltipInstance
+  clearTimeout(internalData.tooltipTimeout)
+  if (isClear) {
+    $xeTable.closeTooltip()
+  } else {
+    if ($tooltip && $tooltip.setActived) {
+      $tooltip.setActived(true)
+    }
+  }
+}
+
 function clearDragStatus ($xeTable: any) {
   const reactData = $xeTable
 
@@ -1261,9 +1261,11 @@ function showDropTip ($xeTable: VxeTableConstructor & VxeTablePrivateMethods, ev
   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) {
@@ -1274,14 +1276,14 @@ function showDropTip ($xeTable: VxeTableConstructor & VxeTablePrivateMethods, ev
         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')
       } else {
@@ -1306,7 +1308,7 @@ function showDropTip ($xeTable: VxeTableConstructor & VxeTablePrivateMethods, ev
           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
         }
@@ -1317,7 +1319,7 @@ function showDropTip ($xeTable: VxeTableConstructor & VxeTablePrivateMethods, ev
         if (prevDragToChild) {
           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')
@@ -1350,7 +1352,44 @@ function hideDropTip ($xeTable: VxeTableConstructor & VxeTablePrivateMethods) {
   }
 }
 
-function handleScrollToRowColumn ($xeTable: VxeTableConstructor, fieldOrColumn: string | VxeTableDefines.ColumnInfo | null, row?: any) {
+/**
+ * 处理显示 tooltip
+ * @param {Event} evnt 事件
+ * @param {Row} row 行对象
+ */
+function handleTooltip ($xeTable: VxeTableConstructor & VxeTablePrivateMethods, evnt: MouseEvent, tdEl: HTMLTableCellElement, overflowElem: HTMLElement, tipElem: HTMLElement | null, params: any) {
+  const reactData = $xeTable as unknown as TableReactData
+
+  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 as VxeTooltipInstance
+      if ($tooltip && $tooltip.open) {
+        $tooltip.open(isCellOverflow ? overflowElem : (tipElem || overflowElem), formatText(content))
+      }
+    })
+  }
+  return $xeTable.$nextTick()
+}
+
+function handleScrollToRowColumn ($xeTable: VxeTableConstructor & VxeTablePrivateMethods, fieldOrColumn: string | VxeTableDefines.ColumnInfo | null, row?: any) {
   const internalData = $xeTable as unknown as TableInternalData
 
   const { fullColumnIdData } = internalData
@@ -1369,13 +1408,13 @@ function computeScrollLoad ($xeTable: VxeTableConstructor & VxeTablePrivateMetho
   return $xeTable.$nextTick().then(() => {
     const { scrollXLoad, scrollYLoad } = reactData
     const { scrollXStore, scrollYStore } = internalData
-    const sYOpts = $xeTable.computeSYOpts
-    const sXOpts = $xeTable.computeSXOpts
+    const virtualYOpts = $xeTable.computeVirtualYOpts
+    const virtualXOpts = $xeTable.computeVirtualXOpts
     // 计算 X 逻辑
     if (scrollXLoad) {
       const { toVisibleIndex: toXVisibleIndex, visibleSize: visibleXSize } = handleVirtualXVisible($xeTable)
-      const offsetXSize = Math.max(0, sXOpts.oSize ? XEUtils.toNumber(sXOpts.oSize) : 0)
-      scrollXStore.preloadSize = 4
+      const offsetXSize = Math.max(0, virtualXOpts.oSize ? XEUtils.toNumber(virtualXOpts.oSize) : 0)
+      scrollXStore.preloadSize = XEUtils.toNumber(virtualXOpts.preSize)
       scrollXStore.offsetSize = offsetXSize
       scrollXStore.visibleSize = visibleXSize
       scrollXStore.endIndex = Math.max(scrollXStore.startIndex + scrollXStore.visibleSize + offsetXSize, scrollXStore.endIndex)
@@ -1387,15 +1426,14 @@ function computeScrollLoad ($xeTable: VxeTableConstructor & VxeTablePrivateMetho
     } else {
       $xeTable.updateScrollXSpace()
     }
-    calcCellHeight($xeTable)
     // 计算 Y 逻辑
     const rowHeight = computeRowHeight($xeTable)
     ;(scrollYStore as any).rowHeight = rowHeight
     reactData.rowHeight = rowHeight
     const { toVisibleIndex: toYVisibleIndex, visibleSize: visibleYSize } = handleVirtualYVisible($xeTable)
     if (scrollYLoad) {
-      const offsetYSize = Math.max(0, sYOpts.oSize ? XEUtils.toNumber(sYOpts.oSize) : 0)
-      scrollYStore.preloadSize = 2
+      const offsetYSize = Math.max(0, virtualYOpts.oSize ? XEUtils.toNumber(virtualYOpts.oSize) : 0)
+      scrollYStore.preloadSize = XEUtils.toNumber(virtualYOpts.preSize)
       scrollYStore.offsetSize = offsetYSize
       scrollYStore.visibleSize = visibleYSize
       scrollYStore.endIndex = Math.max(scrollYStore.startIndex + visibleYSize + offsetYSize, scrollYStore.endIndex)
@@ -1646,13 +1684,12 @@ function handleColumn ($xeTable: VxeTableConstructor & VxeTablePrivateMethods, c
   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) {
@@ -1677,6 +1714,7 @@ function handleColumn ($xeTable: VxeTableConstructor & VxeTablePrivateMethods, c
       if ($xeTable.handleUpdateCustomColumn) {
         $xeTable.handleUpdateCustomColumn()
       }
+      reactData.isColLoading = false
       return $xeTable.recalculate()
     })
   })
@@ -1685,17 +1723,15 @@ function handleColumn ($xeTable: VxeTableConstructor & VxeTablePrivateMethods, c
 /**
  * 纵向 Y 可视渲染处理
  */
-function loadScrollYData ($xeTable: VxeTableConstructor & VxeTablePrivateMethods) {
-  const props = $xeTable
+function loadScrollYData ($xeTable: VxeTableConstructor & VxeTablePrivateMethods, scrollTop?: number) {
   const reactData = $xeTable as unknown as TableReactData
   const internalData = $xeTable as unknown as TableInternalData
 
-  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
@@ -1713,6 +1749,46 @@ function loadScrollYData ($xeTable: VxeTableConstructor & VxeTablePrivateMethods
   }
 }
 
+function lazyScrollXData ($xeTable: VxeTableConstructor & VxeTablePrivateMethods) {
+  const internalData = $xeTable as unknown as TableInternalData
+
+  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: VxeTableConstructor & VxeTablePrivateMethods) {
+  const internalData = $xeTable as unknown as TableInternalData
+
+  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: VxeTableConstructor & VxeTablePrivateMethods, isRollX: boolean, isRollY: boolean) {
   const reactData = $xeTable as unknown as TableReactData
   const internalData = $xeTable as unknown as TableInternalData
@@ -1725,28 +1801,66 @@ function checkLastSyncScroll ($xeTable: VxeTableConstructor & VxeTablePrivateMet
   internalData.lcsTimeout = setTimeout(() => {
     internalData.lcsRunTime = Date.now()
     internalData.lcsTimeout = undefined
+    internalData.intoRunScroll = false
     internalData.inVirtualScroll = false
     internalData.inWheelScroll = false
     internalData.inHeaderScroll = false
     internalData.inBodyScroll = false
     internalData.inFooterScroll = false
     internalData.scrollRenderType = ''
+    calcCellHeight($xeTable)
     if (isRollX && scrollXLoad) {
-      $xeTable.updateScrollXData().then(() => {
-        calcCellHeight($xeTable)
-        loadScrollXData($xeTable)
-      })
+      $xeTable.updateScrollXData()
     }
     if (isRollY && scrollYLoad) {
       $xeTable.updateScrollYData().then(() => {
         calcCellHeight($xeTable)
-        loadScrollYData($xeTable)
+        $xeTable.updateScrollYSpace()
       })
     }
     $xeTable.updateCellAreas()
   }, 200)
 }
 
+const getWheelSpeed = (lastScrollTime: number) => {
+  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: number, cb: (progress: number) => void) => {
+  const duration = Math.abs(diffNum)
+  const startTime = performance.now()
+  let countTop = 0
+  const step = (timestamp: number) => {
+    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: VxeTableConstructor & VxeTablePrivateMethods) {
   const internalData = $xeTable as unknown as TableInternalData
 
@@ -1756,57 +1870,63 @@ function updateHeight ($xeTable: VxeTableConstructor & VxeTablePrivateMethods) {
 }
 
 function calcColumnAutoWidth (column: VxeTableDefines.ColumnInfo, wrapperEl: HTMLDivElement) {
-  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 as HTMLElement
-    const thElem = cellEl.parentElement as HTMLElement
-    let titleWidth = 0
-    if (`${thElem.tagName}`.toLowerCase() === 'th') {
-      XEUtils.arrayEach(cellEl.children, (btnEl) => {
-        titleWidth += (btnEl as HTMLElement).offsetWidth + 1
-      })
-    } else {
-      const labelEl = cellEl.firstElementChild as HTMLElement
-      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] as HTMLDivElement
+    colWidth = Math.max(colWidth, celEl ? Math.ceil(celEl.scrollWidth) + 4 : 0)
+  }
+  return colWidth + leftRightPadding
 }
 
 function calcCellWidth ($xeTable: VxeTableConstructor & VxeTablePrivateMethods) {
-  const reactData = $xeTable as unknown as TableReactData
   const internalData = $xeTable as unknown as TableInternalData
 
   const autoWidthColumnList = $xeTable.computeAutoWidthColumnList
-  reactData.isCalcColumn = true
-  return $xeTable.$nextTick().then(() => {
-    const { fullColumnIdData } = internalData
-    const el = $xeTable.$refs.refElem as HTMLDivElement
-    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 as HTMLDivElement
+  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: VxeTableConstructor & VxeTablePrivateMethods, evnt: MouseEvent, params: any) => {
+  $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: VxeTableConstructor & VxeTablePrivateMethods, evnt: MouseEvent, params: any) => {
+  const reactData = $xeTable as unknown as TableReactData
+
+  reactData.resizeHeightFlag++
+  $xeTable.recalculate(true).then(() => {
+    $xeTable.updateCellAreas()
+    $xeTable.dispatchEvent('row-resizable-change', params, evnt)
+    setTimeout(() => $xeTable.recalculate(true), 300)
   })
 }
 
@@ -1863,7 +1983,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))
     })
   },
   /**
@@ -1918,12 +2038,13 @@ const Methods = {
    * 加载表格数据
    * @param {Array} datas 数据
    */
-  loadTableData (datas: any) {
-    const $xeTable = this
+  loadTableData (datas: any[], isReset: boolean) {
+    const $xeTable = this as VxeTableConstructor & VxeTablePrivateMethods
+    const reactData = $xeTable as unknown as TableReactData
+    const internalData = $xeTable as unknown as TableInternalData
 
-    const { keepSource, showOverflow, treeConfig, treeOpts, editStore, scrollYStore, scrollXStore, lastScrollLeft, lastScrollTop, scrollYLoad: oldScrollYLoad, sXOpts, sYOpts } = this
+    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) {
@@ -1966,43 +2087,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: any) => column.showOverflow === false)
-          if (errColumn) {
-            errLog('vxe.error.errProp', [`column[field="${errColumn.field}"].show-overflow=false`, 'show-overflow=true'])
-          }
-        }
-      }
-
-      if (process.env.VUE_APP_VXE_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()
@@ -2022,6 +2130,30 @@ 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.VUE_APP_VXE_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<void>(resolve => {
@@ -2037,6 +2169,8 @@ const Methods = {
             if (sYOpts.scrollToTopOnChange) {
               targetScrollTop = 0
             }
+            reactData.isRowLoading = false
+            calcCellHeight($xeTable)
             // 是否变更虚拟滚动
             if (oldScrollYLoad === sYLoad) {
               restoreScrollLocation(this, targetScrollLeft, targetScrollTop)
@@ -2061,7 +2195,7 @@ const Methods = {
    */
   loadData (datas: any) {
     const { initStatus } = this
-    return this.loadTableData(datas).then(() => {
+    return this.loadTableData(datas, false).then(() => {
       this.inited = true
       this.initStatus = true
       if (!initStatus) {
@@ -2079,7 +2213,7 @@ const Methods = {
       .then(() => {
         this.inited = true
         this.initStatus = true
-        return this.loadTableData(datas)
+        return this.loadTableData(datas, true)
       })
       .then(() => {
         this.handleLoadDefaults()
@@ -2157,9 +2291,8 @@ const Methods = {
   },
   /**
    * 更新数据行的 Map
-   * 牺牲数据组装的耗时，用来换取使用过程中的流畅
    */
-  cacheRowMap (isSource?: boolean) {
+  cacheRowMap (isReset: boolean, isSource?: boolean) {
     const { treeConfig, treeOpts, tableFullData, fullAllDataRowIdData, tableFullTreeData } = this
     const childrenField = treeOpts.children || treeOpts.childrenField
     const hasChildField = treeOpts.hasChild || treeOpts.hasChildField
@@ -2179,8 +2312,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
@@ -2253,7 +2386,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 })
@@ -2604,18 +2737,37 @@ const Methods = {
     return this.$nextTick()
   },
   getCellElement (row: any, fieldOrColumn: any) {
-    const column = handleFieldOrColumn(this, fieldOrColumn)
+    const $xeTable = this as VxeTableConstructor & VxeTablePrivateMethods
+    const internalData = $xeTable as unknown as TableInternalData
+
+    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
   },
@@ -3009,7 +3161,10 @@ const Methods = {
    * @param {String/Number} rowid 行主键
    */
   getRowById (cellValue: any) {
-    const fullDataRowIdData = this.fullDataRowIdData
+    const $xeTable = this as VxeTableConstructor & VxeTablePrivateMethods
+    const internalData = $xeTable as unknown as TableInternalData
+
+    const { fullDataRowIdData } = internalData
     const rowid = XEUtils.eqNull(cellValue) ? '' : encodeURIComponent(cellValue)
     return fullDataRowIdData[rowid] ? fullDataRowIdData[rowid].row : null
   },
@@ -3017,13 +3172,10 @@ const Methods = {
    * 根据行获取行的唯一主键
    * @param {Row} row 行对象
    */
-  getRowid (cellValue: any) {
+  getRowid (row: any) {
     const $xeTable = this as VxeTableConstructor & VxeTablePrivateMethods
-    const internalData = $xeTable as unknown as TableInternalData
 
-    const { fullDataRowIdData } = internalData
-    const rowid = XEUtils.eqNull(cellValue) ? '' : encodeURIComponent(cellValue || '')
-    return fullDataRowIdData[rowid] ? fullDataRowIdData[rowid].row : null
+    return getRowid($xeTable, row)
   },
   /**
    * 获取处理后的表格数据
@@ -3214,34 +3366,40 @@ const Methods = {
     }
     return $xeTable.$nextTick()
   },
-  setColumnWidth (fieldOrColumn: any, width: any) {
-    const $xeTable = this
+  setColumnWidth (fieldOrColumn: VxeColumnPropTypes.Field | VxeTableDefines.ColumnInfo | VxeColumnPropTypes.Field[] | VxeTableDefines.ColumnInfo[], width: number | string) {
+    const $xeTable = this as VxeTableConstructor & VxeTablePrivateMethods
+    const internalData = $xeTable as unknown as TableInternalData
 
+    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 as HTMLDivElement : 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: any) {
+  getColumnWidth (fieldOrColumn: VxeColumnPropTypes.Field | VxeTableDefines.ColumnInfo) {
     const column = handleFieldOrColumn(this, fieldOrColumn)
     if (column) {
       return column.renderWidth
@@ -3253,7 +3411,12 @@ const Methods = {
    * 如果为 true 则重置所有状态
    * 如果已关联工具栏，则会同步更新
    */
-  resetColumn (options: any) {
+  resetColumn (options?: boolean | {
+    visible?: boolean
+    resizable?: boolean
+    fixed?: boolean
+    order?: boolean
+  }) {
     warnLog('vxe.error.delFunc', ['resetColumn', 'resetCustom'])
     return this.resetCustom(options)
   },
@@ -3526,7 +3689,153 @@ const Methods = {
     })
     Object.assign(this.columnStore, { resizeList, pxList, pxMinList, autoMinList, scaleList, scaleMinList, autoList, remainList })
   },
-  handleResizeDblclickEvent (evnt: MouseEvent, params: VxeTableDefines.CellRenderHeaderParams) {
+  handleColResizeMousedownEvent (evnt: MouseEvent, fixedType: 'left' | 'right' | '', params: VxeTableDefines.CellRenderHeaderParams & { $table: VxeTableConstructor & VxeTablePrivateMethods }) {
+    const $xeTable = this as VxeTableConstructor & VxeTablePrivateMethods
+    const reactData = $xeTable as unknown as TableReactData
+    const internalData = $xeTable as unknown as TableInternalData
+
+    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 as HTMLDivElement
+    const leftContainerElem = $xeTable.$refs.refLeftContainer as HTMLDivElement
+    const rightContainerElem = $xeTable.$refs.refRightContainer as HTMLDivElement
+    const resizeBarElem = $xeTable.$refs.refColResizeBar as HTMLDivElement
+    if (!resizeBarElem) {
+      return
+    }
+    const resizeTipElem = resizeBarElem.firstElementChild as HTMLDivElement
+    const scrollbarXToTop = $xeTable.computeScrollbarXToTop
+    const { clientX: dragClientX } = evnt
+    const wrapperElem = $xeTable.$refs.refElem as HTMLDivElement
+    const dragBtnElem = evnt.target as HTMLDivElement
+    let resizeColumn = column
+    if (column.children && column.children.length) {
+      XEUtils.eachTree(column.children, childColumn => {
+        resizeColumn = childColumn
+      })
+    }
+    const cell = dragBtnElem.parentNode as HTMLTableCellElement
+    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] as HTMLTableCellElement
+      while (tempCellElem) {
+        if (hasClass(tempCellElem, 'fixed--hidden')) {
+          break
+        } else if (!hasClass(tempCellElem, 'col--group')) {
+          fixedOffsetWidth += tempCellElem.offsetWidth
+        }
+        tempCellElem = tempCellElem[siblingProp] as HTMLTableCellElement
+      }
+      if (isRightFixed && rightContainerElem) {
+        dragPosLeft = rightContainerElem.offsetLeft + fixedOffsetWidth
+      }
+    }
+
+    // 处理拖动事件
+    const updateEvent = (evnt: MouseEvent) => {
+      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 = { ...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: MouseEvent, params: VxeTableDefines.CellRenderHeaderParams) {
     const $xeTable = this as VxeTableConstructor & VxeTablePrivateMethods
     const reactData = $xeTable as unknown as TableReactData
     const internalData = $xeTable as unknown as TableInternalData
@@ -3535,6 +3844,8 @@ const Methods = {
     const { isDblclickAutoWidth } = resizableOpts
     const el = $xeTable.$refs.refElem as HTMLDivElement
     if (isDblclickAutoWidth && el) {
+      evnt.stopPropagation()
+      evnt.preventDefault()
       const { fullColumnIdData } = internalData
       const { column } = params
       let resizeColumn = column
@@ -3549,21 +3860,272 @@ const Methods = {
       const cell = dragBtnElem.parentNode as HTMLTableCellElement
       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 = { ...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', { ...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: MouseEvent, params: VxeTableDefines.CellRenderBodyParams & { $table: VxeTableConstructor & VxeTablePrivateMethods }) {
+    const $xeTable = this as VxeTableConstructor & VxeTablePrivateMethods
+    const reactData = $xeTable as unknown as TableReactData
+    const internalData = $xeTable as unknown as TableInternalData
+
+    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 as HTMLDivElement
+    const resizeBarElem = $xeTable.$refs.refRowResizeBar as HTMLDivElement
+    if (!resizeBarElem) {
+      return
+    }
+    const { clientY: dragClientY } = evnt
+    const resizeTipElem = resizeBarElem.firstElementChild as HTMLDivElement
+    const dragBtnElem = evnt.currentTarget as HTMLDivElement
+    const tdEl = dragBtnElem.parentNode as HTMLTableCellElement
+    const trEl = tdEl.parentNode as HTMLTableCellElement
+    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: MouseEvent) => {
+      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 = { ...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: MouseEvent, params: VxeTableDefines.CellRenderBodyParams & { $table: VxeTableConstructor & VxeTablePrivateMethods }) {
+    const $xeTable = this as VxeTableConstructor & VxeTablePrivateMethods
+    const reactData = $xeTable as unknown as TableReactData
+    const internalData = $xeTable as unknown as TableInternalData
+
+    const resizableOpts = $xeTable.computeResizableOpts
+    const { isDblclickAutoHeight } = resizableOpts
+    const el = $xeTable.$refs.refElem as HTMLDivElement
+    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 = { ...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: Record<string, number>) {
+    const $xeTable = this as VxeTableConstructor & VxeTablePrivateMethods
+    const reactData = $xeTable as unknown as TableReactData
+    const internalData = $xeTable as unknown as TableInternalData
+
+    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?: boolean) {
+    const $xeTable = this as VxeTableConstructor & VxeTablePrivateMethods
+    const internalData = $xeTable as unknown as TableInternalData
+
+    const { fullAllDataRowIdData, afterFullData } = internalData
+    const rowOpts = $xeTable.computeRowOpts
+    const cellOpts = $xeTable.computeCellOpts
+    const defaultRowHeight = $xeTable.computeDefaultRowHeight
+    const rest: Record<string, number> = {}
+    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: any | any[], height: number) {
+    const $xeTable = this as VxeTableConstructor & VxeTablePrivateMethods
+    const reactData = $xeTable as unknown as TableReactData
+    const internalData = $xeTable as unknown as TableInternalData
+
+    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 as any).$el as HTMLDivElement : 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: any) {
+    const $xeTable = this as VxeTableConstructor & VxeTablePrivateMethods
+    const internalData = $xeTable as unknown as TableInternalData
+
+    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
   },
   /**
    * 刷新滚动操作，手动同步滚动相关位置（对于某些特殊的操作，比如滚动条错位、固定列不同步）
@@ -3941,10 +4503,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))) {
           const { isLastEnterAppendRow, beforeEnterMethod, enterMethod } = keyboardOpts
@@ -4176,48 +4738,43 @@ const Methods = {
     this.updateCellAreas()
     this.recalculate(true)
   },
-  handleTargetEnterEvent (isClear: any) {
-    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 as VxeTableConstructor & VxeTablePrivateMethods
+    const internalData = $xeTable as unknown as TableInternalData
+
+    const tooltipOpts = $xeTable.computeTooltipOpts
+    let $tooltip = $xeTable.$refs.refTooltip as VxeTooltipInstance
+    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 as VxeTooltipInstance
+        if ($tooltip && $tooltip.isActived && !$tooltip.isActived()) {
+          $xeTable.closeTooltip()
         }
       }, tooltipOpts.leaveDelay)
     } else {
-      this.closeTooltip()
+      $xeTable.closeTooltip()
     }
   },
   triggerHeaderTitleEvent (evnt: any, iconParams: any, params: any) {
-    const tipContent = iconParams.content || iconParams.message
+    const $xeTable = this as VxeTableConstructor & VxeTablePrivateMethods
+    const reactData = $xeTable as unknown as TableReactData
+
+    const tipContent = iconParams.content || (iconParams as any).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 as VxeTooltipInstance
+        if ($tooltip && $tooltip.open) {
           $tooltip.open(evnt.currentTarget, content)
         }
       })
@@ -4227,23 +4784,44 @@ const Methods = {
    * 触发表头 tooltip 事件
    */
   triggerHeaderTooltipEvent (evnt: any, params: any) {
-    const { tooltipStore } = this
+    const $xeTable = this as VxeTableConstructor & VxeTablePrivateMethods
+    const reactData = $xeTable as unknown as TableReactData
+
+    const { tooltipStore } = reactData
     const { column } = params
-    const titleElem = evnt.currentTarget
-    this.handleTargetEnterEvent(tooltipStore.column !== column || tooltipStore.row)
+    handleTargetEnterEvent($xeTable, true)
+    const titleElem = evnt.currentTarget as HTMLDivElement
+    if (!titleElem) {
+      return
+    }
+    const cellEl = titleElem.parentElement as HTMLDivElement
+    if (!cellEl) {
+      return
+    }
+    const thEl = cellEl.parentElement as HTMLTableCellElement
+    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: any, params: any) {
-    const { editConfig, editOpts, editStore, tooltipStore } = this
+    const $xeTable = this as VxeTableConstructor & VxeTablePrivateMethods
+    const props = $xeTable
+    const reactData = $xeTable as unknown as TableReactData
+
+    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 as HTMLTableCellElement
+    handleTargetEnterEvent($xeTable, tooltipStore.column !== column || tooltipStore.row !== row)
     // 单元格处于编辑状态时不触发提示框
     if (column.editRender && isEnableConf(editConfig)) {
       // 如果是行编辑模式
@@ -4256,67 +4834,24 @@ 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') as HTMLElement, null, params)
     }
   },
   /**
    * 触发表尾 tooltip 事件
    */
   triggerFooterTooltipEvent (evnt: any, params: any) {
+    const $xeTable = this as VxeTableConstructor & VxeTablePrivateMethods
+    const reactData = $xeTable as unknown as TableReactData
+
     const { column } = params
-    const { tooltipStore } = this
-    const cell = evnt.currentTarget
-    this.handleTargetEnterEvent(true)
+    const { tooltipStore } = reactData
+    const cell = evnt.currentTarget as HTMLTableCellElement
+    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') as HTMLElement || cell.children[0], null, params)
     }
   },
-  /**
-   * 处理显示 tooltip
-   * @param {Event} evnt 事件
-   * @param {ColumnInfo} column 列配置
-   * @param {Row} row 行对象
-   */
-  handleTooltip (evnt: any, cell: any, overflowElem: any, tipElem: any, params: any) {
-    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: any, content: any) {
     const { $refs } = this
     const commTip = $refs.refCommTooltip
@@ -4329,9 +4864,12 @@ const Methods = {
    * 关闭 tooltip
    */
   closeTooltip () {
-    const { $refs, tooltipStore } = this
-    const tooltip = $refs.tooltip
-    const commTip = $refs.refCommTooltip
+    const $xeTable = this as VxeTableConstructor & VxeTablePrivateMethods
+    const reactData = $xeTable as unknown as TableReactData
+
+    const { tooltipStore } = reactData
+    const tooltip = $xeTable.$refs.refTooltip as VxeTooltipInstance
+    const commTip = $xeTable.$refs.refCommTooltip as VxeTooltipInstance
     if (tooltipStore.visible) {
       Object.assign(tooltipStore, {
         row: null,
@@ -5336,21 +5874,26 @@ const Methods = {
     }
     this.hoverRow = null
   },
-  triggerHeaderCellClickEvent (evnt: any, params: any) {
-    const { _lastResizeTime, sortOpts } = this
+  triggerHeaderCellClickEvent (evnt: MouseEvent, params: VxeTableDefines.CellRenderHeaderParams) {
+    const $xeTable = this as VxeTableConstructor & VxeTablePrivateMethods
+    const internalData = $xeTable as unknown as TableInternalData
+
+    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: any, params: any) {
     this.emitEvent('header-cell-dblclick', Object.assign({ cell: evnt.currentTarget }, params), evnt)
@@ -5404,8 +5947,21 @@ const Methods = {
    */
   triggerCellClickEvent (evnt: MouseEvent, params: VxeTableDefines.CellRenderBodyParams) {
     const $xeTable = this
+    const props = $xeTable
+    const reactData = $xeTable
 
-    const { highlightCurrentRow, editStore, radioOpts, expandOpts, treeOpts, keyboardOpts, editConfig, editOpts, checkboxOpts, rowOpts } = this
+    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
@@ -5489,7 +6045,16 @@ const Methods = {
    * 如果是双击模式，则激活为编辑状态
    */
   triggerCellDblclickEvent (evnt: MouseEvent, params: VxeTableDefines.CellRenderBodyParams) {
-    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 as HTMLDivElement
     params = Object.assign({ cell }, params)
@@ -5560,10 +6125,13 @@ const Methods = {
     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 })
       }
@@ -5667,7 +6235,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
@@ -5677,17 +6245,15 @@ const Methods = {
     if (prevDragRow && dragRow) {
       // 判断是否有拖动
       if (prevDragRow !== dragRow) {
-        return Promise.resolve(
-          dEndMethod
-            ? dEndMethod({
-              oldRow: dragRow,
-              newRow: prevDragRow,
-              dragPos: prevDragPos as any,
-              dragToChild: !!prevDragToChild,
-              offsetIndex: dragOffsetIndex
-            })
-            : true
-        ).then((status) => {
+        const dragParams = {
+          oldRow: dragRow,
+          newRow: prevDragRow,
+          dragPos: prevDragPos as 'top' | 'bottom',
+          dragToChild: !!prevDragToChild,
+          offsetIndex: dragOffsetIndex as 0 | 1
+        }
+        const isDragToChildFlag = isSelfToChildDrag && dragToChildMethod ? dragToChildMethod(dragParams) : prevDragToChild
+        return Promise.resolve(dEndMethod ? dEndMethod(dragParams) : true).then((status) => {
           if (!status) {
             return
           }
@@ -5767,7 +6333,11 @@ const Methods = {
                   // 根到根
                 }
 
-                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)
@@ -5784,13 +6354,13 @@ 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
                 })
               }
             }
@@ -5811,7 +6381,7 @@ const Methods = {
 
           reactData.isDragRowMove = true
           $xeTable.handleTableData(treeConfig && transform)
-          $xeTable.cacheRowMap()
+          $xeTable.cacheRowMap(false)
           updateScrollYStatus($xeTable)
           if (!(treeConfig && transform)) {
             updateAfterDataIndex($xeTable)
@@ -5829,7 +6399,7 @@ const Methods = {
             oldRow: dragRow,
             newRow: prevDragRow,
             dragPos: prevDragPos as any,
-            dragToChild: !!prevDragToChild,
+            dragToChild: isDragToChildFlag,
             offsetIndex: dragOffsetIndex,
             _index: {
               newIndex: nafIndex,
@@ -5856,18 +6426,16 @@ const Methods = {
     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)
@@ -5989,7 +6557,7 @@ const Methods = {
 
     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) {
@@ -5997,17 +6565,15 @@ const Methods = {
       if (prevDragCol !== dragCol) {
         const oldColumn = dragCol
         const newColumn = prevDragCol
-        return Promise.resolve(
-          dragEndMethod
-            ? dragEndMethod({
-              oldColumn,
-              newColumn,
-              dragPos: prevDragPos as any,
-              dragToChild: !!prevDragToChild,
-              offsetIndex: dragOffsetIndex
-            })
-            : true
-        ).then((status) => {
+        const dragParams = {
+          oldColumn,
+          newColumn,
+          dragPos: prevDragPos as 'left' | 'right',
+          dragToChild: !!prevDragToChild,
+          offsetIndex: dragOffsetIndex as 0 | 1
+        }
+        const isDragToChildFlag = isSelfToChildDrag && dragToChildMethod ? dragToChildMethod(dragParams) : prevDragToChild
+        return Promise.resolve(dragEndMethod ? dragEndMethod(dragParams) : true).then((status) => {
           if (!status) {
             return
           }
@@ -6103,7 +6669,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])
             } else {
@@ -6137,7 +6703,7 @@ const Methods = {
             oldColumn,
             newColumn,
             dragPos: prevDragPos,
-            dragToChild: !!prevDragToChild,
+            dragToChild: isDragToChildFlag,
             offsetIndex: dragOffsetIndex,
             _index: {
               newIndex: nafIndex,
@@ -7169,13 +7735,18 @@ const Methods = {
    * 获取表格的滚动状态
    */
   getScroll () {
-    const { $refs, scrollXLoad, scrollYLoad } = this
-    const bodyElem = $refs.refTableBody.$el
+    const $xeTable = this as VxeTableConstructor & VxeTablePrivateMethods
+    const reactData = $xeTable as unknown as TableReactData
+    const internalData = $xeTable as unknown as TableInternalData
+
+    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: Event, isRollY: boolean, isRollX: boolean, scrollTop: number, scrollLeft: number, params: any) {
@@ -7280,48 +7851,6 @@ const Methods = {
     }
     $xeTable.dispatchEvent('scroll', evntParams, evnt)
   },
-  lazyScrollXData () {
-    const $xeTable = this as VxeTableConstructor & VxeTablePrivateMethods
-    const internalData = $xeTable as unknown as TableInternalData
-
-    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 as VxeTableConstructor & VxeTablePrivateMethods
-    const props = $xeTable
-    const internalData = $xeTable as unknown as TableInternalData
-
-    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 可视渲染事件处理
    */
@@ -7332,7 +7861,7 @@ const Methods = {
     if (sXOpts.immediate) {
       loadScrollXData($xeTable)
     } else {
-      $xeTable.lazyScrollXData()
+      lazyScrollXData($xeTable)
     }
   },
   /**
@@ -7345,14 +7874,14 @@ const Methods = {
     if (sYOpts.immediate) {
       loadScrollYData($xeTable)
     } else {
-      $xeTable.lazyScrollYData()
+      lazyScrollYData($xeTable)
     }
   },
   triggerBodyScrollEvent (evnt: Event, fixedType: '' | 'left' | 'right') {
     const $xeTable = this as VxeTableConstructor & VxeTablePrivateMethods
     const internalData = $xeTable as unknown as TableInternalData
 
-    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 as HTMLDivElement
     const yHandleEl = $xeTable.$refs.refScrollYHandleElem as HTMLDivElement
     const leftScrollElem = getRefElem(elemStore['left-body-scroll'])
@@ -7363,6 +7892,9 @@ const Methods = {
     if (inWheelScroll || inVirtualScroll || inHeaderScroll || inFooterScroll) {
       return
     }
+    if (intoRunScroll) {
+      return
+    }
     if (!bodyScrollElem) {
       return
     }
@@ -7420,22 +7952,16 @@ const Methods = {
     const $xeTable = this as VxeTableConstructor & VxeTablePrivateMethods
     const internalData = $xeTable as unknown as TableInternalData
 
-    const { elemStore, inWheelScroll, inVirtualScroll, inBodyScroll, inFooterScroll } = internalData
+    const { elemStore, intoRunScroll, inWheelScroll, inVirtualScroll, inBodyScroll, inFooterScroll } = internalData
     const xHandleEl = $xeTable.$refs.refScrollXHandleElem as HTMLDivElement
     const yHandleEl = $xeTable.$refs.refScrollYHandleElem as HTMLDivElement
     const bodyScrollElem = getRefElem(elemStore['main-body-scroll'])
     const headerScrollElem = getRefElem(elemStore['main-header-scroll'])
     const footerScrollElem = getRefElem(elemStore['main-footer-scroll'])
-    if (inWheelScroll) {
+    if (inWheelScroll || inVirtualScroll || inBodyScroll || inFooterScroll) {
       return
     }
-    if (inVirtualScroll) {
-      return
-    }
-    if (inBodyScroll) {
-      return
-    }
-    if (inFooterScroll) {
+    if (intoRunScroll) {
       return
     }
     if (!headerScrollElem) {
@@ -7465,22 +7991,16 @@ const Methods = {
     const $xeTable = this as VxeTableConstructor & VxeTablePrivateMethods
     const internalData = $xeTable as unknown as TableInternalData
 
-    const { elemStore, inWheelScroll, inVirtualScroll, inHeaderScroll, inBodyScroll } = internalData
+    const { elemStore, intoRunScroll, inWheelScroll, inVirtualScroll, inHeaderScroll, inBodyScroll } = internalData
     const xHandleEl = $xeTable.$refs.refScrollXHandleElem as HTMLDivElement
     const yHandleEl = $xeTable.$refs.refScrollYHandleElem as HTMLDivElement
     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 (inHeaderScroll) {
+    if (inWheelScroll || inVirtualScroll || inHeaderScroll || inBodyScroll) {
       return
     }
-    if (inBodyScroll) {
+    if (intoRunScroll) {
       return
     }
     if (!footerScrollElem) {
@@ -7512,7 +8032,10 @@ const Methods = {
     const reactData = $xeTable as unknown as TableReactData
     const internalData = $xeTable as unknown as TableInternalData
 
-    const { deltaY, deltaX } = evnt
+    const { target, deltaY, deltaX } = evnt
+    if (target && /^textarea$/i.test((target as HTMLElement).tagName)) {
+      return
+    }
     const { highlightHoverRow } = tableProps
     const { elemStore, lastScrollTop, lastScrollLeft } = internalData
     const rowOpts = $xeTable.computeRowOpts
@@ -7532,29 +8055,14 @@ const Methods = {
       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
     }
 
@@ -7570,16 +8078,31 @@ const Methods = {
         $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: number) => {
+        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: Event) {
@@ -7653,17 +8176,15 @@ const Methods = {
     })
   },
   updateScrollXData () {
-    const $xeTable = this
-    const props = $xeTable
+    const $xeTable = this as VxeTableConstructor & VxeTablePrivateMethods
+    const reactData = $xeTable as unknown as TableReactData
 
-    const { showOverflow } = props
+    const { isAllOverflow } = reactData
     handleTableColumn($xeTable)
-    // calcCellHeight()
     return $xeTable.$nextTick().then(() => {
-      // calcCellHeight()
       handleTableColumn($xeTable)
       $xeTable.updateScrollXSpace()
-      if (!showOverflow) {
+      if (!isAllOverflow) {
         $xeTable.updateScrollYSpace()
       }
     })
@@ -7721,9 +8242,7 @@ const Methods = {
     const $xeTable = this
 
     $xeTable.handleTableData()
-    // calcCellHeight()
     return $xeTable.$nextTick().then(() => {
-      // calcCellHeight()
       $xeTable.handleTableData()
       $xeTable.updateScrollYSpace()
     })
@@ -7731,38 +8250,37 @@ const Methods = {
   // 更新纵向 Y 可视渲染上下剩余空间大小
   updateScrollYSpace () {
     const $xeTable = this as VxeTableConstructor & VxeTablePrivateMethods
-    const props = $xeTable
     const reactData = $xeTable as unknown as TableReactData
     const internalData = $xeTable as unknown as TableInternalData
 
-    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
         }
       }
     } else {
@@ -7787,7 +8305,7 @@ const Methods = {
     if (scrollYSpaceEl) {
       scrollYSpaceEl.style.height = ySpaceHeight ? `${ySpaceHeight}px` : ''
     }
-    $xeTable.$nextTick(() => {
+    return $xeTable.$nextTick().then(() => {
       updateStyle($xeTable)
     })
   },
@@ -7852,11 +8370,9 @@ const Methods = {
    */
   scrollToRow (row: any, fieldOrColumn?: VxeColumnPropTypes.Field | VxeTableDefines.ColumnInfo) {
     const $xeTable = this as VxeTableConstructor & VxeTablePrivateMethods
-    const props = $xeTable
     const reactData = $xeTable as unknown as TableReactData
 
-    const { showOverflow } = props
-    const { scrollYLoad, scrollXLoad } = reactData
+    const { isAllOverflow, scrollYLoad, scrollXLoad } = reactData
     const rest = []
     if (row) {
       if (this.treeConfig) {
@@ -7870,7 +8386,7 @@ const Methods = {
     }
     return Promise.all(rest).then(() => {
       if (row) {
-        if (!showOverflow && (scrollYLoad || scrollXLoad)) {
+        if (!isAllOverflow && (scrollYLoad || scrollXLoad)) {
           calcCellHeight($xeTable)
           calcCellWidth($xeTable)
         }