vxe-table 4.23.0-beta.1 → 4.23.0-beta.2

package/es/table/src/table.js

@@ -7,6 +7,7 @@ import { VxeUI } from '../../ui';
 import { createReactData, createInternalData, getRowUniqueId, createRowId, clearTableAllStatus, getColumnList, toFilters, hasDeepKey, getRowkey, getRowid, rowToVisible, colToVisible, getCellValue, setCellValue, handleRowidOrRow, handleFieldOrColumn, toTreePathSeq, restoreScrollLocation, getRootColumn, getRefElem, getColReMinWidth, getColReMaxWidth, createHandleUpdateRowId, createHandleGetRowId, getCalcHeight, getCellRestHeight, getLastChildColumn, getRowMaxHeight, handleCustomStoreConfig, encodeRowid } from './util';
 import { getSlotVNs } from '../../ui/src/vn';
 import { moveRowAnimateToTb, clearRowAnimate, moveColAnimateToLr, clearColAnimate } from '../../ui/src/anime';
+import { getThumbOffsetSize, getThumbSize, getScrollFromClick, getScrollFromDrag } from './scrollbar';
 import { createComponentLog } from '../../ui/src/log';
 import { getCrossTableDragRowInfo } from './store';
 import Cell from './cell';
@@ -29,7 +30,7 @@ import '../module/validator/hook';
 import '../module/custom/hook';
 import '../render';
 const { warnLog, errLog } = createComponentLog('table');
-const { getConfig, getIcon, getI18n, renderer, formats, createEvent, globalResize, interceptor, hooks, globalEvents, GLOBAL_EVENT_KEYS, useFns, renderEmptyElement } = VxeUI;
+const { getConfig, getIcon, getI18n, renderer, formats, createEvent, globalResize, interceptor, hooks, domUtils, globalEvents, GLOBAL_EVENT_KEYS, useFns, renderEmptyElement } = VxeUI;
 const supportMaxRow = 5e6;
 const customStorageKey = 'VXE_CUSTOM_STORE';
 const maxYHeight = 5e6;
@@ -104,6 +105,10 @@ export default defineVxeComponent({
         const refScrollYBottomCornerElem = ref();
         const refScrollXSpaceElem = ref();
         const refScrollYSpaceElem = ref();
+        const refTrackXElem = ref();
+        const refTrackYElem = ref();
+        const refThumbXElem = ref();
+        const refThumbYElem = ref();
         let $xeToolbar;
         const computeTableId = computed(() => {
             const { id } = props;
@@ -194,6 +199,36 @@ export default defineVxeComponent({
             const scrollbarOpts = computeScrollbarOpts.value;
             return scrollbarOpts.y ? Object.assign({}, scrollbarOpts.y, scrollbarOpts.yConfig) : (scrollbarOpts.yConfig || {});
         });
+        const computeScrollXHeight = computed(() => {
+            const scrollbarOpts = computeScrollbarOpts.value;
+            const scrollbarXOpts = computeScrollbarXOpts.value;
+            return XEUtils.toNumber(getDefaultConfig(getDefaultConfig(scrollbarXOpts.height, scrollbarOpts.height), scrollDefaultConf.height));
+        });
+        const computeScrollYWidth = computed(() => {
+            const scrollbarOpts = computeScrollbarOpts.value;
+            const scrollbarYOpts = computeScrollbarYOpts.value;
+            return XEUtils.toNumber(getDefaultConfig(getDefaultConfig(scrollbarYOpts.width, scrollbarOpts.width), scrollDefaultConf.width));
+        });
+        const computeScrollXVisible = computed(() => {
+            const scrollbarOpts = computeScrollbarOpts.value;
+            const scrollbarXOpts = computeScrollbarXOpts.value;
+            return getDefaultConfig(scrollbarXOpts.visible, scrollbarOpts.visible);
+        });
+        const computeScrollYVisible = computed(() => {
+            const scrollbarOpts = computeScrollbarOpts.value;
+            const scrollbarYOpts = computeScrollbarYOpts.value;
+            return getDefaultConfig(scrollbarYOpts.visible, scrollbarOpts.visible);
+        });
+        const computeScrollXAutoHide = computed(() => {
+            const scrollbarOpts = computeScrollbarOpts.value;
+            const scrollbarXOpts = computeScrollbarXOpts.value;
+            return getDefaultConfig(getDefaultConfig(scrollbarXOpts.autoHide, scrollbarOpts.autoHide), scrollDefaultConf.autoHide);
+        });
+        const computeScrollYAutoHide = computed(() => {
+            const scrollbarOpts = computeScrollbarOpts.value;
+            const scrollbarYOpts = computeScrollbarYOpts.value;
+            return getDefaultConfig(getDefaultConfig(scrollbarYOpts.autoHide, scrollbarOpts.autoHide), scrollDefaultConf.autoHide);
+        });
         const computeScrollbarXToTop = computed(() => {
             const scrollbarXOpts = computeScrollbarXOpts.value;
             return scrollbarXOpts.position === 'top';
@@ -202,6 +237,23 @@ export default defineVxeComponent({
             const scrollbarYOpts = computeScrollbarYOpts.value;
             return scrollbarYOpts.position === 'left';
         });
+        const computeScrollbarWrapperClss = computed(() => {
+            const { yThumbHeight, xThumbWidth } = reactData;
+            const scrollbarXToTop = computeScrollbarXToTop.value;
+            const scrollbarYToLeft = computeScrollbarYToLeft.value;
+            const scrollXVisible = computeScrollXVisible.value;
+            const scrollYVisible = computeScrollYVisible.value;
+            return domUtils.buildClass([
+                'vxe-scrollbar is--virtual',
+                `ov-x--${scrollXVisible === false ? 'hidden' : 'visible'}`,
+                `ov-y--${scrollYVisible === false ? 'hidden' : 'visible'}`,
+                `sx-pos--${scrollbarXToTop ? 'top' : 'bottom'}`,
+                `sy-pos--${scrollbarYToLeft ? 'left' : 'right'}`
+            ], {
+                'overflow-y': yThumbHeight,
+                'overflow-x': xThumbWidth
+            });
+        });
         const computeScrollYThreshold = computed(() => {
             const virtualYOpts = computeVirtualYOpts.value;
             const { threshold } = virtualYOpts;
@@ -231,6 +283,10 @@ export default defineVxeComponent({
             }
             return cellOpts;
         });
+        const computeCellHeitht = computed(() => {
+            const cellOpts = computeCellOpts.value;
+            return cellOpts.height;
+        });
         const computeHeaderCellOpts = computed(() => {
             const headerCellOpts = Object.assign({}, getConfig().table.headerCellConfig, props.headerCellConfig);
             const defaultRowHeight = computeDefaultRowHeight.value;
@@ -538,11 +594,8 @@ export default defineVxeComponent({
             return '';
         });
         const computeTableStyle = computed(() => {
-            const scrollbarOpts = computeScrollbarOpts.value;
-            const scrollbarXOpts = computeScrollbarXOpts.value;
-            const scrollbarYOpts = computeScrollbarYOpts.value;
-            const barWidth = getDefaultConfig(getDefaultConfig(scrollbarYOpts.width, scrollbarOpts.width), scrollDefaultConf.width);
-            const barHeight = getDefaultConfig(getDefaultConfig(scrollbarXOpts.height, scrollbarOpts.height), scrollDefaultConf.height);
+            const barWidth = computeScrollYWidth.value;
+            const barHeight = computeScrollXHeight.value;
             const stys = {};
             if (barWidth || barHeight) {
                 stys['--vxe-ui-table-view-scrollbar-width'] = toCssUnit(barWidth || barHeight);
@@ -741,8 +794,15 @@ export default defineVxeComponent({
             computeScrollbarOpts,
             computeScrollbarXOpts,
             computeScrollbarYOpts,
+            computeScrollXHeight,
+            computeScrollYWidth,
+            computeScrollXVisible,
+            computeScrollYVisible,
+            computeScrollXAutoHide,
+            computeScrollYAutoHide,
             computeScrollbarXToTop,
             computeScrollbarYToLeft,
+            computeScrollbarWrapperClss,
             computeColumnOpts,
             computeCurrentColumnOpts,
             computeScrollXThreshold,
@@ -1863,14 +1923,6 @@ export default defineVxeComponent({
             if (!bodyWrapperElem) {
                 return;
             }
-            const yHandleEl = refScrollYHandleElem.value;
-            if (!yHandleEl) {
-                return;
-            }
-            const xHandleEl = refScrollXHandleElem.value;
-            if (!xHandleEl) {
-                return;
-            }
             const columnOpts = computeColumnOpts.value;
             let tWidth = 0;
             const minCellWidth = 40; // 列宽最少限制 40px
@@ -2470,12 +2522,12 @@ export default defineVxeComponent({
                 emptyPlaceholderElem.style.top = `${tHeaderHeight}px`;
                 emptyPlaceholderElem.style.height = bodyWrapperElem ? `${bodyWrapperElem.offsetHeight - osbHeight}px` : '';
             }
-            const scrollbarXOpts = computeScrollbarXOpts.value;
-            const scrollbarYOpts = computeScrollbarYOpts.value;
+            const scrollXVisible = computeScrollXVisible.value;
+            const scrollYVisible = computeScrollYVisible.value;
             const scrollbarYToLeft = computeScrollbarYToLeft.value;
             let xScrollbarVisible = overflowX ? 'visible' : 'hidden';
-            const hideXScroll = scrollbarXOpts.visible === false || scrollbarXOpts.visible === 'hidden';
-            if (!hideXScroll || $xeGanttView) {
+            const hideXScroll = scrollXVisible === false || scrollXVisible === 'hidden';
+            if (scrollXVisible === 'visible' || $xeGanttView) {
                 osbHeight = scrollbarHeight;
                 xScrollbarVisible = 'visible';
             }
@@ -2484,12 +2536,12 @@ export default defineVxeComponent({
                 xScrollbarVisible = 'hidden';
             }
             let yScrollbarVisible = overflowY ? 'visible' : 'hidden';
-            const showYScroll = !(scrollbarYOpts.visible === false || scrollbarYOpts.visible === 'hidden');
-            if (!showYScroll || (($xeGantt && $xeGanttView && $xeGantt.reactData.showRightView) && !scrollbarYToLeft)) {
+            const hideYScroll = scrollYVisible === false || scrollYVisible === 'hidden';
+            if (hideYScroll || (($xeGantt && $xeGanttView && $xeGantt.reactData.showRightView) && !scrollbarYToLeft)) {
                 osbWidth = 0;
                 yScrollbarVisible = 'hidden';
             }
-            else if (showYScroll) {
+            else if (scrollYVisible === 'visible') {
                 osbWidth = scrollbarWidth;
                 yScrollbarVisible = 'visible';
             }
@@ -3297,7 +3349,6 @@ export default defineVxeComponent({
         const calcScrollbar = () => {
             const { scrollXWidth, scrollYHeight } = reactData;
             const { elemStore } = internalData;
-            const scrollbarOpts = computeScrollbarOpts.value;
             const el = refElem.value;
             if (!el || !el.clientWidth) {
                 return;
@@ -3307,20 +3358,29 @@ export default defineVxeComponent({
             const footerTableElem = getRefElem(elemStore['main-footer-table']);
             const xHandleEl = refScrollXHandleElem.value;
             const yHandleEl = refScrollYHandleElem.value;
+            const thumbXElem = refThumbXElem.value;
+            const thumbYElem = refThumbYElem.value;
             let overflowY = false;
             let overflowX = false;
             if (bodyWrapperElem) {
-                const scrollbarXOpts = computeScrollbarXOpts.value;
-                const scrollbarYOpts = computeScrollbarYOpts.value;
-                const barWidth = XEUtils.toNumber(getDefaultConfig(getDefaultConfig(scrollbarYOpts.width, scrollbarOpts.width), scrollDefaultConf.width));
-                const barHeight = XEUtils.toNumber(getDefaultConfig(getDefaultConfig(scrollbarXOpts.height, scrollbarOpts.height), scrollDefaultConf.height));
+                const scrollbarOpts = computeScrollbarOpts.value;
+                const barWidth = computeScrollYWidth.value;
+                const barHeight = computeScrollXHeight.value;
                 overflowY = scrollYHeight > bodyWrapperElem.clientHeight;
-                if (yHandleEl) {
+                // 如果是虚拟滚动条
+                if (thumbYElem) {
+                    reactData.scrollbarHeight = scrollbarOpts.padding ? thumbYElem.offsetWidth : 0;
+                }
+                else if (yHandleEl) {
                     reactData.scrollbarWidth = (barWidth || barHeight) || (yHandleEl.offsetWidth - yHandleEl.clientWidth) || 14;
                 }
                 reactData.overflowY = overflowY;
                 overflowX = scrollXWidth > bodyWrapperElem.clientWidth;
-                if (xHandleEl) {
+                // 如果是虚拟滚动条
+                if (thumbXElem) {
+                    reactData.scrollbarHeight = scrollbarOpts.padding ? thumbXElem.offsetHeight : 0;
+                }
+                else if (xHandleEl) {
                     reactData.scrollbarHeight = (barHeight || barWidth) || (xHandleEl.offsetHeight - xHandleEl.clientHeight) || 14;
                 }
                 const hHeight = headerTableElem ? headerTableElem.clientHeight : 0;
@@ -3387,6 +3447,10 @@ export default defineVxeComponent({
                 }
             });
         };
+        const updateScrollbar = () => {
+            updateThumbSize();
+            updateThumbOffset();
+        };
         const defaultMinRunDelay = 50;
         const handleLazyRecalculate = (reFull, reWidth, reHeight, options) => {
             const minRunDelay = (options ? options.minRunDelay : defaultMinRunDelay) || defaultMinRunDelay;
@@ -3407,6 +3471,7 @@ export default defineVxeComponent({
                 const refreshDelay = resizeOpts.refreshDelay || 30;
                 const reDelay = rceDelay + refreshDelay;
                 const el = refElem.value;
+                updateScrollbar();
                 if (el && el.clientWidth) {
                     autoCellWidth();
                     updateRowExpandStyle();
@@ -11422,6 +11487,18 @@ export default defineVxeComponent({
                 }
                 return nextTick();
             },
+            /**
+             * @private
+             */
+            updateScrollbar() {
+                return updateScrollbar();
+            },
+            /**
+             * @private
+             */
+            updateThumbOffset() {
+                return updateThumbOffset();
+            },
             /**
              * 表头单元格按下事件
              */
@@ -12573,19 +12650,18 @@ export default defineVxeComponent({
             },
             handleScrollEvent(evnt, isRollY, isRollX, scrollTop, scrollLeft, params) {
                 const { highlightHoverRow } = props;
-                const { lastScrollLeft, lastScrollTop } = internalData;
-                const xHandleEl = refScrollXHandleElem.value;
-                const yHandleEl = refScrollYHandleElem.value;
-                if (!xHandleEl || !yHandleEl) {
+                const { elemStore, lastScrollLeft, lastScrollTop } = internalData;
+                const bodyScrollElem = getRefElem(elemStore['main-body-scroll']);
+                if (!bodyScrollElem) {
                     return;
                 }
                 const rowOpts = computeRowOpts.value;
                 const validTip = refValidTooltip.value;
                 const tooltip = refTooltip.value;
-                const bodyHeight = yHandleEl.clientHeight;
-                const bodyWidth = xHandleEl.clientWidth;
-                const scrollHeight = yHandleEl.scrollHeight;
-                const scrollWidth = xHandleEl.scrollWidth;
+                const bodyHeight = bodyScrollElem.clientHeight;
+                const bodyWidth = bodyScrollElem.clientWidth;
+                const scrollHeight = bodyScrollElem.scrollHeight;
+                const scrollWidth = bodyScrollElem.scrollWidth;
                 let isTop = false;
                 let isBottom = false;
                 let isLeft = false;
@@ -12647,6 +12723,7 @@ export default defineVxeComponent({
                     isLeft,
                     isRight,
                     direction }, params);
+                updateThumbOffset();
                 updateRowExpandStyle();
                 checkLastSyncScroll(isRollX, isRollY);
                 if (isRollX) {
@@ -12691,6 +12768,7 @@ export default defineVxeComponent({
                 }
             },
             triggerBodyScrollEvent(evnt, fixedType) {
+                const { useScrollbar } = props;
                 const { scrollYLoad, scrollXLoad } = reactData;
                 const { elemStore, intoRunScroll, lastScrollTop, lastScrollLeft, inWheelScroll, inVirtualScroll, inHeaderScroll, inBodyScroll, scrollRenderType, inFooterScroll } = internalData;
                 if (inWheelScroll || inVirtualScroll || inHeaderScroll || inFooterScroll) {
@@ -12710,19 +12788,21 @@ export default defineVxeComponent({
                 if (!bodyScrollElem) {
                     return;
                 }
-                if (!xHandleEl) {
-                    return;
-                }
-                if (!yHandleEl) {
-                    return;
+                if (!useScrollbar) {
+                    if (!xHandleEl) {
+                        return;
+                    }
+                    if (!yHandleEl) {
+                        return;
+                    }
                 }
                 if (inBodyScroll) {
                     if (scrollRenderType !== fixedType) {
                         return;
                     }
                 }
-                let scrollTop = yHandleEl.scrollTop;
-                let scrollLeft = xHandleEl.scrollLeft;
+                let scrollTop = 0;
+                let scrollLeft = 0;
                 if (leftScrollElem && fixedType === 'left') {
                     scrollTop = leftScrollElem.scrollTop;
                 }
@@ -12863,8 +12943,8 @@ export default defineVxeComponent({
                 const rightFixedWidth = computeRightFixedWidth.value;
                 const { elemStore, lastScrollTop, lastScrollLeft } = internalData;
                 const rowOpts = computeRowOpts.value;
-                const scrollbarXOpts = computeScrollbarXOpts.value;
-                const scrollbarYOpts = computeScrollbarYOpts.value;
+                const scrollXVisible = computeScrollXVisible.value;
+                const scrollYVisible = computeScrollYVisible.value;
                 const xHandleEl = refScrollXHandleElem.value;
                 const yHandleEl = refScrollYHandleElem.value;
                 const leftScrollElem = getRefElem(elemStore['left-body-scroll']);
@@ -12887,14 +12967,14 @@ export default defineVxeComponent({
                 const isRollY = overflowY && scrollTop !== lastScrollTop;
                 if (isRollX) {
                     // 如果禁用滚动
-                    if (scrollbarXOpts.visible === false || scrollbarXOpts.visible === 'hidden') {
+                    if (scrollXVisible === false || scrollXVisible === 'hidden') {
                         evnt.preventDefault();
                         return;
                     }
                 }
                 if (isRollY) {
                     // 如果禁用滚动
-                    if (scrollbarYOpts.visible === false || scrollbarYOpts.visible === 'hidden') {
+                    if (scrollYVisible === false || scrollYVisible === 'hidden') {
                         evnt.preventDefault();
                         return;
                     }
@@ -13459,6 +13539,168 @@ export default defineVxeComponent({
                 return nextTick();
             }
         };
+        const updateThumbSize = () => {
+            const { elemStore } = internalData;
+            const viewEl = getRefElem(elemStore['main-body-scroll']);
+            if (!viewEl) {
+                return;
+            }
+            if (!viewEl.clientHeight || !viewEl.clientHeight) {
+                return;
+            }
+            const trackXEl = refTrackXElem.value;
+            const xThumbWidth = trackXEl ? getThumbSize(viewEl.clientWidth, viewEl.scrollWidth, trackXEl.clientWidth) : 0;
+            const thumbXElem = refThumbXElem.value;
+            if (thumbXElem) {
+                thumbXElem.style.width = xThumbWidth + 'px';
+            }
+            reactData.xThumbWidth = xThumbWidth;
+            const trackYEl = refTrackYElem.value;
+            const yThumbHeight = trackYEl ? getThumbSize(viewEl.clientHeight, viewEl.scrollHeight, trackYEl.clientHeight) : 0;
+            const thumbYElem = refThumbYElem.value;
+            if (thumbYElem) {
+                thumbYElem.style.height = yThumbHeight + 'px';
+            }
+            reactData.yThumbHeight = yThumbHeight;
+        };
+        const updateThumbOffset = () => {
+            const { elemStore } = internalData;
+            const viewEl = getRefElem(elemStore['main-body-scroll']);
+            if (!viewEl) {
+                return;
+            }
+            if (!viewEl.clientHeight || !viewEl.clientHeight) {
+                return;
+            }
+            const { xThumbWidth, yThumbHeight } = reactData;
+            const trackXEl = refTrackXElem.value;
+            const thumbXElem = refThumbXElem.value;
+            const xThumbLeft = trackXEl && xThumbWidth ? getThumbOffsetSize(viewEl.scrollLeft, viewEl.clientWidth, viewEl.scrollWidth, trackXEl.clientWidth, xThumbWidth) : 0;
+            internalData.xThumbLeft = xThumbLeft;
+            if (thumbXElem && xThumbWidth) {
+                thumbXElem.style.width = xThumbWidth + 'px';
+                thumbXElem.style.transform = `translateX(${xThumbLeft}px)`;
+            }
+            const trackYEl = refTrackYElem.value;
+            const thumbYElem = refThumbYElem.value;
+            const yThumbTop = trackYEl && yThumbHeight ? getThumbOffsetSize(viewEl.scrollTop, viewEl.clientHeight, viewEl.scrollHeight, trackYEl.clientHeight, yThumbHeight) : 0;
+            internalData.yThumbTop = yThumbTop;
+            if (thumbYElem && yThumbHeight) {
+                thumbYElem.style.height = yThumbHeight + 'px';
+                thumbYElem.style.transform = `translateY(${yThumbTop}px)`;
+            }
+        };
+        const clickTrackXEvent = (evnt) => {
+            const { elemStore } = internalData;
+            const trackEl = evnt.currentTarget;
+            if (trackEl !== evnt.target) {
+                return;
+            }
+            const viewEl = getRefElem(elemStore['main-body-scroll']);
+            if (!viewEl) {
+                return;
+            }
+            const { xThumbWidth } = reactData;
+            const trackRect = trackEl.getBoundingClientRect();
+            viewEl.scrollTo({
+                left: getScrollFromClick(evnt.clientX - trackRect.left, viewEl.clientWidth, viewEl.scrollWidth, trackEl.clientWidth, xThumbWidth),
+                behavior: 'auto'
+            });
+        };
+        const clickTrackYEvent = (evnt) => {
+            const { elemStore } = internalData;
+            const trackEl = evnt.currentTarget;
+            if (trackEl !== evnt.target) {
+                return;
+            }
+            const viewEl = getRefElem(elemStore['main-body-scroll']);
+            if (!viewEl) {
+                return;
+            }
+            const { yThumbHeight } = reactData;
+            const trackRect = trackEl.getBoundingClientRect();
+            viewEl.scrollTo({
+                top: getScrollFromClick(evnt.clientY - trackRect.top, viewEl.clientHeight, viewEl.scrollHeight, trackEl.clientHeight, yThumbHeight),
+                behavior: 'auto'
+            });
+        };
+        const pointerdownThumbXEvent = (evnt) => {
+            const { elemStore } = internalData;
+            const thumbEl = evnt.currentTarget;
+            internalData.isThumbDrag = true;
+            thumbEl.setPointerCapture(evnt.pointerId);
+            const viewEl = getRefElem(elemStore['main-body-scroll']);
+            if (!viewEl) {
+                return;
+            }
+            const { xThumbWidth } = reactData;
+            const trackEl = thumbEl.parentElement;
+            const trackRect = trackEl.getBoundingClientRect();
+            const pointerPosition = evnt.clientX - trackRect.left;
+            // 记录 thumb 的偏移
+            const thumbOffset = getThumbOffsetSize(viewEl.scrollLeft, viewEl.clientWidth, viewEl.scrollWidth, trackEl.clientWidth, xThumbWidth);
+            internalData.thumbDragOffset = pointerPosition - thumbOffset;
+        };
+        const pointermoveThumbXEvent = (evnt) => {
+            const thumbEl = evnt.currentTarget;
+            if (!thumbEl.hasPointerCapture(evnt.pointerId)) {
+                return;
+            }
+            const { elemStore, isThumbDrag, thumbDragOffset } = internalData;
+            if (isThumbDrag) {
+                const viewEl = getRefElem(elemStore['main-body-scroll']);
+                if (!viewEl) {
+                    return;
+                }
+                const { xThumbWidth } = reactData;
+                const thumbEl = evnt.currentTarget;
+                const trackEl = thumbEl.parentElement;
+                const trackRect = trackEl.getBoundingClientRect();
+                // 更新偏移
+                viewEl.scrollLeft = getScrollFromDrag(evnt.clientX - trackRect.left, thumbDragOffset, viewEl.clientWidth, viewEl.scrollWidth, trackEl.clientWidth, xThumbWidth);
+            }
+        };
+        const cleatPointerThumbEvent = (evnt) => {
+            const thumbEl = evnt.currentTarget;
+            thumbEl.releasePointerCapture(evnt.pointerId);
+            internalData.isThumbDrag = false;
+        };
+        const pointerdownThumbYEvent = (evnt) => {
+            const { elemStore } = internalData;
+            const thumbEl = evnt.currentTarget;
+            internalData.isThumbDrag = true;
+            thumbEl.setPointerCapture(evnt.pointerId);
+            const viewEl = getRefElem(elemStore['main-body-scroll']);
+            if (!viewEl) {
+                return;
+            }
+            const { yThumbHeight } = reactData;
+            const trackEl = thumbEl.parentElement;
+            const trackRect = trackEl.getBoundingClientRect();
+            const pointerPosition = evnt.clientY - trackRect.top;
+            // 记录 thumb 的偏移
+            const thumbOffset = getThumbOffsetSize(viewEl.scrollTop, viewEl.clientHeight, viewEl.scrollHeight, trackEl.clientHeight, yThumbHeight);
+            internalData.thumbDragOffset = pointerPosition - thumbOffset;
+        };
+        const pointermoveThumbYEvent = (evnt) => {
+            const thumbEl = evnt.currentTarget;
+            if (!thumbEl.hasPointerCapture(evnt.pointerId)) {
+                return;
+            }
+            const { elemStore, isThumbDrag, thumbDragOffset } = internalData;
+            if (isThumbDrag) {
+                const viewEl = getRefElem(elemStore['main-body-scroll']);
+                if (!viewEl) {
+                    return;
+                }
+                const { yThumbHeight } = reactData;
+                const thumbEl = evnt.currentTarget;
+                const trackEl = thumbEl.parentElement;
+                const trackRect = trackEl.getBoundingClientRect();
+                // 更新偏移
+                viewEl.scrollTop = getScrollFromDrag(evnt.clientY - trackRect.top, thumbDragOffset, viewEl.clientHeight, viewEl.scrollHeight, trackEl.clientHeight, yThumbHeight);
+            }
+        };
         // 检测对应模块是否安装
         // 'openExport,openPrint,exportData,openImport,importData,saveFile,readFile,importByFile,print'.split(',').forEach(name => {
         //   ($xeTable as any)[name] = function () {
@@ -13483,6 +13725,8 @@ export default defineVxeComponent({
             const scrollbarOpts = computeScrollbarOpts.value;
             const scrollbarXOpts = computeScrollbarXOpts.value;
             const scrollbarYOpts = computeScrollbarYOpts.value;
+            const scrollXVisible = computeScrollXVisible.value;
+            const scrollYVisible = computeScrollYVisible.value;
             const { overscrollBehavior: overscrollXBehavior } = scrollbarXOpts;
             const { overscrollBehavior: overscrollYBehavior } = scrollbarYOpts;
             const isFixedLeft = fixedType === 'left';
@@ -13493,8 +13737,8 @@ export default defineVxeComponent({
                 ref: isFixedLeft ? refLeftContainer : refRightContainer,
                 class: [
                     `vxe-table--fixed-${fixedType}-wrapper`,
-                    `sx--${(scrollbarXOpts.visible === false || scrollbarXOpts.visible === 'hidden') ? 'hidden' : 'visible'}`,
-                    `sy--${(scrollbarYOpts.visible === false || scrollbarYOpts.visible === 'hidden') ? 'hidden' : 'visible'}`,
+                    `sx--${(scrollXVisible === false || scrollXVisible === 'hidden') ? 'hidden' : 'visible'}`,
+                    `sy--${(scrollYVisible === false || scrollYVisible === 'hidden') ? 'hidden' : 'visible'}`,
                     {
                         [`x-ob--${osXBehavior}`]: osXBehavior,
                         [`y-ob--${osYBehavior}`]: osYBehavior
@@ -13758,6 +14002,7 @@ export default defineVxeComponent({
         };
         const renderScrollY = () => {
             return h('div', {
+                key: 'vsy',
                 ref: refScrollYVirtualElem,
                 class: 'vxe-table--scroll-y-virtual'
             }, [
@@ -13795,12 +14040,15 @@ export default defineVxeComponent({
             const scrollbarOpts = computeScrollbarOpts.value;
             const scrollbarXOpts = computeScrollbarXOpts.value;
             const scrollbarYOpts = computeScrollbarYOpts.value;
+            const scrollXVisible = computeScrollXVisible.value;
+            const scrollYVisible = computeScrollYVisible.value;
             const { overscrollBehavior: overscrollXBehavior } = scrollbarXOpts;
             const { overscrollBehavior: overscrollYBehavior } = scrollbarYOpts;
             const { leftList, rightList } = columnStore;
             const osXBehavior = XEUtils.eqNull(overscrollXBehavior) ? scrollbarOpts.overscrollBehavior : overscrollXBehavior;
             const osYBehavior = XEUtils.eqNull(overscrollYBehavior) ? scrollbarOpts.overscrollBehavior : overscrollYBehavior;
             return h('div', {
+                key: 'tvw',
                 ref: refTableViewportElem,
                 class: ['vxe-table--viewport-wrapper', {
                         [`x-ob--${osXBehavior}`]: osXBehavior,
@@ -13810,8 +14058,8 @@ export default defineVxeComponent({
                 h('div', {
                     class: [
                         'vxe-table--main-wrapper',
-                        `sx--${(scrollbarXOpts.visible === false || scrollbarXOpts.visible === 'hidden') ? 'hidden' : 'visible'}`,
-                        `sy--${(scrollbarYOpts.visible === false || scrollbarYOpts.visible === 'hidden') ? 'hidden' : 'visible'}`
+                        `sx--${(scrollXVisible === false || scrollXVisible === 'hidden') ? 'hidden' : 'visible'}`,
+                        `sy--${(scrollYVisible === false || scrollYVisible === 'hidden') ? 'hidden' : 'visible'}`
                     ]
                 }, [
                     /**
@@ -13853,9 +14101,10 @@ export default defineVxeComponent({
                 renderRowExpandedVNs()
             ]);
         };
-        const renderBody = () => {
+        const renderNativeBody = () => {
             const scrollbarYToLeft = computeScrollbarYToLeft.value;
             return h('div', {
+                key: 'lnb',
                 class: 'vxe-table--layout-wrapper'
             }, scrollbarYToLeft
                 ? [
@@ -13867,6 +14116,72 @@ export default defineVxeComponent({
                     renderScrollY()
                 ]);
         };
+        const renderVirtualBody = () => {
+            const $xeGanttView = internalData.xeGanttView;
+            const { useScrollbar } = props;
+            const { xThumbWidth, yThumbHeight } = reactData;
+            const scrollbarOpts = computeScrollbarOpts.value;
+            const scrollXAutoHide = computeScrollXAutoHide.value;
+            const scrollYAutoHide = computeScrollYAutoHide.value;
+            const scrollXVisible = computeScrollXVisible.value;
+            const scrollYVisible = computeScrollYVisible.value;
+            const scrollbarXToTop = computeScrollbarXToTop.value;
+            const scrollbarYToLeft = computeScrollbarYToLeft.value;
+            const scrollbarWrapperClss = computeScrollbarWrapperClss.value;
+            const hideXScroll = scrollXVisible === false || scrollXVisible === 'hidden';
+            const hideYScroll = scrollYVisible === false || scrollYVisible === 'hidden';
+            return h('div', {
+                key: 'lvb',
+                class: ['vxe-table--layout-wrapper', `sx-pos--${scrollbarXToTop ? 'top' : 'bottom'}`, `sy-pos--${scrollbarYToLeft ? 'left' : 'right'}`, {
+                        'is--virtual-scrollbar': useScrollbar,
+                        'ov-padding': useScrollbar && scrollbarOpts.padding,
+                        'ov-x--auto-hide': useScrollbar && scrollXAutoHide,
+                        'ov-y--auto-hide': useScrollbar && scrollYAutoHide,
+                        'overflow-y': yThumbHeight,
+                        'overflow-x': xThumbWidth
+                    }]
+            }, [
+                renderViewport(),
+                h('div', {
+                    class: scrollbarWrapperClss
+                }, [
+                    hideXScroll
+                        ? renderEmptyElement($xeTable)
+                        : h('div', {
+                            ref: refTrackXElem,
+                            class: 'vxe-scrollbar--track-x',
+                            onClick: clickTrackXEvent
+                        }, [
+                            h('div', {
+                                ref: refThumbXElem,
+                                class: 'vxe-scrollbar--thumb-x',
+                                onPointerdown: pointerdownThumbXEvent,
+                                onPointermove: pointermoveThumbXEvent,
+                                onPointerup: cleatPointerThumbEvent,
+                                onPointercancel: cleatPointerThumbEvent,
+                                onLostpointercapture: cleatPointerThumbEvent
+                            })
+                        ]),
+                    hideYScroll || (($xeGantt && $xeGanttView && $xeGantt.reactData.showRightView) && !scrollbarYToLeft)
+                        ? renderEmptyElement($xeTable)
+                        : h('div', {
+                            ref: refTrackYElem,
+                            class: 'vxe-scrollbar--track-y',
+                            onClick: clickTrackYEvent
+                        }, [
+                            h('div', {
+                                ref: refThumbYElem,
+                                class: 'vxe-scrollbar--thumb-y',
+                                onPointerdown: pointerdownThumbYEvent,
+                                onPointermove: pointermoveThumbYEvent,
+                                onPointerup: cleatPointerThumbEvent,
+                                onPointercancel: cleatPointerThumbEvent,
+                                onLostpointercapture: cleatPointerThumbEvent
+                            })
+                        ])
+                ])
+            ]);
+        };
         const renderVN = () => {
             const { loading, stripe, useScrollbar, showHeader, height, treeConfig, mouseConfig, showFooter, highlightCell, highlightHoverRow, highlightHoverColumn, editConfig, editRules, importConfig, exportConfig, printConfig } = props;
             const { isGroup, overflowX, overflowY, scrollXLoad, scrollYLoad, tableData, initStore, isRowGroupStatus, columnStore, filterStore, customStore, tooltipStore } = reactData;
@@ -13972,15 +14287,17 @@ export default defineVxeComponent({
                 h('div', {
                     key: 'tw',
                     class: 'vxe-table--render-wrapper'
-                }, scrollbarXToTop
-                    ? [
-                        renderScrollX(),
-                        renderBody()
-                    ]
-                    : [
-                        renderBody(),
-                        renderScrollX()
-                    ]),
+                }, useScrollbar
+                    ? [renderVirtualBody()]
+                    : (scrollbarXToTop
+                        ? [
+                            renderScrollX(),
+                            renderNativeBody()
+                        ]
+                        : [
+                            renderNativeBody(),
+                            renderScrollX()
+                        ])),
                 /**
                  * 空数据
                  */
@@ -14287,6 +14604,7 @@ export default defineVxeComponent({
                 $xeTable.refreshColumn();
             });
         });
+        const reScrollFlag = ref(0);
         const reLayoutFlag = ref(0);
         watch(computeSize, () => {
             reLayoutFlag.value++;
@@ -14319,36 +14637,47 @@ export default defineVxeComponent({
         watch(() => props.maxHeight, () => {
             reLayoutFlag.value++;
         });
+        watch(() => VxeUI.getLanguage(), () => {
+            reLayoutFlag.value++;
+        });
         watch(computeScrollbarXToTop, () => {
+            reScrollFlag.value++;
             reLayoutFlag.value++;
         });
         watch(computeScrollbarYToLeft, () => {
+            reScrollFlag.value++;
             reLayoutFlag.value++;
         });
-        watch(() => VxeUI.getLanguage(), () => {
+        watch(computeScrollXVisible, () => {
+            reScrollFlag.value++;
             reLayoutFlag.value++;
         });
-        watch(() => {
-            const scrollbarXOpts = computeScrollbarXOpts.value;
-            return scrollbarXOpts.visible;
-        }, () => {
+        watch(computeScrollYVisible, () => {
+            reScrollFlag.value++;
             reLayoutFlag.value++;
         });
-        watch(() => {
-            const scrollbarYOpts = computeScrollbarYOpts.value;
-            return scrollbarYOpts.visible;
-        }, () => {
+        watch(computeScrollXHeight, () => {
+            reScrollFlag.value++;
             reLayoutFlag.value++;
         });
-        watch(() => {
-            const cellOpts = computeCellOpts.value;
-            return cellOpts.height;
-        }, () => {
+        watch(computeScrollYWidth, () => {
+            reScrollFlag.value++;
+            reLayoutFlag.value++;
+        });
+        watch(computeCellHeitht, () => {
             reLayoutFlag.value++;
         });
         watch(reLayoutFlag, () => {
             $xeTable.recalculate(true);
         });
+        watch(reScrollFlag, () => {
+            nextTick(() => {
+                $xeTable.updateScrollbar();
+                nextTick(() => {
+                    $xeTable.updateScrollbar();
+                });
+            });
+        });
         const footFlag = ref(0);
         watch(() => props.footerData ? props.footerData.length : -1, () => {
             footFlag.value++;
@@ -14464,7 +14793,6 @@ export default defineVxeComponent({
             }
         });
         $xeTable.preventEvent(null, 'created', { $table: $xeTable });
-        let resizeObserver;
         onActivated(() => {
             $xeTable.recalculate().then(() => $xeTable.refreshScroll());
             $xeTable.preventEvent(null, 'activated', { $table: $xeTable });
@@ -14480,7 +14808,7 @@ export default defineVxeComponent({
         });
         onMounted(() => {
             const { editConfig, exportConfig, importConfig, treeConfig, minHeight, keepSource, areaConfig } = props;
-            const { scrollXStore, scrollYStore } = internalData;
+            const { elemStore, scrollXStore, scrollYStore } = internalData;
             const columnOpts = computeColumnOpts.value;
             const columnDragOpts = computeColumnDragOpts.value;
             const aggregateOpts = computeAggregateOpts.value;
@@ -14753,12 +15081,26 @@ export default defineVxeComponent({
             handleUpdateRowGroup(groupFields);
             initData();
             nextTick(() => {
-                if (props.autoResize) {
-                    const el = refElem.value;
+                const { useScrollbar, autoResize } = props;
+                const el = refElem.value;
+                if (useScrollbar) {
+                    const viewInnerEl = getRefElem(elemStore['main-body-table']);
+                    const scrollObserver = globalResize.create(() => {
+                        reScrollFlag.value++;
+                    });
+                    if (el) {
+                        scrollObserver.observe(el);
+                    }
+                    if (viewInnerEl) {
+                        scrollObserver.observe(viewInnerEl);
+                    }
+                    internalData.scrollObserver = scrollObserver;
+                }
+                if (autoResize) {
                     const parentEl = $xeTable.getParentElem();
-                    resizeObserver = globalResize.create(() => {
+                    const resizeObserver = globalResize.create(() => {
                         if (props.autoResize) {
-                            layoutReFlag.value++;
+                            handleResizeEvent();
                         }
                     });
                     if (el) {
@@ -14767,6 +15109,7 @@ export default defineVxeComponent({
                     if (parentEl) {
                         resizeObserver.observe(parentEl);
                     }
+                    internalData.resizeObserver = resizeObserver;
                 }
             });
             if (virtualYOpts.mode !== 'scroll') {
@@ -14788,7 +15131,7 @@ export default defineVxeComponent({
             $xeTable.preventEvent(null, 'mounted', { $table: $xeTable });
         });
         onBeforeUnmount(() => {
-            const { _sToTime } = internalData;
+            const { resizeObserver, scrollObserver, _sToTime } = internalData;
             if (_sToTime) {
                 clearTimeout(_sToTime);
             }
@@ -14799,6 +15142,9 @@ export default defineVxeComponent({
             internalData.cvCacheMaps = {};
             internalData.prevDragRow = null;
             internalData.prevDragCol = null;
+            if (scrollObserver) {
+                scrollObserver.disconnect();
+            }
             if (resizeObserver) {
                 resizeObserver.disconnect();
             }