vxe-table 3.17.6 → 3.17.8

package/packages/table/src/methods.ts

@@ -8,7 +8,7 @@ import { getSlotVNs } from '../../ui/src/vn'
 import { moveRowAnimateToTb, clearRowAnimate, moveColAnimateToLr, clearColAnimate } from './anime'
 import { warnLog, errLog } from '../../ui/src/log'
 
-import type { VxeTableDefines, VxeColumnPropTypes, VxeTableEmits, ValueOf, TableReactData, VxeTableConstructor, VxeToolbarConstructor, TableInternalData, VxeGridConstructor, GridPrivateMethods, VxeTablePrivateMethods, VxeTooltipInstance, VxeTablePropTypes } from '../../../types'
+import type { VxeTableDefines, VxeColumnPropTypes, VxeTableEmits, ValueOf, TableReactData, VxeTableConstructor, VxeToolbarConstructor, VxeToolbarInstance, TableInternalData, VxeGridConstructor, GridPrivateMethods, VxeTablePrivateMethods, VxeTooltipInstance, VxeTablePropTypes } from '../../../types'
 
 const { getConfig, getI18n, renderer, formats, interceptor, createEvent } = VxeUI
 
@@ -971,14 +971,15 @@ function updateStyle ($xeTable: VxeTableConstructor & VxeTablePrivateMethods) {
   const internalData = $xeTable as unknown as TableInternalData
 
   const { showHeaderOverflow: allColumnHeaderOverflow, showFooterOverflow: allColumnFooterOverflow, mouseConfig, spanMethod, footerSpanMethod } = props
-  const { isGroup, currentRow, tableColumn, scrollXLoad, scrollYLoad, overflowX, scrollbarWidth, overflowY, scrollbarHeight, scrollXWidth, columnStore, editStore, isAllOverflow, expandColumn, isColLoading } = reactData
-  const { visibleColumn, tableHeight, headerHeight, footerHeight, elemStore, customHeight, customMinHeight, customMaxHeight } = internalData
+  const { isGroup, currentRow, tableColumn, scrollXLoad, scrollYLoad, overflowX, scrollbarWidth, overflowY, scrollbarHeight, scrollXWidth, columnStore, editStore, isAllOverflow, expandColumn, isColLoading, tHeaderHeight, tFooterHeight } = reactData
+  const { visibleColumn, tableHeight, elemStore, customHeight, customMinHeight, customMaxHeight } = internalData
+  const $xeGanttView = internalData.xeGanttView
   const el = $xeTable.$refs.refElem as HTMLDivElement
-  if (!el) {
+  if (!el || !el.clientHeight) {
     return
   }
   const containerList = ['main', 'left', 'right']
-  const osbWidth = overflowY ? scrollbarWidth : 0
+  let osbWidth = overflowY ? scrollbarWidth : 0
   const osbHeight = overflowX ? scrollbarHeight : 0
   const emptyPlaceholderElem = $xeTable.$refs.refEmptyPlaceholder as HTMLDivElement
   const mouseOpts = $xeTable.computeMouseOpts
@@ -986,39 +987,49 @@ function updateStyle ($xeTable: VxeTableConstructor & VxeTablePrivateMethods) {
   const bodyWrapperElem = getRefElem(elemStore['main-body-wrapper'])
   const bodyTableElem = getRefElem(elemStore['main-body-table'])
   if (emptyPlaceholderElem) {
-    emptyPlaceholderElem.style.top = `${headerHeight}px`
+    emptyPlaceholderElem.style.top = `${tHeaderHeight}px`
     emptyPlaceholderElem.style.height = bodyWrapperElem ? `${bodyWrapperElem.offsetHeight - osbHeight}px` : ''
   }
 
-  let bodyHeight = 0
+  const scrollbarXToTop = $xeTable.computeScrollbarXToTop
+  const scrollbarYToLeft = $xeTable.computeScrollbarYToLeft
+
+  const xScrollbarVisible = overflowX ? 'visible' : 'hidden'
+  let yScrollbarVisible = overflowY ? 'visible' : 'hidden'
+  if ($xeGanttView) {
+    if (!scrollbarYToLeft) {
+      osbWidth = 0
+      yScrollbarVisible = 'hidden'
+    }
+  }
+
+  let tbHeight = 0
   let bodyMaxHeight = 0
-  const bodyMinHeight = customMinHeight - headerHeight - footerHeight - osbHeight
+  const bodyMinHeight = customMinHeight - tHeaderHeight - tFooterHeight - osbHeight
   if (customMaxHeight) {
-    bodyMaxHeight = Math.max(bodyMinHeight, customMaxHeight - headerHeight - footerHeight - osbHeight)
+    bodyMaxHeight = Math.max(bodyMinHeight, customMaxHeight - tHeaderHeight - tFooterHeight - osbHeight)
   }
   if (customHeight) {
-    bodyHeight = customHeight - headerHeight - footerHeight - osbHeight
+    tbHeight = customHeight - tHeaderHeight - tFooterHeight - osbHeight
   }
-  if (!bodyHeight) {
+  if (!tbHeight) {
     if (bodyTableElem) {
-      bodyHeight = bodyTableElem.clientHeight
+      tbHeight = bodyTableElem.clientHeight
     }
   }
-  if (bodyHeight) {
+  if (tbHeight) {
     if (bodyMaxHeight) {
-      bodyHeight = Math.min(bodyMaxHeight, bodyHeight)
+      tbHeight = Math.min(bodyMaxHeight, tbHeight)
     }
-    bodyHeight = Math.max(bodyMinHeight, bodyHeight)
+    tbHeight = Math.max(bodyMinHeight, tbHeight)
   }
 
-  const scrollbarXToTop = $xeTable.$refs.computeScrollbarXToTop
-
   const xLeftCornerEl = $xeTable.$refs.refScrollXLeftCornerElem as HTMLDivElement
   const xRightCornerEl = $xeTable.$refs.refScrollXRightCornerElem as HTMLDivElement
   const scrollXVirtualEl = $xeTable.$refs.refScrollXVirtualElem as HTMLDivElement
   if (scrollXVirtualEl) {
     scrollXVirtualEl.style.height = `${osbHeight}px`
-    scrollXVirtualEl.style.visibility = overflowX ? 'visible' : 'hidden'
+    scrollXVirtualEl.style.visibility = xScrollbarVisible
   }
   const xWrapperEl = $xeTable.$refs.refScrollXWrapperElem as HTMLDivElement
   if (xWrapperEl) {
@@ -1037,32 +1048,34 @@ function updateStyle ($xeTable: VxeTableConstructor & VxeTablePrivateMethods) {
   const scrollYVirtualEl = $xeTable.$refs.refScrollYVirtualElem as HTMLDivElement
   if (scrollYVirtualEl) {
     scrollYVirtualEl.style.width = `${osbWidth}px`
-    scrollYVirtualEl.style.height = `${bodyHeight + headerHeight + footerHeight}px`
-    scrollYVirtualEl.style.visibility = overflowY ? 'visible' : 'hidden'
+    scrollYVirtualEl.style.height = `${tbHeight + tHeaderHeight + tFooterHeight}px`
+    scrollYVirtualEl.style.visibility = yScrollbarVisible
   }
   const yTopCornerEl = $xeTable.$refs.refScrollYTopCornerElem as HTMLDivElement
   if (yTopCornerEl) {
-    yTopCornerEl.style.height = `${headerHeight}px`
-    yTopCornerEl.style.display = overflowY && headerHeight ? 'block' : ''
+    yTopCornerEl.style.height = `${tHeaderHeight}px`
+    yTopCornerEl.style.display = overflowY && tHeaderHeight ? 'block' : ''
   }
   const yWrapperEl = $xeTable.$refs.refScrollYWrapperElem as HTMLDivElement
   if (yWrapperEl) {
-    yWrapperEl.style.height = `${bodyHeight}px`
-    yWrapperEl.style.top = `${headerHeight}px`
+    yWrapperEl.style.height = `${tbHeight}px`
+    yWrapperEl.style.top = `${tHeaderHeight}px`
   }
   const yBottomCornerEl = $xeTable.$refs.refScrollYBottomCornerElem as HTMLDivElement
   if (yBottomCornerEl) {
-    yBottomCornerEl.style.height = `${footerHeight}px`
-    yBottomCornerEl.style.top = `${headerHeight + bodyHeight}px`
-    yBottomCornerEl.style.display = overflowY && footerHeight ? 'block' : ''
+    yBottomCornerEl.style.height = `${tFooterHeight}px`
+    yBottomCornerEl.style.top = `${tHeaderHeight + tbHeight}px`
+    yBottomCornerEl.style.display = overflowY && tFooterHeight ? 'block' : ''
   }
 
   const rowExpandEl = $xeTable.$refs.refRowExpandElem as HTMLDivElement
   if (rowExpandEl) {
-    rowExpandEl.style.height = `${bodyHeight}px`
-    rowExpandEl.style.top = `${headerHeight}px`
+    rowExpandEl.style.height = `${tbHeight}px`
+    rowExpandEl.style.top = `${tHeaderHeight}px`
   }
 
+  reactData.tBodyHeight = tbHeight
+
   containerList.forEach((name, index) => {
     const fixedType = index > 0 ? name : ''
     const layoutList = ['header', 'body', 'footer']
@@ -1128,7 +1141,7 @@ function updateStyle ($xeTable: VxeTableConstructor & VxeTablePrivateMethods) {
         }
 
         if (currScrollElem) {
-          currScrollElem.style.height = `${headerHeight}px`
+          currScrollElem.style.height = `${tHeaderHeight}px`
         }
 
         if (tableElem) {
@@ -1137,16 +1150,16 @@ function updateStyle ($xeTable: VxeTableConstructor & VxeTablePrivateMethods) {
       } else if (layout === 'body') {
         if (currScrollElem) {
           currScrollElem.style.maxHeight = customMaxHeight ? `${bodyMaxHeight}px` : ''
-          currScrollElem.style.height = customHeight ? `${bodyHeight}px` : ''
+          currScrollElem.style.height = customHeight ? `${tbHeight}px` : ''
           currScrollElem.style.minHeight = `${bodyMinHeight}px`
         }
 
         // 如果是固定列
         if (fixedWrapperElem) {
           if (wrapperElem) {
-            wrapperElem.style.top = `${headerHeight}px`
+            wrapperElem.style.top = `${tHeaderHeight}px`
           }
-          fixedWrapperElem.style.height = `${customHeight > 0 ? customHeight : (tableHeight + headerHeight + footerHeight + osbHeight)}px`
+          fixedWrapperElem.style.height = `${customHeight > 0 ? customHeight : (tableHeight + tHeaderHeight + tFooterHeight + osbHeight)}px`
           fixedWrapperElem.style.width = `${fixedColumn.reduce((previous, column) => previous + column.renderWidth, 0)}px`
         }
 
@@ -1229,11 +1242,11 @@ function updateStyle ($xeTable: VxeTableConstructor & VxeTablePrivateMethods) {
         }
 
         if (currScrollElem) {
-          currScrollElem.style.height = `${footerHeight}px`
+          currScrollElem.style.height = `${tFooterHeight}px`
           // 如果是固定列
           if (fixedWrapperElem) {
             if (wrapperElem) {
-              wrapperElem.style.top = `${customHeight > 0 ? customHeight - footerHeight - osbHeight : tableHeight + headerHeight}px`
+              wrapperElem.style.top = `${customHeight > 0 ? customHeight - tFooterHeight - osbHeight : tableHeight + tHeaderHeight}px`
             }
           }
         }
@@ -1249,6 +1262,9 @@ function updateStyle ($xeTable: VxeTableConstructor & VxeTablePrivateMethods) {
   if (mouseConfig && mouseOpts.selected && editStore.selected.row && editStore.selected.column) {
     $xeTable.addCellSelectedClass()
   }
+  if ($xeGanttView) {
+    $xeGanttView.handleUpdateStyle()
+  }
   return $xeTable.$nextTick()
 }
 
@@ -2332,12 +2348,17 @@ function autoCellWidth ($xeTable: VxeTableConstructor & VxeTablePrivateMethods)
 const calcCellAutoHeight = (rowRest: VxeTableDefines.RowCacheItem, wrapperEl: HTMLDivElement) => {
   const cellElemList = wrapperEl.querySelectorAll(`.vxe-cell--wrapper[rowid="${rowRest.rowid}"]`)
   let colHeight = rowRest.height
+  let firstCellStyle: CSSStyleDeclaration | null = null
+  let topBottomPadding = 0
   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))
+    const wrapperElem = cellElemList[i] as HTMLElement
+    const cellElem = wrapperElem.parentElement as HTMLTableCellElement
+    if (!firstCellStyle) {
+      firstCellStyle = getComputedStyle(cellElem)
+      topBottomPadding = firstCellStyle ? Math.ceil(XEUtils.toNumber(firstCellStyle.paddingTop) + XEUtils.toNumber(firstCellStyle.paddingBottom)) : 0
+    }
+    const cellHeight = wrapperElem ? wrapperElem.clientHeight : 0
+    colHeight = Math.max(colHeight, Math.ceil(cellHeight + topBottomPadding))
   }
   return colHeight
 }
@@ -2757,13 +2778,13 @@ function calcScrollbar ($xeTable: VxeTableConstructor & VxeTablePrivateMethods)
     }
     reactData.overflowX = overflowX
 
-    const headerHeight = headerTableElem ? headerTableElem.clientHeight : 0
-    const footerHeight = footerTableElem ? footerTableElem.clientHeight : 0
+    const hHeight = headerTableElem ? headerTableElem.clientHeight : 0
+    const fHeight = footerTableElem ? footerTableElem.clientHeight : 0
     internalData.tableHeight = bodyWrapperElem.offsetHeight
-    internalData.headerHeight = headerHeight
-    internalData.footerHeight = footerHeight
-
-    reactData.parentHeight = Math.max(internalData.headerHeight + footerHeight + 20, $xeTable.getParentHeight())
+    reactData.tHeaderHeight = hHeight
+    reactData.tFooterHeight = fHeight
+    reactData.overflowX = overflowX
+    reactData.parentHeight = Math.max(hHeight + fHeight + 20, $xeTable.getParentHeight())
   }
   if (overflowX) {
     $xeTable.checkScrolling()
@@ -2823,6 +2844,7 @@ function handleLazyRecalculate ($xeTable: VxeTableConstructor & VxeTablePrivateM
 
   return new Promise<void>(resolve => {
     const { rceTimeout, rceRunTime } = internalData
+    const $xeGanttView = internalData.xeGanttView
     const resizeOpts = $xeTable.computeResizeOpts
     const refreshDelay = resizeOpts.refreshDelay || 20
     const el = $xeTable.$refs.refElem as HTMLElement
@@ -2846,6 +2868,9 @@ function handleLazyRecalculate ($xeTable: VxeTableConstructor & VxeTablePrivateM
         handleRecalculateStyle($xeTable, reFull, reWidth, reHeight)
       )
     }
+    if ($xeGanttView) {
+      $xeGanttView.handleLazyRecalculate()
+    }
     internalData.rceTimeout = setTimeout(() => {
       internalData.rceTimeout = undefined
       handleRecalculateStyle($xeTable, reFull, reWidth, reHeight)
@@ -3653,6 +3678,20 @@ const wheelScrollTopTo = (diffNum: number, cb: (progress: number) => void) => {
   requestAnimationFrame(step)
 }
 
+const syncGanttScrollTop = ($xeTable: VxeTableConstructor & VxeTablePrivateMethods, scrollTop: number) => {
+  const internalData = $xeTable as unknown as TableInternalData
+
+  const $xeGanttView = internalData.xeGanttView
+  if ($xeGanttView) {
+    const ganttInternalData = $xeGanttView.internalData
+    const { elemStore: ganttElemStore } = ganttInternalData
+    const ganttBodyScrollElem = getRefElem(ganttElemStore['main-body-scroll'])
+    if (ganttBodyScrollElem) {
+      ganttBodyScrollElem.scrollTop = scrollTop
+    }
+  }
+}
+
 function updateHeight ($xeTable: VxeTableConstructor & VxeTablePrivateMethods) {
   const reactData = $xeTable as unknown as TableReactData
   const internalData = $xeTable as unknown as TableInternalData
@@ -3983,6 +4022,7 @@ const Methods = {
 
     const { scrollYLoad } = reactData
     const { scrollYStore, fullDataRowIdData } = internalData
+    const $xeGanttView = internalData.xeGanttView
     let fullList: any[] = internalData.afterFullData
     // 是否进行数据处理
     if (force) {
@@ -4003,6 +4043,9 @@ const Methods = {
     })
     reactData.tableData = tableData
     internalData.visibleDataRowIdData = visibleDataRowIdMaps
+    if ($xeGanttView) {
+      $xeGanttView.updateViewData()
+    }
     return $xeTable.$nextTick()
   },
   /**
@@ -5792,12 +5835,14 @@ const Methods = {
   },
   handleRowResizeMousedownEvent (evnt: MouseEvent, params: VxeTableDefines.CellRenderBodyParams & { $table: VxeTableConstructor & VxeTablePrivateMethods }) {
     const $xeTable = this as VxeTableConstructor & VxeTablePrivateMethods
+    const props = $xeTable
     const reactData = $xeTable as unknown as TableReactData
     const internalData = $xeTable as unknown as TableInternalData
 
     evnt.stopPropagation()
     evnt.preventDefault()
     const { row } = params
+    const { showOverflow } = props
     const { overflowX, scrollbarWidth, overflowY, scrollbarHeight } = reactData
     const { elemStore, fullAllDataRowIdData } = internalData
     const osbWidth = overflowY ? scrollbarWidth : 0
@@ -5826,7 +5871,10 @@ const Methods = {
       return
     }
     const defaultRowHeight = $xeTable.computeDefaultRowHeight
-    const currCellHeight = rowRest.resizeHeight || cellOpts.height || rowOpts.height || rowRest.height || defaultRowHeight
+    let currCellHeight = rowRest.resizeHeight || cellOpts.height || rowOpts.height || rowRest.height || defaultRowHeight
+    if (!showOverflow) {
+      currCellHeight = tdEl.clientHeight
+    }
     const tableRect = tableEl.getBoundingClientRect()
     const trRect = trEl.getBoundingClientRect()
     const targetOffsetY = dragClientY - trRect.y - trEl.clientHeight
@@ -5992,6 +6040,29 @@ const Methods = {
     })
     return rest
   },
+  recalcRowHeight (rowOrId: any | any[]) {
+    const $xeTable = this as VxeTableConstructor & VxeTablePrivateMethods
+    const reactData = $xeTable as unknown as TableReactData
+    const internalData = $xeTable as unknown as TableInternalData
+
+    const { fullAllDataRowIdData } = internalData
+    const rows = XEUtils.isArray(rowOrId) ? rowOrId : [rowOrId]
+    const el = $xeTable.$refs.refElem as HTMLDivElement
+    if (el) {
+      const { handleGetRowId } = createHandleGetRowId($xeTable)
+      el.setAttribute('data-calc-row', 'Y')
+      rows.forEach(row => {
+        const rowid = XEUtils.isString(row) || XEUtils.isNumber(row) ? row : handleGetRowId(row)
+        const rowRest = fullAllDataRowIdData[rowid]
+        if (rowRest) {
+          rowRest.resizeHeight = calcCellAutoHeight(rowRest, el)
+        }
+        el.removeAttribute('data-calc-row')
+      })
+      reactData.calcCellHeightFlag++
+    }
+    return $xeTable.$nextTick()
+  },
   setRowHeight (rowOrId: any | any[], height: number) {
     const $xeTable = this as VxeTableConstructor & VxeTablePrivateMethods
     const reactData = $xeTable as unknown as TableReactData
@@ -10256,6 +10327,7 @@ const Methods = {
       }
       setScrollTop(yHandleEl, scrollTop)
       setScrollTop(rowExpandEl, scrollTop)
+      syncGanttScrollTop($xeTable, scrollTop)
       if (scrollYLoad) {
         $xeTable.triggerScrollYEvent(evnt)
       }
@@ -10460,6 +10532,7 @@ const Methods = {
         setScrollTop(leftScrollElem, currTopNum)
         setScrollTop(rightScrollElem, currTopNum)
         setScrollTop(rowExpandEl, currTopNum)
+        syncGanttScrollTop($xeTable, currTopNum)
         if (scrollYLoad) {
           $xeTable.triggerScrollYEvent(evnt)
         }
@@ -10476,6 +10549,7 @@ const Methods = {
           setScrollTop(leftScrollElem, currTopNum)
           setScrollTop(rightScrollElem, currTopNum)
           setScrollTop(rowExpandEl, currTopNum)
+          syncGanttScrollTop($xeTable, currTopNum)
           if (scrollYLoad) {
             $xeTable.triggerScrollYEvent(evnt)
           }
@@ -10559,6 +10633,7 @@ const Methods = {
     setScrollTop(leftScrollElem, scrollTop)
     setScrollTop(rightScrollElem, scrollTop)
     setScrollTop(rowExpandEl, scrollTop)
+    syncGanttScrollTop($xeTable, scrollTop)
     if (scrollYLoad) {
       $xeTable.triggerScrollYEvent(evnt)
     }
@@ -10590,6 +10665,7 @@ const Methods = {
 
     const { scrollXLoad, overflowX, scrollXWidth } = reactData
     const { visibleColumn, scrollXStore, elemStore, fullColumnIdData } = internalData
+    const $xeGanttView = internalData.xeGanttView
     const mouseOpts = $xeTable.computeMouseOpts
     const tableBody = $xeTable.$refs.refTableBody
     const tableBodyElem = tableBody ? (tableBody as any).$el as HTMLDivElement : null
@@ -10657,10 +10733,13 @@ const Methods = {
         scrollXSpaceEl.style.width = `${ySpaceWidth}px`
       }
 
+      calcScrollbar($xeTable)
       if (isScrollXBig && mouseOpts.area) {
         errLog('vxe.error.notProp', ['mouse-config.area'])
       }
-      calcScrollbar($xeTable)
+      if ($xeGanttView) {
+        $xeGanttView.updateScrollXSpace()
+      }
       return $xeTable.$nextTick(() => {
         updateStyle($xeTable)
       })
@@ -10684,6 +10763,7 @@ const Methods = {
 
     const { isAllOverflow, scrollYLoad, expandColumn } = reactData
     const { scrollYStore, elemStore, isResizeCellHeight, afterFullData, fullAllDataRowIdData, rowExpandedMaps } = internalData
+    const $xeGanttView = internalData.xeGanttView
     const { startIndex } = scrollYStore
     const mouseOpts = $xeTable.computeMouseOpts
     const expandOpts = $xeTable.computeExpandOpts
@@ -10778,10 +10858,13 @@ const Methods = {
     reactData.scrollYHeight = scrollYHeight
     reactData.isScrollYBig = isScrollYBig
 
+    calcScrollbar($xeTable)
     if (isScrollYBig && mouseOpts.area) {
       errLog('vxe.error.notProp', ['mouse-config.area'])
     }
-    calcScrollbar($xeTable)
+    if ($xeGanttView) {
+      $xeGanttView.updateScrollYSpace()
+    }
     return $xeTable.$nextTick().then(() => {
       updateStyle($xeTable)
     })
@@ -11160,16 +11243,38 @@ const Methods = {
     this.isActivated = false
     return this.$nextTick()
   },
-  // 连接工具栏
-  connect ($toolbar: any) {
+  /**
+   * 已废弃，被 connectToolbar 替换
+   * @deprecated
+   */
+  connect ($toolbar: VxeToolbarConstructor | VxeToolbarInstance) {
+    return this.connectToolbar($toolbar)
+  },
+  /**
+   * 连接工具栏
+   * @param $toolbar
+   */
+  connectToolbar ($toolbar: VxeToolbarConstructor | VxeToolbarInstance) {
+    const $xeTable = this as VxeTableConstructor & VxeTablePrivateMethods
+
     if ($toolbar && $toolbar.syncUpdate) {
-      $toolbar.syncUpdate({ collectColumn: this.collectColumn, $table: this })
+      $toolbar.syncUpdate({ collectColumn: this.collectColumn, $table: $xeTable })
       this.$toolbar = $toolbar
     } else {
       errLog('vxe.error.barUnableLink')
     }
     return this.$nextTick()
   },
+  handleConnectGanttView ($ganttView: any) {
+    const $xeTable = this as VxeTableConstructor & VxeTablePrivateMethods
+    const internalData = $xeTable as unknown as TableInternalData
+
+    if ($ganttView && $ganttView.connectUpdate) {
+      $ganttView.connectUpdate({ $table: $xeTable })
+      internalData.xeGanttView = $ganttView
+    }
+    return $xeTable.$nextTick()
+  },
 
   /*************************
    * Publish methods

package/packages/table/src/props.ts

@@ -5,7 +5,7 @@ import type { VxeTablePropTypes } from '../../../types'
 
 const { getConfig } = VxeUI
 
-export default {
+export const tableProps = {
   /** 基本属性 */
   id: [String, Function] as PropType<VxeTablePropTypes.ID>,
   // 数据

package/packages/table/src/table.ts

@@ -8,7 +8,7 @@ import methods from './methods'
 import TableBodyComponent from './body'
 import TableHeaderComponent from './header'
 import TableFooterComponent from './footer'
-import tableProps from './props'
+import { tableProps } from './props'
 import { getSlotVNs } from '../../ui/src/vn'
 import { warnLog, errLog } from '../../ui/src/log'
 import TableCustomPanelComponent from '../module/custom/panel'
@@ -522,6 +522,12 @@ export default {
       scrollbarHeight: 0,
       // 行高
       rowHeight: 0,
+      // 表头高度
+      tHeaderHeight: 0,
+      // 表体高度
+      tBodyHeight: 0,
+      // 表尾高度
+      tFooterHeight: 0,
       // 表格父容器的高度
       parentHeight: 0,
       // 是否使用分组表头
@@ -1410,28 +1416,20 @@ export default {
     },
 
     computeSize () {
-      this.reScrollFlag++
+      this.reLayoutFlag++
     },
     showHeader () {
-      this.reScrollFlag++
+      this.reLayoutFlag++
     },
     showFooter () {
-      this.reScrollFlag++
+      this.reLayoutFlag++
     },
     overflowX () {
-      this.reScrollFlag++
+      this.reLayoutFlag++
     },
     overflowY () {
-      this.reScrollFlag++
-    },
-    reScrollFlag () {
-      const $xeTable = this as VxeTableConstructor & VxeTablePrivateMethods
-
-      $xeTable.$nextTick(() => {
-        $xeTable.recalculate(true).then(() => $xeTable.refreshScroll())
-      })
+      this.reLayoutFlag++
     },
-
     height () {
       this.reLayoutFlag++
     },

package/packages/table/src/util.ts

@@ -36,10 +36,6 @@ export function createInternalData (): TableInternalData {
     tableWidth: 0,
     // 表格高度
     tableHeight: 0,
-    // 表头高度
-    headerHeight: 0,
-    // 表尾高度
-    footerHeight: 0,
     customHeight: 0,
     customMinHeight: 0,
     customMaxHeight: 0,

package/packages/toolbar/src/toolbar.ts

@@ -367,7 +367,7 @@ export default /* define-vxe-component start */ defineVxeComponent({
             $xeGrid.triggerToolbarBtnEvent(item, $event)
           } else {
             const gCommandOpts = commands.get(code)
-            const params = { code, button: item, $table: $table!, $grid: $xeGrid, $event }
+            const params = { code, button: item, $table: $table as VxeTableConstructor, $grid: $xeGrid, $gantt: null, $event }
             if (gCommandOpts) {
               const tCommandMethod = gCommandOpts.tableCommandMethod || gCommandOpts.commandMethod
               if (tCommandMethod) {
@@ -396,7 +396,7 @@ export default /* define-vxe-component start */ defineVxeComponent({
             $xeGrid.triggerToolbarTolEvent(item, $event)
           } else {
             const gCommandOpts = commands.get(code)
-            const params = { code, button: null, tool: item, $table: $table!, $grid: $xeGrid, $event }
+            const params = { code, button: null, tool: item, $table: $table as VxeTableConstructor, $grid: $xeGrid, $gantt: null, $event }
             if (gCommandOpts) {
               const tCommandMethod = gCommandOpts.tableCommandMethod || gCommandOpts.commandMethod
               if (tCommandMethod) {

package/packages/ui/index.ts

@@ -235,7 +235,15 @@ VxeUI.setConfig({
     },
     scrollbarConfig: {
       // width: 14,
-      // height: 14
+      // height: 14,
+      x: {
+        // position: 'bottom',
+        visible: true
+      },
+      y: {
+        // position: 'right',
+        visible: true
+      }
     }
   },
   // export: {
@@ -288,7 +296,9 @@ VxeUI.setConfig({
     //   types: ['csv', 'html', 'xml', 'txt']
     // },
     // buttons: []
-  }
+  },
+
+  gantt: {}
 })
 
 const iconPrefix = 'vxe-table-icon-'

package/packages/ui/src/dom.ts

@@ -100,7 +100,7 @@ export function getDomNode () {
   }
 }
 
-export function getOffsetHeight (elem: HTMLElement) {
+export function getOffsetHeight (elem?: HTMLElement) {
   return elem ? elem.offsetHeight : 0
 }
 

package/styles/cssvar.scss

@@ -1,3 +1 @@
-/*已废弃*/
-
 @use './base.scss';