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

package/es/table/src/table.js

@@ -2,11 +2,12 @@ import { h, reactive, ref, provide, inject, nextTick, Teleport, onActivated, onD
 import { defineVxeComponent } from '../../ui/src/comp';
 import XEUtils from 'xe-utils';
 import { initTpImg, getTpImg, isPx, isScale, hasClass, addClass, removeClass, wheelScrollTopTo, wheelScrollLeftTo, getEventTargetNode, getPaddingTopBottomSize, setScrollTop, setScrollLeft, toCssUnit, hasControlKey, checkTargetElement, hasAxternalInputTarget } from '../../ui/src/dom';
-import { getLastZIndex, nextZIndex, hasChildrenList, getFuncText, isEnableConf, formatText, eqEmptyValue, hasEnableConf } from '../../ui/src/utils';
+import { getLastZIndex, nextZIndex, hasChildrenList, getFuncText, isEnableConf, formatText, eqEmptyValue, hasEnableConf, getDefaultConfig } from '../../ui/src/utils';
 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;
@@ -44,6 +45,7 @@ export default defineVxeComponent({
         const { slots, emit } = context;
         const xID = XEUtils.uniqueId();
         const browseObj = XEUtils.browse();
+        const scrollDefaultConf = Object.assign({}, getConfig().scrollbar);
         // 使用已安装的组件，如果未安装则不渲染
         const VxeUILoadingComponent = VxeUI.getComponent('VxeLoading');
         const VxeUITooltipComponent = VxeUI.getComponent('VxeTooltip');
@@ -103,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;
@@ -186,14 +192,42 @@ export default defineVxeComponent({
             return Object.assign({}, getConfig().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;
@@ -203,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;
@@ -232,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;
@@ -539,16 +594,16 @@ export default 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);
+            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);
             }
-            if (height) {
-                tStys['--vxe-ui-table-view-scrollbar-height'] = toCssUnit(height);
-            }
-            return tStys;
+            return stys;
         });
         const computeTableRowExpandedList = computed(() => {
             const { tableData, rowExpandedFlag, expandColumn, rowGroupExpandedFlag, treeExpandedFlag } = reactData;
@@ -739,8 +794,15 @@ export default defineVxeComponent({
             computeScrollbarOpts,
             computeScrollbarXOpts,
             computeScrollbarYOpts,
+            computeScrollXHeight,
+            computeScrollYWidth,
+            computeScrollXVisible,
+            computeScrollYVisible,
+            computeScrollXAutoHide,
+            computeScrollYAutoHide,
             computeScrollbarXToTop,
             computeScrollbarYToLeft,
+            computeScrollbarWrapperClss,
             computeColumnOpts,
             computeCurrentColumnOpts,
             computeScrollXThreshold,
@@ -1861,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
@@ -2461,7 +2515,6 @@ export default 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']);
@@ -2469,24 +2522,26 @@ export default 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';
             }
@@ -3294,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;
@@ -3304,17 +3358,30 @@ 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 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;
@@ -3380,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;
@@ -3400,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();
@@ -11415,6 +11487,18 @@ export default defineVxeComponent({
                 }
                 return nextTick();
             },
+            /**
+             * @private
+             */
+            updateScrollbar() {
+                return updateScrollbar();
+            },
+            /**
+             * @private
+             */
+            updateThumbOffset() {
+                return updateThumbOffset();
+            },
             /**
              * 表头单元格按下事件
              */
@@ -12566,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;
@@ -12640,6 +12723,7 @@ export default defineVxeComponent({
                     isLeft,
                     isRight,
                     direction }, params);
+                updateThumbOffset();
                 updateRowExpandStyle();
                 checkLastSyncScroll(isRollX, isRollY);
                 if (isRollX) {
@@ -12684,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) {
@@ -12703,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;
                 }
@@ -12856,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']);
@@ -12880,14 +12967,14 @@ export default 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;
                     }
@@ -13452,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 () {
@@ -13476,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';
@@ -13484,10 +13735,15 @@ export default 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, {
@@ -13746,6 +14002,7 @@ export default defineVxeComponent({
         };
         const renderScrollY = () => {
             return h('div', {
+                key: 'vsy',
                 ref: refScrollYVirtualElem,
                 class: 'vxe-table--scroll-y-virtual'
             }, [
@@ -13783,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,
@@ -13796,7 +14056,11 @@ export default 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'}`
+                    ]
                 }, [
                     /**
                      * 表头
@@ -13837,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
                 ? [
@@ -13851,8 +14116,74 @@ 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, 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;
@@ -13895,7 +14226,7 @@ export default 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,
@@ -13956,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()
+                        ])),
                 /**
                  * 空数据
                  */
@@ -14271,6 +14604,7 @@ export default defineVxeComponent({
                 $xeTable.refreshColumn();
             });
         });
+        const reScrollFlag = ref(0);
         const reLayoutFlag = ref(0);
         watch(computeSize, () => {
             reLayoutFlag.value++;
@@ -14303,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++;
@@ -14448,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 });
@@ -14464,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;
@@ -14486,6 +14830,7 @@ export default 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();
@@ -14717,6 +15062,12 @@ export default defineVxeComponent({
             // if (hasEnableConf(printConfig, printOpts) || hasEnableConf(importConfig, importOpts) || hasEnableConf(exportConfig, exportOpts)) && !$xeTable.exportData) {
             //   errLog('vxe.error.reqModule', ['Export'])
             // }
+            if (scrollbarOpts.x) {
+                warnLog('vxe.error.delProp', ['scrollbar-config.x', 'scrollbar-config.xConfig']);
+            }
+            if (scrollbarOpts.y) {
+                warnLog('vxe.error.delProp', ['scrollbar-config.y', 'scrollbar-config.yConfig']);
+            }
             Object.assign(scrollYStore, {
                 startIndex: 0,
                 endIndex: 0,
@@ -14730,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) {
@@ -14744,6 +15109,7 @@ export default defineVxeComponent({
                     if (parentEl) {
                         resizeObserver.observe(parentEl);
                     }
+                    internalData.resizeObserver = resizeObserver;
                 }
             });
             if (virtualYOpts.mode !== 'scroll') {
@@ -14765,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);
             }
@@ -14776,6 +15142,9 @@ export default defineVxeComponent({
             internalData.cvCacheMaps = {};
             internalData.prevDragRow = null;
             internalData.prevDragCol = null;
+            if (scrollObserver) {
+                scrollObserver.disconnect();
+            }
             if (resizeObserver) {
                 resizeObserver.disconnect();
             }