vxe-pc-ui 4.17.29 → 4.18.0

package/dist/all.esm.js

@@ -101,7 +101,7 @@ function checkDynamic() {
 }
 
 const { log } = VxeUI;
-const uiVersion = `ui v${"4.17.29"}`;
+const uiVersion = `ui v${"4.18.0"}`;
 function createComponentLog(name) {
     const tableVersion = VxeUI.tableVersion ? `table v${VxeUI.tableVersion}` : '';
     const ganttVersion = VxeUI.ganttVersion ? `gantt v${VxeUI.ganttVersion}` : '';
@@ -115,7 +115,7 @@ function createComponentLog(name) {
 const warnLog$i = log.create('warn', uiVersion);
 log.create('error', uiVersion);
 
-const version = "4.17.29";
+const version = "4.18.0";
 VxeUI.uiVersion = version;
 VxeUI.dynamicApp = dynamicApp;
 function config(options) {
@@ -495,7 +495,10 @@ setConfig$1({
     splitterPanel: {},
     slider: {
         max: 100,
-        min: 0
+        min: 0,
+        tooltipConfig: {
+            enterDelay: 0
+        }
     },
     space: {},
     steps: {},
@@ -2037,7 +2040,7 @@ function updatePanelPlacement(targetElem, panelElem, options) {
             const targetTop = targetRect.top;
             minWidth = targetElem.offsetWidth;
             if (teleportTo) {
-                left = defaultLeft || (targetLeft);
+                left = defaultLeft || (targetLeft - (panelWidth - targetWidth) / 2);
                 top = defaultTop || (targetTop + targetHeight);
                 if (placement === 'top') {
                     panelPlacement = 'top';
@@ -3386,6 +3389,7 @@ const VxeButtonComponent = defineVxeComponent({
         const { slots, emit } = context;
         const $xeModal = inject('$xeModal', null);
         const $xeDrawer = inject('$xeDrawer', null);
+        const $xeGrid = inject('$xeGrid', null);
         const $xeTable = inject('$xeTable', null);
         const $xeTree = inject('$xeTree', null);
         const $xeForm = inject('$xeForm', null);
@@ -3432,7 +3436,7 @@ const VxeButtonComponent = defineVxeComponent({
                 if (XEUtils.isBoolean(globalTransfer)) {
                     return globalTransfer;
                 }
-                if ($xeTable || $xeTree || $xeModal || $xeDrawer || $xeForm) {
+                if ($xeGrid || $xeTable || $xeTree || $xeModal || $xeDrawer || $xeForm) {
                     return true;
                 }
             }
@@ -3788,12 +3792,6 @@ const VxeButtonComponent = defineVxeComponent({
                 return nextTick();
             }
         };
-        const handleGlobalMousewheelEvent = (evnt) => {
-            const panelElem = refBtnPanel.value;
-            if (reactData.visiblePanel && !getEventTargetNode(evnt, panelElem).flag) {
-                hidePanel();
-            }
-        };
         const handleGlobalMousedownEvent = (evnt) => {
             const btnDisabled = computeBtnDisabled.value;
             const { visiblePanel } = reactData;
@@ -3812,6 +3810,12 @@ const VxeButtonComponent = defineVxeComponent({
                 updatePlacement();
             }
         };
+        const handleGlobalScrollEvent = () => {
+            const { visiblePanel } = reactData;
+            if (visiblePanel) {
+                updatePlacement();
+            }
+        };
         Object.assign($xeButton, buttonMethods);
         const renderVN = () => {
             const { className, trigger, title, routerLink, type, destroyOnClose, name, loading, shadow, showDropdownIcon } = props;
@@ -3992,14 +3996,14 @@ const VxeButtonComponent = defineVxeComponent({
             if (props.type === 'text') {
                 warnLog$h('vxe.error.delProp', ['type=text', 'mode=text']);
             }
-            globalEvents.on($xeButton, 'mousewheel', handleGlobalMousewheelEvent);
             globalEvents.on($xeButton, 'mousedown', handleGlobalMousedownEvent);
             globalEvents.on($xeButton, 'resize', handleGlobalResizeEvent);
+            globalEvents.on($xeButton, 'scroll', handleGlobalScrollEvent);
         });
         onUnmounted(() => {
-            globalEvents.off($xeButton, 'mousewheel');
             globalEvents.off($xeButton, 'mousedown');
             globalEvents.off($xeButton, 'resize');
+            globalEvents.off($xeButton, 'scroll');
         });
         return $xeButton;
     },
@@ -12775,21 +12779,6 @@ var VxeCascaderComponent = defineVxeComponent({
             const { $event } = params;
             hideOptionPanel($event);
         };
-        const handleGlobalMousewheelEvent = (evnt) => {
-            const { visiblePanel } = reactData;
-            const isDisabled = computeIsDisabled.value;
-            if (!isDisabled) {
-                if (visiblePanel) {
-                    const panelElem = refOptionPanel.value;
-                    if (getEventTargetNode(evnt, panelElem).flag) {
-                        updatePlacement();
-                    }
-                    else {
-                        hideOptionPanel(evnt);
-                    }
-                }
-            }
-        };
         const handleGlobalMousedownEvent = (evnt) => {
             const { visiblePanel } = reactData;
             const isDisabled = computeIsDisabled.value;
@@ -12823,6 +12812,12 @@ var VxeCascaderComponent = defineVxeComponent({
                 updatePlacement();
             }
         };
+        const handleGlobalScrollEvent = () => {
+            const { visiblePanel } = reactData;
+            if (visiblePanel) {
+                updatePlacement();
+            }
+        };
         const handleFocusSearch = () => {
             if (props.filterable) {
                 nextTick(() => {
@@ -13655,16 +13650,16 @@ var VxeCascaderComponent = defineVxeComponent({
         });
         loadData(props.options || []);
         onMounted(() => {
-            globalEvents.on($xeCascader, 'mousewheel', handleGlobalMousewheelEvent);
             globalEvents.on($xeCascader, 'mousedown', handleGlobalMousedownEvent);
             globalEvents.on($xeCascader, 'blur', handleGlobalBlurEvent);
             globalEvents.on($xeCascader, 'resize', handleGlobalResizeEvent);
+            globalEvents.on($xeCascader, 'scroll', handleGlobalScrollEvent);
         });
         onUnmounted(() => {
-            globalEvents.off($xeCascader, 'mousewheel');
             globalEvents.off($xeCascader, 'mousedown');
             globalEvents.off($xeCascader, 'blur');
             globalEvents.off($xeCascader, 'resize');
+            globalEvents.off($xeCascader, 'scroll');
             XEUtils.assign(reactData, createReactData$l());
             XEUtils.assign(internalData, createInternalData$k());
         });
@@ -15920,7 +15915,7 @@ var VxeNumberInputComponent = defineVxeComponent({
                     const inputElem = refInputTarget.value;
                     const content = getText(contentMethod
                         ? contentMethod({
-                            $mumberInput: $xeNumberInput,
+                            $numberInput: $xeNumberInput,
                             type,
                             inputValue: inputElem.value,
                             value: inputValue || '',
@@ -17018,21 +17013,6 @@ var VxeColorPickerComponent = defineVxeComponent({
                 }
             }
         };
-        const handleGlobalMousewheelEvent = (evnt) => {
-            const { visiblePanel } = reactData;
-            const isDisabled = computeIsDisabled.value;
-            if (!isDisabled) {
-                if (visiblePanel) {
-                    const panelElem = refOptionPanel.value;
-                    if (getEventTargetNode(evnt, panelElem).flag) {
-                        updatePlacement();
-                    }
-                    else {
-                        hideOptionPanel();
-                    }
-                }
-            }
-        };
         const handleGlobalMousedownEvent = (evnt) => {
             const { visiblePanel } = reactData;
             const isDisabled = computeIsDisabled.value;
@@ -17066,6 +17046,12 @@ var VxeColorPickerComponent = defineVxeComponent({
                 updatePlacement();
             }
         };
+        const handleGlobalScrollEvent = () => {
+            const { visiblePanel } = reactData;
+            if (visiblePanel) {
+                updatePlacement();
+            }
+        };
         const dispatchEvent = (type, params, evnt) => {
             emit(type, createEvent(evnt, { $colorPicker: $xeColorPicker }, params));
         };
@@ -17469,16 +17455,16 @@ var VxeColorPickerComponent = defineVxeComponent({
             updateType();
         });
         onMounted(() => {
-            globalEvents.on($xeColorPicker, 'mousewheel', handleGlobalMousewheelEvent);
             globalEvents.on($xeColorPicker, 'mousedown', handleGlobalMousedownEvent);
             globalEvents.on($xeColorPicker, 'blur', handleGlobalBlurEvent);
             globalEvents.on($xeColorPicker, 'resize', handleGlobalResizeEvent);
+            globalEvents.on($xeColorPicker, 'scroll', handleGlobalScrollEvent);
         });
         onUnmounted(() => {
-            globalEvents.off($xeColorPicker, 'mousewheel');
             globalEvents.off($xeColorPicker, 'mousedown');
             globalEvents.off($xeColorPicker, 'blur');
             globalEvents.off($xeColorPicker, 'resize');
+            globalEvents.off($xeColorPicker, 'scroll');
         });
         updateType();
         provide('$xeColorPicker', $xeColorPicker);
@@ -21509,21 +21495,6 @@ var VxeDatePickerComponent = defineVxeComponent({
                 }
             }
         };
-        const handleGlobalMousewheelEvent = (evnt) => {
-            const { visiblePanel } = reactData;
-            const isDisabled = computeIsDisabled.value;
-            if (!isDisabled) {
-                if (visiblePanel) {
-                    const panelWrapperElem = refPanelWrapper.value;
-                    if (getEventTargetNode(evnt, panelWrapperElem).flag) {
-                        updatePlacement();
-                    }
-                    else {
-                        hidePanel();
-                    }
-                }
-            }
-        };
         const handleGlobalBlurEvent = () => {
             const { isActivated, visiblePanel } = reactData;
             if (visiblePanel) {
@@ -21546,6 +21517,12 @@ var VxeDatePickerComponent = defineVxeComponent({
                 updatePlacement();
             }
         };
+        const handleGlobalScrollEvent = () => {
+            const { visiblePanel } = reactData;
+            if (visiblePanel) {
+                updatePlacement();
+            }
+        };
         // 弹出面板
         const updateZindex = () => {
             const popupOpts = computePopupOpts.value;
@@ -22019,11 +21996,11 @@ var VxeDatePickerComponent = defineVxeComponent({
         });
         updateModelValue();
         nextTick(() => {
-            globalEvents.on($xeDatePicker, 'mousewheel', handleGlobalMousewheelEvent);
             globalEvents.on($xeDatePicker, 'mousedown', handleGlobalMousedownEvent);
             globalEvents.on($xeDatePicker, 'keydown', handleGlobalKeydownEvent);
             globalEvents.on($xeDatePicker, 'blur', handleGlobalBlurEvent);
             globalEvents.on($xeDatePicker, 'resize', handleGlobalResizeEvent);
+            globalEvents.on($xeDatePicker, 'scroll', handleGlobalScrollEvent);
         });
         onMounted(() => {
             const { type, multiple, maskedConfig } = props;
@@ -22037,11 +22014,11 @@ var VxeDatePickerComponent = defineVxeComponent({
             }
         });
         onUnmounted(() => {
-            globalEvents.off($xeDatePicker, 'mousewheel');
             globalEvents.off($xeDatePicker, 'mousedown');
             globalEvents.off($xeDatePicker, 'keydown');
             globalEvents.off($xeDatePicker, 'blur');
             globalEvents.off($xeDatePicker, 'resize');
+            globalEvents.off($xeDatePicker, 'scroll');
             XEUtils.assign(reactData, createReactData$h());
             XEUtils.assign(internalData, createInternalData$g());
         });
@@ -22971,22 +22948,6 @@ var VxeDateRangePickerComponent = defineVxeComponent({
                 }
             }
         };
-        const handleGlobalMousewheelEvent = (evnt) => {
-            const { visiblePanel } = reactData;
-            const isDisabled = computeIsDisabled.value;
-            if (!isDisabled) {
-                if (visiblePanel) {
-                    const panelWrapperElem = refPanelWrapper.value;
-                    if (getEventTargetNode(evnt, panelWrapperElem).flag) {
-                        updatePlacement();
-                    }
-                    else {
-                        checkValue();
-                        hidePanel();
-                    }
-                }
-            }
-        };
         const handleGlobalBlurEvent = () => {
             const { visiblePanel, isActivated } = reactData;
             if (visiblePanel) {
@@ -23009,6 +22970,12 @@ var VxeDateRangePickerComponent = defineVxeComponent({
                 updatePlacement();
             }
         };
+        const handleGlobalScrollEvent = () => {
+            const { visiblePanel } = reactData;
+            if (visiblePanel) {
+                updatePlacement();
+            }
+        };
         // 弹出面板
         const updateZindex = () => {
             const popupOpts = computePopupOpts.value;
@@ -23536,11 +23503,11 @@ var VxeDateRangePickerComponent = defineVxeComponent({
         });
         updateModelValue(true);
         nextTick(() => {
-            globalEvents.on($xeDateRangePicker, 'mousewheel', handleGlobalMousewheelEvent);
             globalEvents.on($xeDateRangePicker, 'mousedown', handleGlobalMousedownEvent);
             globalEvents.on($xeDateRangePicker, 'keydown', handleGlobalKeydownEvent);
             globalEvents.on($xeDateRangePicker, 'blur', handleGlobalBlurEvent);
             globalEvents.on($xeDateRangePicker, 'resize', handleGlobalResizeEvent);
+            globalEvents.on($xeDateRangePicker, 'scroll', handleGlobalScrollEvent);
         });
         onDeactivated(() => {
             checkValue();
@@ -23549,10 +23516,11 @@ var VxeDateRangePickerComponent = defineVxeComponent({
             checkValue();
         });
         onUnmounted(() => {
-            globalEvents.off($xeDateRangePicker, 'mousewheel');
             globalEvents.off($xeDateRangePicker, 'mousedown');
+            globalEvents.off($xeDateRangePicker, 'keydown');
             globalEvents.off($xeDateRangePicker, 'blur');
             globalEvents.off($xeDateRangePicker, 'resize');
+            globalEvents.off($xeDateRangePicker, 'scroll');
             XEUtils.assign(reactData, createReactData$g());
             XEUtils.assign(internalData, createInternalData$f());
         });
@@ -27095,21 +27063,6 @@ var VxeIconPickerComponent = defineVxeComponent({
             togglePanelEvent(evnt);
             dispatchEvent('click', {}, evnt);
         };
-        const handleGlobalMousewheelEvent = (evnt) => {
-            const { visiblePanel } = reactData;
-            const isDisabled = computeIsDisabled.value;
-            if (!isDisabled) {
-                if (visiblePanel) {
-                    const panelElem = refOptionPanel.value;
-                    if (getEventTargetNode(evnt, panelElem).flag) {
-                        updatePlacement();
-                    }
-                    else {
-                        hideOptionPanel();
-                    }
-                }
-            }
-        };
         const handleGlobalMousedownEvent = (evnt) => {
             const { visiblePanel } = reactData;
             const isDisabled = computeIsDisabled.value;
@@ -27185,6 +27138,18 @@ var VxeIconPickerComponent = defineVxeComponent({
                 }
             }
         };
+        const handleGlobalResizeEvent = () => {
+            const { visiblePanel } = reactData;
+            if (visiblePanel) {
+                updatePlacement();
+            }
+        };
+        const handleGlobalScrollEvent = () => {
+            const { visiblePanel } = reactData;
+            if (visiblePanel) {
+                updatePlacement();
+            }
+        };
         const dispatchEvent = (type, params, evnt) => {
             emit(type, createEvent(evnt, { $iconPicker: $xeIconPicker }, params));
         };
@@ -27444,16 +27409,19 @@ var VxeIconPickerComponent = defineVxeComponent({
             handleData();
         });
         onMounted(() => {
-            globalEvents.on($xeIconPicker, 'mousewheel', handleGlobalMousewheelEvent);
             globalEvents.on($xeIconPicker, 'mousedown', handleGlobalMousedownEvent);
             globalEvents.on($xeIconPicker, 'keydown', handleGlobalKeydownEvent);
             globalEvents.on($xeIconPicker, 'blur', handleGlobalBlurEvent);
+            globalEvents.on($xeIconPicker, 'resize', handleGlobalResizeEvent);
+            globalEvents.on($xeIconPicker, 'scroll', handleGlobalScrollEvent);
         });
         onBeforeUnmount(() => {
             globalEvents.off($xeIconPicker, 'mousewheel');
             globalEvents.off($xeIconPicker, 'mousedown');
             globalEvents.off($xeIconPicker, 'keydown');
             globalEvents.off($xeIconPicker, 'blur');
+            globalEvents.off($xeIconPicker, 'resize');
+            globalEvents.off($xeIconPicker, 'scroll');
             XEUtils.assign(reactData, createReactData$e());
             XEUtils.assign(internalData, createInternalData$d());
         });
@@ -32515,21 +32483,6 @@ var VxeSelectComponent = defineVxeComponent({
             }
             reactData.reactFlag++;
         };
-        const handleGlobalMousewheelEvent = (evnt) => {
-            const { visiblePanel } = reactData;
-            const isDisabled = computeIsDisabled.value;
-            if (!isDisabled) {
-                if (visiblePanel) {
-                    const panelElem = refOptionPanel.value;
-                    if (getEventTargetNode(evnt, panelElem).flag) {
-                        updatePlacement();
-                    }
-                    else {
-                        hideOptionPanel(evnt);
-                    }
-                }
-            }
-        };
         const handleGlobalMousedownEvent = (evnt) => {
             const { visiblePanel } = reactData;
             const isDisabled = computeIsDisabled.value;
@@ -32692,6 +32645,12 @@ var VxeSelectComponent = defineVxeComponent({
                 updatePlacement();
             }
         };
+        const handleGlobalScrollEvent = () => {
+            const { visiblePanel } = reactData;
+            if (visiblePanel) {
+                updatePlacement();
+            }
+        };
         const handleFocusSearch = () => {
             if (props.filterable) {
                 nextTick(() => {
@@ -33496,18 +33455,18 @@ var VxeSelectComponent = defineVxeComponent({
                     loadData(options);
                 }
             });
-            globalEvents.on($xeSelect, 'mousewheel', handleGlobalMousewheelEvent);
             globalEvents.on($xeSelect, 'mousedown', handleGlobalMousedownEvent);
             globalEvents.on($xeSelect, 'keydown', handleGlobalKeydownEvent);
             globalEvents.on($xeSelect, 'blur', handleGlobalBlurEvent);
             globalEvents.on($xeSelect, 'resize', handleGlobalResizeEvent);
+            globalEvents.on($xeSelect, 'scroll', handleGlobalScrollEvent);
         });
         onUnmounted(() => {
-            globalEvents.off($xeSelect, 'mousewheel');
             globalEvents.off($xeSelect, 'mousedown');
             globalEvents.off($xeSelect, 'keydown');
             globalEvents.off($xeSelect, 'blur');
             globalEvents.off($xeSelect, 'resize');
+            globalEvents.off($xeSelect, 'scroll');
             XEUtils.assign(reactData, createReactData$9());
             XEUtils.assign(internalData, createInternalData$8());
         });
@@ -35522,26 +35481,6 @@ var VxePulldownComponent = defineVxeComponent({
             }
             dispatchEvent('click', { $pulldown: $xePulldown }, evnt);
         };
-        const handleGlobalMousewheelEvent = (evnt) => {
-            const { trigger, disabled } = props;
-            const { visiblePanel } = reactData;
-            const panelElem = refPulldownPanel.value;
-            const popupOpts = computePopupOpts.value;
-            const currTrigger = trigger || popupOpts.trigger;
-            if (!disabled) {
-                if (visiblePanel) {
-                    if (getEventTargetNode(evnt, panelElem).flag) {
-                        updatePlacement();
-                    }
-                    else {
-                        if (currTrigger !== 'manual') {
-                            hideOptionPanel();
-                            dispatchEvent('hide-panel', {}, evnt);
-                        }
-                    }
-                }
-            }
-        };
         const handleGlobalMousedownEvent = (evnt) => {
             const { trigger, disabled } = props;
             const { visiblePanel } = reactData;
@@ -35580,6 +35519,12 @@ var VxePulldownComponent = defineVxeComponent({
                 updatePlacement();
             }
         };
+        const handleGlobalScrollEvent = () => {
+            const { visiblePanel } = reactData;
+            if (visiblePanel) {
+                updatePlacement();
+            }
+        };
         const dispatchEvent = (type, params, evnt) => {
             emit(type, createEvent(evnt, { $pulldown: $xePulldown }, params));
         };
@@ -35591,30 +35536,6 @@ var VxePulldownComponent = defineVxeComponent({
             hidePanel: hideOptionPanel
         };
         Object.assign($xePulldown, pulldownMethods);
-        watch(() => props.modelValue, (value) => {
-            reactData.isActivated = !!value;
-            if (value) {
-                showPanel();
-            }
-            else {
-                hideOptionPanel();
-            }
-        });
-        nextTick(() => {
-            if (props.modelValue) {
-                showPanel();
-            }
-            globalEvents.on($xePulldown, 'mousewheel', handleGlobalMousewheelEvent);
-            globalEvents.on($xePulldown, 'mousedown', handleGlobalMousedownEvent);
-            globalEvents.on($xePulldown, 'blur', handleGlobalBlurEvent);
-            globalEvents.on($xePulldown, 'resize', handleGlobalResizeEvent);
-        });
-        onUnmounted(() => {
-            globalEvents.off($xePulldown, 'mousewheel');
-            globalEvents.off($xePulldown, 'mousedown');
-            globalEvents.off($xePulldown, 'blur');
-            globalEvents.off($xePulldown, 'resize');
-        });
         const renderDefaultPanel = (options) => {
             const optionSlot = slots.option;
             return h('div', {
@@ -35699,6 +35620,30 @@ var VxePulldownComponent = defineVxeComponent({
                 ])
             ]);
         };
+        watch(() => props.modelValue, (value) => {
+            reactData.isActivated = !!value;
+            if (value) {
+                showPanel();
+            }
+            else {
+                hideOptionPanel();
+            }
+        });
+        nextTick(() => {
+            if (props.modelValue) {
+                showPanel();
+            }
+            globalEvents.on($xePulldown, 'mousedown', handleGlobalMousedownEvent);
+            globalEvents.on($xePulldown, 'blur', handleGlobalBlurEvent);
+            globalEvents.on($xePulldown, 'resize', handleGlobalResizeEvent);
+            globalEvents.on($xePulldown, 'scroll', handleGlobalScrollEvent);
+        });
+        onUnmounted(() => {
+            globalEvents.off($xePulldown, 'mousedown');
+            globalEvents.off($xePulldown, 'blur');
+            globalEvents.off($xePulldown, 'resize');
+            globalEvents.off($xePulldown, 'scroll');
+        });
         $xePulldown.renderVN = renderVN;
         return $xePulldown;
     },
@@ -38087,6 +38032,8 @@ const SplitPane = VxeSplitPane;
 function createInternalData$6() {
     return {
         // _isUp: false,
+        isDragStatus: false,
+        isBtnActive: false,
         currValue: 0,
         startValue: 0,
         endValue: 0
@@ -38130,10 +38077,19 @@ var VxeSliderComponent = defineVxeComponent({
             type: Boolean,
             default: null
         },
+        status: {
+            type: String,
+            default: () => getConfig$3().slider.status
+        },
         immediate: {
             type: Boolean,
             default: () => getConfig$3().slider.immediate
-        }
+        },
+        showTooltip: {
+            type: Boolean,
+            default: () => getConfig$3().slider.showTooltip
+        },
+        tooltipConfig: Object
     },
     emits: [
         'update:modelValue',
@@ -38190,6 +38146,9 @@ var VxeSliderComponent = defineVxeComponent({
             const { range, startValue, endValue } = props;
             return range ? `${startValue || ''}${endValue || ''}` : '';
         });
+        const computeTooltipOpts = computed(() => {
+            return Object.assign({}, getConfig$3().slider.tooltipConfig, props.tooltipConfig);
+        });
         const computeMaps = {};
         const $xeSlider = {
             xID,
@@ -38342,6 +38301,38 @@ var VxeSliderComponent = defineVxeComponent({
             const raw = minNum + ratio * (maxNum - minNum);
             return Math.floor(raw);
         };
+        const handleShowTip = (btnElem) => {
+            const { showTooltip } = props;
+            if (showTooltip) {
+                if (VxeUI.tooltip) {
+                    const { currValue } = internalData;
+                    const tooltipOpts = computeTooltipOpts.value;
+                    const { contentMethod } = tooltipOpts;
+                    const content = getText(contentMethod
+                        ? contentMethod({
+                            $slider: $xeSlider,
+                            value: currValue
+                        })
+                        : '' + currValue);
+                    if (content) {
+                        VxeUI.tooltip.open(btnElem, Object.assign({}, Object.assign(Object.assign({}, tooltipOpts), { content }), {
+                            contentMethod: undefined
+                        }));
+                    }
+                    else {
+                        VxeUI.tooltip.close();
+                    }
+                }
+            }
+        };
+        const handleHideTip = () => {
+            const { showTooltip } = props;
+            if (showTooltip) {
+                if (VxeUI.tooltip) {
+                    VxeUI.tooltip.close();
+                }
+            }
+        };
         const handleBtnMousedownEvent = (evnt) => {
             const { range, immediate } = props;
             const btnElem = evnt.currentTarget;
@@ -38353,6 +38344,7 @@ var VxeSliderComponent = defineVxeComponent({
                     evnt.preventDefault();
                     const el = refElem.value;
                     const barElem = refBarElem.value;
+                    internalData.isDragStatus = true;
                     if (el && barElem) {
                         const btnType = btnElem.getAttribute('data-type');
                         const barRect = barElem.getBoundingClientRect();
@@ -38379,10 +38371,12 @@ var VxeSliderComponent = defineVxeComponent({
                         changeEvent(evnt);
                     }
                     updateTrackStyle();
+                    handleShowTip(btnElem);
                 };
                 document.onmouseup = (evnt) => {
                     document.onmousemove = null;
                     document.onmouseup = null;
+                    internalData.isDragStatus = false;
                     dispatchEvent('track-dragend', {
                         currentValue: internalData.currValue,
                         startValue: internalData.startValue,
@@ -38390,18 +38384,37 @@ var VxeSliderComponent = defineVxeComponent({
                     }, evnt);
                     changeEvent(evnt);
                     updateTrackStyle();
+                    if (!internalData.isBtnActive) {
+                        handleHideTip();
+                    }
                 };
                 dispatchEvent('track-dragstart', {
                     currentValue: internalData.currValue,
                     startValue: internalData.startValue,
                     endValue: internalData.endValue
                 }, evnt);
+                internalData.isDragStatus = false;
+            }
+        };
+        const handleBtnMouseenterEvent = (evnt) => {
+            const { startValue, endValue } = internalData;
+            const btnElem = evnt.currentTarget;
+            const btnType = btnElem.getAttribute('data-type');
+            internalData.currValue = btnType === '1' ? startValue : endValue;
+            internalData.isBtnActive = true;
+            handleShowTip(btnElem);
+        };
+        const handleBtnMouseleaveEvent = () => {
+            const { isDragStatus } = internalData;
+            internalData.isBtnActive = false;
+            if (!isDragStatus) {
+                handleHideTip();
             }
         };
         const collapsePanePrivateMethods = {};
         Object.assign($xeSlider, collapsePaneMethods, collapsePanePrivateMethods);
         const renderVN = () => {
-            const { vertical, range } = props;
+            const { status, vertical, range } = props;
             const vSize = computeSize.value;
             const formReadonly = computeFormReadonly.value;
             const isDisabled = computeIsDisabled.value;
@@ -38409,6 +38422,7 @@ var VxeSliderComponent = defineVxeComponent({
                 ref: refElem,
                 class: ['vxe-slider', {
                         [`size--${vSize}`]: vSize,
+                        [`theme--${status}`]: status,
                         'is--vertical': vertical,
                         'is--readonly': formReadonly,
                         'is--disabled': isDisabled
@@ -38431,6 +38445,8 @@ var VxeSliderComponent = defineVxeComponent({
                             ref: refStartBtnElem,
                             class: 'vxe-slider--bar-btn',
                             'data-type': '1',
+                            onMouseenter: handleBtnMouseenterEvent,
+                            onMouseleave: handleBtnMouseleaveEvent,
                             onMousedown: handleBtnMousedownEvent
                         }),
                     formReadonly
@@ -38439,6 +38455,8 @@ var VxeSliderComponent = defineVxeComponent({
                             ref: refEndBtnElem,
                             class: 'vxe-slider--bar-btn',
                             'data-type': '2',
+                            onMouseenter: handleBtnMouseenterEvent,
+                            onMouseleave: handleBtnMouseleaveEvent,
                             onMousedown: handleBtnMousedownEvent
                         })
                 ])
@@ -38514,6 +38532,26 @@ var VxeSpaceComponent = defineVxeComponent({
         align: {
             type: String,
             default: () => getConfig$3().space.align
+        },
+        fill: {
+            type: Boolean,
+            default: () => getConfig$3().space.fill
+        },
+        itemWidth: {
+            type: [String, Number],
+            default: () => getConfig$3().space.itemWidth
+        },
+        itemMinWidth: {
+            type: [String, Number],
+            default: () => getConfig$3().space.itemMinWidth
+        },
+        itemMaxWidth: {
+            type: [String, Number],
+            default: () => getConfig$3().space.itemMaxWidth
+        },
+        separatorWidth: {
+            type: [String, Number],
+            default: () => getConfig$3().space.separatorWidth
         }
     },
     emits: [],
@@ -38576,20 +38614,36 @@ var VxeSpaceComponent = defineVxeComponent({
         const spacePrivateMethods = {};
         Object.assign($xeSpace, spaceMethods, spacePrivateMethods);
         const renderItems = () => {
-            const { separator, itemClassName } = props;
+            const { separator, itemClassName, itemWidth, itemMinWidth, itemMaxWidth, separatorWidth } = props;
             const itemVNs = [];
             const defaultSlot = slots.default;
             const separatorSlot = slots.separator;
+            const srStys = {};
+            if (separatorWidth) {
+                srStys.width = toCssUnit(itemWidth);
+            }
+            const itemStys = {};
+            if (itemWidth) {
+                itemStys.width = toCssUnit(itemWidth);
+            }
+            if (itemMinWidth) {
+                itemStys.minWidth = toCssUnit(itemMinWidth);
+            }
+            if (itemMaxWidth) {
+                itemStys.maxWidth = toCssUnit(itemMaxWidth);
+            }
             if (defaultSlot) {
                 XEUtils.each(defaultSlot({}), (itemVN, index, items) => {
                     itemVNs.push(h('div', {
                         key: 'i' + index,
-                        class: ['vxe-space--item', getPropClass(itemClassName, { index })]
+                        class: ['vxe-space--item', getPropClass(itemClassName, { index })],
+                        style: itemStys
                     }, [itemVN]));
                     if ((separator || separatorSlot) && index < items.length - 1) {
                         itemVNs.push(h('div', {
                             key: 's' + index,
-                            class: 'vxe-space--separator'
+                            class: 'vxe-space--separator',
+                            style: srStys
                         }, separatorSlot ? separatorSlot({}) : ('' + separator)));
                     }
                 });
@@ -38597,7 +38651,7 @@ var VxeSpaceComponent = defineVxeComponent({
             return itemVNs;
         };
         const renderVN = () => {
-            const { vertical, wrap, className } = props;
+            const { vertical, wrap, className, fill, itemWidth, itemMinWidth, itemMaxWidth } = props;
             const wrapperStyle = computeWrapperStyle.value;
             const vSize = computeSize.value;
             return h('div', {
@@ -38605,7 +38659,9 @@ var VxeSpaceComponent = defineVxeComponent({
                 class: ['vxe-space', getPropClass(className, {}), {
                         [`size--${vSize}`]: vSize,
                         'is--wrap': wrap,
-                        'is--vertical': vertical
+                        'is--vertical': vertical,
+                        'is--fill': fill,
+                        'is--width': itemWidth || itemMinWidth || itemMaxWidth
                     }],
                 style: wrapperStyle
             }, renderItems());
@@ -39472,21 +39528,6 @@ var VxeTableSelectComponent = defineVxeComponent({
             clearValueEvent(evnt, null);
             hideOptionPanel();
         };
-        const handleGlobalMousewheelEvent = (evnt) => {
-            const { visiblePanel } = reactData;
-            const isDisabled = computeIsDisabled.value;
-            if (!isDisabled) {
-                if (visiblePanel) {
-                    const panelElem = refOptionPanel.value;
-                    if (getEventTargetNode(evnt, panelElem).flag) {
-                        updatePlacement();
-                    }
-                    else {
-                        hideOptionPanel();
-                    }
-                }
-            }
-        };
         const handleGlobalMousedownEvent = (evnt) => {
             const { visiblePanel } = reactData;
             const isDisabled = computeIsDisabled.value;
@@ -39520,6 +39561,12 @@ var VxeTableSelectComponent = defineVxeComponent({
                 updatePlacement();
             }
         };
+        const handleGlobalScrollEvent = () => {
+            const { visiblePanel } = reactData;
+            if (visiblePanel) {
+                updatePlacement();
+            }
+        };
         const focusEvent = (evnt) => {
             const isDisabled = computeIsDisabled.value;
             if (!isDisabled) {
@@ -39705,16 +39752,16 @@ var VxeTableSelectComponent = defineVxeComponent({
                     reactData.initialized = true;
                 }
             }
-            globalEvents.on($xeTableSelect, 'mousewheel', handleGlobalMousewheelEvent);
             globalEvents.on($xeTableSelect, 'mousedown', handleGlobalMousedownEvent);
             globalEvents.on($xeTableSelect, 'blur', handleGlobalBlurEvent);
             globalEvents.on($xeTableSelect, 'resize', handleGlobalResizeEvent);
+            globalEvents.on($xeTableSelect, 'scroll', handleGlobalScrollEvent);
         });
         onUnmounted(() => {
-            globalEvents.off($xeTableSelect, 'mousewheel');
             globalEvents.off($xeTableSelect, 'mousedown');
             globalEvents.off($xeTableSelect, 'blur');
             globalEvents.off($xeTableSelect, 'resize');
+            globalEvents.off($xeTableSelect, 'scroll');
             XEUtils.assign(reactData, createReactData$5());
             XEUtils.assign(internalData, createInternalData$5());
         });
@@ -45987,21 +46034,6 @@ var VxeTreeSelectComponent = defineVxeComponent({
                 $tree.clearAllExpandNode();
             }
         };
-        const handleGlobalMousewheelEvent = (evnt) => {
-            const { visiblePanel } = reactData;
-            const isDisabled = computeIsDisabled.value;
-            if (!isDisabled) {
-                if (visiblePanel) {
-                    const panelElem = refOptionPanel.value;
-                    if (getEventTargetNode(evnt, panelElem).flag) {
-                        updatePlacement();
-                    }
-                    else {
-                        hideOptionPanel(evnt);
-                    }
-                }
-            }
-        };
         const handleGlobalMousedownEvent = (evnt) => {
             const { visiblePanel } = reactData;
             const isDisabled = computeIsDisabled.value;
@@ -46035,6 +46067,12 @@ var VxeTreeSelectComponent = defineVxeComponent({
                 updatePlacement();
             }
         };
+        const handleGlobalScrollEvent = () => {
+            const { visiblePanel } = reactData;
+            if (visiblePanel) {
+                updatePlacement();
+            }
+        };
         const handleFocusSearch = () => {
             if (props.filterable) {
                 nextTick(() => {
@@ -46405,16 +46443,16 @@ var VxeTreeSelectComponent = defineVxeComponent({
             if (XEUtils.isBoolean(props.autoClose)) {
                 warnLog$1('vxe.error.delProp', ['auto-close', 'checked-closable | clear-closable']);
             }
-            globalEvents.on($xeTreeSelect, 'mousewheel', handleGlobalMousewheelEvent);
             globalEvents.on($xeTreeSelect, 'mousedown', handleGlobalMousedownEvent);
             globalEvents.on($xeTreeSelect, 'blur', handleGlobalBlurEvent);
             globalEvents.on($xeTreeSelect, 'resize', handleGlobalResizeEvent);
+            globalEvents.on($xeTreeSelect, 'scroll', handleGlobalScrollEvent);
         });
         onBeforeUnmount(() => {
-            globalEvents.off($xeTreeSelect, 'mousewheel');
             globalEvents.off($xeTreeSelect, 'mousedown');
             globalEvents.off($xeTreeSelect, 'blur');
             globalEvents.off($xeTreeSelect, 'resize');
+            globalEvents.off($xeTreeSelect, 'scroll');
             XEUtils.assign(reactData, createReactData$1());
             XEUtils.assign(internalData, createInternalData$1());
         });