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

package/dist/all.esm.js

@@ -56,7 +56,7 @@ function getDefaultConfig(val1, def1) {
     return XEUtils.eqNull(val1) ? def1 : val1;
 }
 
-const version = "4.23.0-beta.0";
+const version = "4.23.0-beta.2";
 VxeUI.version = version;
 VxeUI.tableVersion = version;
 VxeUI.setConfig({
@@ -318,16 +318,14 @@ VxeUI.setConfig({
             oSize: 0
         },
         scrollbarConfig: {
-            // width: 14,
-            // height: 14,
-            x: {
-                // position: 'bottom',
-                visible: true
-            },
-            y: {
-                // position: 'right',
-                visible: true
-            }
+        // xConfig: {
+        //   // position: 'bottom',
+        //   // visible: true
+        // },
+        // yConfig: {
+        //   // position: 'right',
+        //   // visible: true
+        // }
         },
         undoRedoHistoryConfig: {
             stackSize: 50
@@ -940,7 +938,7 @@ function getPopupWrapperElement(panelElem) {
 }
 
 const { log } = VxeUI;
-const tableVersion = `table v${"4.23.0-beta.0"}`;
+const tableVersion = `table v${"4.23.0-beta.2"}`;
 function createComponentLog(name) {
     const uiVersion = VxeUI.uiVersion ? `ui v${VxeUI.uiVersion}` : '';
     const ganttVersion = VxeUI.ganttVersion ? `gantt v${VxeUI.ganttVersion}` : '';
@@ -1192,9 +1190,15 @@ function createInternalData$3() {
         // 当前行
         currentRow: null,
         currentCol: null,
-        // 最后滚动位置
-        lastScrollLeft: 0,
+        // resizeObserver: undefined,
+        // 滚动条
+        // scrollObserver: undefined,
+        // isThumbDrag: false,
+        thumbDragOffset: 0,
+        yThumbTop: 0,
+        xThumbLeft: 0,
         lastScrollTop: 0,
+        lastScrollLeft: 0,
         // 单选框属性，已选中保留的行
         radioReserveRow: null,
         // 复选框属性，已选中保留的行集合
@@ -1327,6 +1331,9 @@ function createReactData$2() {
         scrollbarWidth: 0,
         // 横向滚动条的高度
         scrollbarHeight: 0,
+        // 滚动条
+        yThumbHeight: 0,
+        xThumbWidth: 0,
         // 行高
         rowHeight: 0,
         // 表格父容器的高度
@@ -3852,7 +3859,10 @@ const tableProps = {
         type: Boolean,
         default: () => getConfig$7().table.highlightCurrentRow
     },
-    // （即将废弃）鼠标移到行是否要高亮显示
+    /**
+     * （即将废弃）鼠标移到行是否要高亮显示
+     * @deprecated
+     */
     highlightHoverRow: {
         type: Boolean,
         default: () => getConfig$7().table.highlightHoverRow
@@ -4075,6 +4085,10 @@ const tableProps = {
     virtualXConfig: Object,
     // 纵向虚拟滚动配置项
     virtualYConfig: Object,
+    useScrollbar: {
+        type: Boolean,
+        default: () => getDefaultConfig(getConfig$7().table.useScrollbar, getConfig$7().useScrollbar)
+    },
     // 滚动条配置项
     scrollbarConfig: Object,
     // 撤销/恢复历史配置项
@@ -4285,6 +4299,61 @@ function clearColAnimate(elem, clss) {
     }, 500);
 }
 
+/**
+ * 计算滚动条滑块的长度
+ */
+function getThumbSize(viewportSize, contentSize, trackSize) {
+    if (contentSize <= viewportSize) {
+        return 0;
+    }
+    const ratio = viewportSize / contentSize;
+    const ideal = trackSize * ratio;
+    return Math.max(20, Math.min(ideal, trackSize));
+}
+/**
+ * 计算滚动条滑块的偏移位置
+ */
+function getThumbOffsetSize(offsetSize, viewportSize, contentSize, trackSize, thumbSize) {
+    const maxScroll = contentSize - viewportSize;
+    if (maxScroll <= 0) {
+        return 0;
+    }
+    const maxThumbOffset = trackSize - thumbSize;
+    if (maxThumbOffset <= 0) {
+        return 0;
+    }
+    const clamped = Math.min(Math.max(offsetSize, 0), maxScroll);
+    const ratio = clamped / maxScroll;
+    return ratio * maxThumbOffset;
+}
+/**
+ * 根据点击轨道的位置，计算滑块的偏移位置
+ */
+function getScrollFromClick(clickPosition, viewportSize, contentSize, trackSize, thumbSize) {
+    const maxThumbOffset = trackSize - thumbSize;
+    const maxScroll = contentSize - viewportSize;
+    if (maxScroll <= 0 || maxThumbOffset <= 0) {
+        return 0;
+    }
+    let thumbOffset = clickPosition - thumbSize / 2;
+    thumbOffset = Math.min(Math.max(thumbOffset, 0), maxThumbOffset);
+    const scrollOffset = (thumbOffset / maxThumbOffset) * maxScroll;
+    return scrollOffset;
+}
+/**
+ * 拖拽 thumb 时，根据鼠标位置计算滑块的偏移位置
+ */
+function getScrollFromDrag(pointerPosition, dragOffset, viewportSize, contentSize, trackSize, thumbSize) {
+    const maxScroll = contentSize - viewportSize;
+    const maxThumbOffset = trackSize - thumbSize;
+    if (maxScroll <= 0 || maxThumbOffset <= 0) {
+        return 0;
+    }
+    let thumbOffset = pointerPosition - dragOffset;
+    thumbOffset = Math.min(Math.max(thumbOffset, 0), maxThumbOffset);
+    return (thumbOffset / maxThumbOffset) * maxScroll;
+}
+
 // 跨表拖拽
 const crossTableDragRowInfo = reactive({
     row: null
@@ -15974,7 +16043,7 @@ renderer$2.mixin({
 });
 
 const { warnLog: warnLog$2, errLog: errLog$2 } = createComponentLog('table');
-const { getConfig: getConfig$2, getIcon: getIcon$1, getI18n: getI18n$2, renderer: renderer$1, formats, createEvent: createEvent$2, globalResize, interceptor, hooks: hooks$1, globalEvents: globalEvents$1, GLOBAL_EVENT_KEYS: GLOBAL_EVENT_KEYS$1, useFns: useFns$2, renderEmptyElement: renderEmptyElement$1 } = VxeUI;
+const { getConfig: getConfig$2, getIcon: getIcon$1, getI18n: getI18n$2, renderer: renderer$1, formats, createEvent: createEvent$2, globalResize, interceptor, hooks: hooks$1, domUtils, globalEvents: globalEvents$1, GLOBAL_EVENT_KEYS: GLOBAL_EVENT_KEYS$1, useFns: useFns$2, renderEmptyElement: renderEmptyElement$1 } = VxeUI;
 const supportMaxRow = 5e6;
 const customStorageKey = 'VXE_CUSTOM_STORE';
 const maxYHeight = 5e6;
@@ -15989,6 +16058,7 @@ var VxeTableComponent = defineVxeComponent({
         const { slots, emit } = context;
         const xID = XEUtils.uniqueId();
         const browseObj = XEUtils.browse();
+        const scrollDefaultConf = Object.assign({}, getConfig$2().scrollbar);
         // 使用已安装的组件，如果未安装则不渲染
         const VxeUILoadingComponent = VxeUI.getComponent('VxeLoading');
         const VxeUITooltipComponent = VxeUI.getComponent('VxeTooltip');
@@ -16048,6 +16118,10 @@ var VxeTableComponent = 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;
@@ -16131,14 +16205,42 @@ var VxeTableComponent = defineVxeComponent({
             return Object.assign({}, getConfig$2().table.scrollbarConfig, props.scrollbarConfig);
         });
         const computeScrollbarXOpts = computed(() => {
-            var _a;
             const scrollbarOpts = computeScrollbarOpts.value;
-            return Object.assign({}, scrollbarOpts.x, ((_a = props.scrollbarConfig) === null || _a === void 0 ? void 0 : _a.x) || {});
+            return scrollbarOpts.x ? Object.assign({}, scrollbarOpts.x, scrollbarOpts.xConfig) : (scrollbarOpts.xConfig || {});
         });
         const computeScrollbarYOpts = computed(() => {
-            var _a;
             const scrollbarOpts = computeScrollbarOpts.value;
-            return Object.assign({}, scrollbarOpts.y, ((_a = props.scrollbarConfig) === null || _a === void 0 ? void 0 : _a.y) || {});
+            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;
@@ -16148,6 +16250,23 @@ var VxeTableComponent = 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;
@@ -16177,6 +16296,10 @@ var VxeTableComponent = defineVxeComponent({
             }
             return cellOpts;
         });
+        const computeCellHeitht = computed(() => {
+            const cellOpts = computeCellOpts.value;
+            return cellOpts.height;
+        });
         const computeHeaderCellOpts = computed(() => {
             const headerCellOpts = Object.assign({}, getConfig$2().table.headerCellConfig, props.headerCellConfig);
             const defaultRowHeight = computeDefaultRowHeight.value;
@@ -16476,16 +16599,16 @@ var VxeTableComponent = defineVxeComponent({
             return '';
         });
         const computeTableStyle = computed(() => {
-            const scrollbarOpts = computeScrollbarOpts.value;
-            const { width, height } = scrollbarOpts;
-            const tStys = {};
-            if (width) {
-                tStys['--vxe-ui-table-view-scrollbar-width'] = toCssUnit(width);
-            }
-            if (height) {
-                tStys['--vxe-ui-table-view-scrollbar-height'] = toCssUnit(height);
+            const barWidth = computeScrollYWidth.value;
+            const barHeight = computeScrollXHeight.value;
+            const stys = {};
+            if (barWidth || barHeight) {
+                stys['--vxe-ui-table-view-scrollbar-width'] = toCssUnit(barWidth || barHeight);
+                stys['--vxe-ui-scrollbar-y-width'] = toCssUnit(barWidth || barHeight);
+                stys['--vxe-ui-table-view-scrollbar-height'] = toCssUnit(barHeight || barWidth);
+                stys['--vxe-ui-scrollbar-x-height'] = toCssUnit(barHeight || barWidth);
             }
-            return tStys;
+            return stys;
         });
         const computeTableRowExpandedList = computed(() => {
             const { tableData, rowExpandedFlag, expandColumn, rowGroupExpandedFlag, treeExpandedFlag } = reactData;
@@ -16673,8 +16796,15 @@ var VxeTableComponent = defineVxeComponent({
             computeScrollbarOpts,
             computeScrollbarXOpts,
             computeScrollbarYOpts,
+            computeScrollXHeight,
+            computeScrollYWidth,
+            computeScrollXVisible,
+            computeScrollYVisible,
+            computeScrollXAutoHide,
+            computeScrollYAutoHide,
             computeScrollbarXToTop,
             computeScrollbarYToLeft,
+            computeScrollbarWrapperClss,
             computeColumnOpts,
             computeCurrentColumnOpts,
             computeScrollXThreshold,
@@ -17791,14 +17921,6 @@ var VxeTableComponent = 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
@@ -18391,7 +18513,6 @@ var VxeTableComponent = defineVxeComponent({
             const isHeaderRenderOptimize = computeIsHeaderRenderOptimize.value;
             const isBodyRenderOptimize = computeIsBodyRenderOptimize.value;
             const isFooterRenderOptimize = computeIsFooterRenderOptimize.value;
-            const scrollbarOpts = computeScrollbarOpts.value;
             const mouseOpts = computeMouseOpts.value;
             const bodyWrapperElem = getRefElem(elemStore['main-body-wrapper']);
             const bodyTableElem = getRefElem(elemStore['main-body-table']);
@@ -18399,24 +18520,26 @@ var VxeTableComponent = defineVxeComponent({
                 emptyPlaceholderElem.style.top = `${tHeaderHeight}px`;
                 emptyPlaceholderElem.style.height = bodyWrapperElem ? `${bodyWrapperElem.offsetHeight - osbHeight}px` : '';
             }
-            const scrollbarXConf = scrollbarOpts.x || {};
-            const scrollbarYConf = scrollbarOpts.y || {};
+            const scrollXVisible = computeScrollXVisible.value;
+            const scrollYVisible = computeScrollYVisible.value;
             const scrollbarYToLeft = computeScrollbarYToLeft.value;
             let xScrollbarVisible = overflowX ? 'visible' : 'hidden';
-            if (scrollbarXConf.visible === 'visible' || $xeGanttView) {
+            const hideXScroll = scrollXVisible === false || scrollXVisible === 'hidden';
+            if (scrollXVisible === 'visible' || $xeGanttView) {
                 osbHeight = scrollbarHeight;
                 xScrollbarVisible = 'visible';
             }
-            else if (scrollbarXConf.visible === 'hidden' || scrollbarXConf.visible === false) {
+            else if (hideXScroll) {
                 osbHeight = 0;
                 xScrollbarVisible = 'hidden';
             }
             let yScrollbarVisible = overflowY ? 'visible' : 'hidden';
-            if ((scrollbarYConf.visible === 'hidden' || scrollbarYConf.visible === false) || (($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 (scrollbarYConf.visible === 'visible') {
+            else if (scrollYVisible === 'visible') {
                 osbWidth = scrollbarWidth;
                 yScrollbarVisible = 'visible';
             }
@@ -19224,7 +19347,6 @@ var VxeTableComponent = defineVxeComponent({
         const calcScrollbar = () => {
             const { scrollXWidth, scrollYHeight } = reactData;
             const { elemStore } = internalData;
-            const scrollbarOpts = computeScrollbarOpts.value;
             const el = refElem.value;
             if (!el || !el.clientWidth) {
                 return;
@@ -19234,17 +19356,30 @@ var VxeTableComponent = 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 scrollbarOpts = computeScrollbarOpts.value;
+                const barWidth = computeScrollYWidth.value;
+                const barHeight = computeScrollXHeight.value;
                 overflowY = scrollYHeight > bodyWrapperElem.clientHeight;
-                if (yHandleEl) {
-                    reactData.scrollbarWidth = scrollbarOpts.width || (yHandleEl.offsetWidth - yHandleEl.clientWidth) || 14;
+                // 如果是虚拟滚动条
+                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) {
-                    reactData.scrollbarHeight = scrollbarOpts.height || (xHandleEl.offsetHeight - xHandleEl.clientHeight) || 14;
+                // 如果是虚拟滚动条
+                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;
                 const fHeight = footerTableElem ? footerTableElem.clientHeight : 0;
@@ -19310,6 +19445,10 @@ var VxeTableComponent = defineVxeComponent({
                 }
             });
         };
+        const updateScrollbar = () => {
+            updateThumbSize();
+            updateThumbOffset();
+        };
         const defaultMinRunDelay = 50;
         const handleLazyRecalculate = (reFull, reWidth, reHeight, options) => {
             const minRunDelay = (options ? options.minRunDelay : defaultMinRunDelay) || defaultMinRunDelay;
@@ -19330,6 +19469,7 @@ var VxeTableComponent = defineVxeComponent({
                 const refreshDelay = resizeOpts.refreshDelay || 30;
                 const reDelay = rceDelay + refreshDelay;
                 const el = refElem.value;
+                updateScrollbar();
                 if (el && el.clientWidth) {
                     autoCellWidth();
                     updateRowExpandStyle();
@@ -27331,6 +27471,18 @@ var VxeTableComponent = defineVxeComponent({
                 }
                 return nextTick();
             },
+            /**
+             * @private
+             */
+            updateScrollbar() {
+                return updateScrollbar();
+            },
+            /**
+             * @private
+             */
+            updateThumbOffset() {
+                return updateThumbOffset();
+            },
             /**
              * 表头单元格按下事件
              */
@@ -28478,19 +28630,18 @@ var VxeTableComponent = 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;
@@ -28552,6 +28703,7 @@ var VxeTableComponent = defineVxeComponent({
                     isLeft,
                     isRight,
                     direction }, params);
+                updateThumbOffset();
                 updateRowExpandStyle();
                 checkLastSyncScroll(isRollX, isRollY);
                 if (isRollX) {
@@ -28596,6 +28748,7 @@ var VxeTableComponent = 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) {
@@ -28615,19 +28768,21 @@ var VxeTableComponent = 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;
                 }
@@ -28768,8 +28923,8 @@ var VxeTableComponent = 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']);
@@ -28792,14 +28947,14 @@ var VxeTableComponent = defineVxeComponent({
                 const isRollY = overflowY && scrollTop !== lastScrollTop;
                 if (isRollX) {
                     // 如果禁用滚动
-                    if (scrollbarXOpts.visible === 'hidden') {
+                    if (scrollXVisible === false || scrollXVisible === 'hidden') {
                         evnt.preventDefault();
                         return;
                     }
                 }
                 if (isRollY) {
                     // 如果禁用滚动
-                    if (scrollbarYOpts.visible === 'hidden') {
+                    if (scrollYVisible === false || scrollYVisible === 'hidden') {
                         evnt.preventDefault();
                         return;
                     }
@@ -29364,6 +29519,168 @@ var VxeTableComponent = 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 () {
@@ -29388,6 +29705,8 @@ var VxeTableComponent = 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';
@@ -29396,10 +29715,15 @@ var VxeTableComponent = defineVxeComponent({
             const osYBehavior = XEUtils.eqNull(overscrollYBehavior) ? scrollbarOpts.overscrollBehavior : overscrollYBehavior;
             return h('div', {
                 ref: isFixedLeft ? refLeftContainer : refRightContainer,
-                class: [`vxe-table--fixed-${fixedType}-wrapper`, `sx--${scrollbarXOpts.visible}`, `sy--${scrollbarYOpts.visible}`, {
+                class: [
+                    `vxe-table--fixed-${fixedType}-wrapper`,
+                    `sx--${(scrollXVisible === false || scrollXVisible === 'hidden') ? 'hidden' : 'visible'}`,
+                    `sy--${(scrollYVisible === false || scrollYVisible === 'hidden') ? 'hidden' : 'visible'}`,
+                    {
                         [`x-ob--${osXBehavior}`]: osXBehavior,
                         [`y-ob--${osYBehavior}`]: osYBehavior
-                    }]
+                    }
+                ]
             }, [
                 showHeader
                     ? h(TableHeaderComponent, {
@@ -29658,6 +29982,7 @@ var VxeTableComponent = defineVxeComponent({
         };
         const renderScrollY = () => {
             return h('div', {
+                key: 'vsy',
                 ref: refScrollYVirtualElem,
                 class: 'vxe-table--scroll-y-virtual'
             }, [
@@ -29695,12 +30020,15 @@ var VxeTableComponent = 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,
@@ -29708,7 +30036,11 @@ var VxeTableComponent = defineVxeComponent({
                     }]
             }, [
                 h('div', {
-                    class: ['vxe-table--main-wrapper', `sx--${scrollbarXOpts.visible}`, `sy--${scrollbarYOpts.visible}`]
+                    class: [
+                        'vxe-table--main-wrapper',
+                        `sx--${(scrollXVisible === false || scrollXVisible === 'hidden') ? 'hidden' : 'visible'}`,
+                        `sy--${(scrollYVisible === false || scrollYVisible === 'hidden') ? 'hidden' : 'visible'}`
+                    ]
                 }, [
                     /**
                      * 表头
@@ -29749,9 +30081,10 @@ var VxeTableComponent = defineVxeComponent({
                 renderRowExpandedVNs()
             ]);
         };
-        const renderBody = () => {
+        const renderNativeBody = () => {
             const scrollbarYToLeft = computeScrollbarYToLeft.value;
             return h('div', {
+                key: 'lnb',
                 class: 'vxe-table--layout-wrapper'
             }, scrollbarYToLeft
                 ? [
@@ -29763,8 +30096,74 @@ var VxeTableComponent = 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$1($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$1($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, showHeader, height, treeConfig, mouseConfig, showFooter, highlightCell, highlightHoverRow, highlightHoverColumn, editConfig, editRules, importConfig, exportConfig, printConfig } = props;
+            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;
             const { teleportToWrapperElem, popupToWrapperElem, customPopupToElem } = internalData;
             const { leftList, rightList } = columnStore;
@@ -29807,7 +30206,7 @@ var VxeTableComponent = defineVxeComponent({
             if (isCrossTableDrag && !tableData.length) {
                 tbOns.onDragover = $xeTable.handleCrossTableRowDragoverEmptyEvent;
             }
-            return h('div', Object.assign({ ref: refElem, class: ['vxe-table', 'vxe-table--render-default', `tid_${xID}`, `border--${tableBorder}`, `sx-pos--${scrollbarXToTop ? 'top' : 'bottom'}`, `sy-pos--${scrollbarYToLeft ? 'left' : 'right'}`, {
+            return h('div', Object.assign({ ref: refElem, class: ['vxe-table', 'vxe-table--render-default', `tid_${xID}`, `border--${tableBorder}`, useScrollbar ? 'is--virtual-scrollbar' : 'is--native-scrollbar', `sx-pos--${scrollbarXToTop ? 'top' : 'bottom'}`, `sy-pos--${scrollbarYToLeft ? 'left' : 'right'}`, {
                         [`size--${vSize}`]: vSize,
                         [`valid-msg--${validOpts.msgMode}`]: !!editRules,
                         'vxe-editable': !!editConfig,
@@ -29868,15 +30267,17 @@ var VxeTableComponent = defineVxeComponent({
                 h('div', {
                     key: 'tw',
                     class: 'vxe-table--render-wrapper'
-                }, scrollbarXToTop
-                    ? [
-                        renderScrollX(),
-                        renderBody()
-                    ]
-                    : [
-                        renderBody(),
-                        renderScrollX()
-                    ]),
+                }, useScrollbar
+                    ? [renderVirtualBody()]
+                    : (scrollbarXToTop
+                        ? [
+                            renderScrollX(),
+                            renderNativeBody()
+                        ]
+                        : [
+                            renderNativeBody(),
+                            renderScrollX()
+                        ])),
                 /**
                  * 空数据
                  */
@@ -30183,6 +30584,7 @@ var VxeTableComponent = defineVxeComponent({
                 $xeTable.refreshColumn();
             });
         });
+        const reScrollFlag = ref(0);
         const reLayoutFlag = ref(0);
         watch(computeSize, () => {
             reLayoutFlag.value++;
@@ -30215,36 +30617,47 @@ var VxeTableComponent = 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++;
@@ -30360,7 +30773,6 @@ var VxeTableComponent = defineVxeComponent({
             }
         });
         $xeTable.preventEvent(null, 'created', { $table: $xeTable });
-        let resizeObserver;
         onActivated(() => {
             $xeTable.recalculate().then(() => $xeTable.refreshScroll());
             $xeTable.preventEvent(null, 'activated', { $table: $xeTable });
@@ -30376,7 +30788,7 @@ var VxeTableComponent = 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;
@@ -30398,6 +30810,7 @@ var VxeTableComponent = defineVxeComponent({
             const areaOpts = computeAreaOpts.value;
             const sortOpts = computeSortOpts.value;
             const filterOpts = computeFilterOpts.value;
+            const scrollbarOpts = computeScrollbarOpts.value;
             const { groupFields } = aggregateOpts;
             if ($xeGantt) {
                 const { refClassifyWrapperElem } = $xeGantt.getRefMaps();
@@ -30629,6 +31042,12 @@ var VxeTableComponent = defineVxeComponent({
             // if (hasEnableConf(printConfig, printOpts) || hasEnableConf(importConfig, importOpts) || hasEnableConf(exportConfig, exportOpts)) && !$xeTable.exportData) {
             //   errLog('vxe.error.reqModule', ['Export'])
             // }
+            if (scrollbarOpts.x) {
+                warnLog$2('vxe.error.delProp', ['scrollbar-config.x', 'scrollbar-config.xConfig']);
+            }
+            if (scrollbarOpts.y) {
+                warnLog$2('vxe.error.delProp', ['scrollbar-config.y', 'scrollbar-config.yConfig']);
+            }
             Object.assign(scrollYStore, {
                 startIndex: 0,
                 endIndex: 0,
@@ -30642,12 +31061,26 @@ var VxeTableComponent = 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) {
@@ -30656,6 +31089,7 @@ var VxeTableComponent = defineVxeComponent({
                     if (parentEl) {
                         resizeObserver.observe(parentEl);
                     }
+                    internalData.resizeObserver = resizeObserver;
                 }
             });
             if (virtualYOpts.mode !== 'scroll') {
@@ -30677,7 +31111,7 @@ var VxeTableComponent = defineVxeComponent({
             $xeTable.preventEvent(null, 'mounted', { $table: $xeTable });
         });
         onBeforeUnmount(() => {
-            const { _sToTime } = internalData;
+            const { resizeObserver, scrollObserver, _sToTime } = internalData;
             if (_sToTime) {
                 clearTimeout(_sToTime);
             }
@@ -30688,6 +31122,9 @@ var VxeTableComponent = defineVxeComponent({
             internalData.cvCacheMaps = {};
             internalData.prevDragRow = null;
             internalData.prevDragCol = null;
+            if (scrollObserver) {
+                scrollObserver.disconnect();
+            }
             if (resizeObserver) {
                 resizeObserver.disconnect();
             }