vxe-pc-ui 4.15.1 → 4.15.3

package/dist/all.esm.js

@@ -80,19 +80,25 @@ function checkDynamic() {
     }
 }
 
-const version$1 = `ui v${"4.15.1"}`;
-const warnLog = log.create('warn', version$1);
-const errLog = log.create('error', version$1);
+const version$1 = `ui v${"4.15.3"}`;
+function createComponentLog(name) {
+    return {
+        warnLog: log.create('warn', `${version$1} ${name}`),
+        errLog: log.create('error', `${version$1} ${name}`)
+    };
+}
+const warnLog$b = log.create('warn', version$1);
+log.create('error', version$1);
 
-const version = "4.15.1";
+const version = "4.15.3";
 VxeUI.uiVersion = version;
 VxeUI.dynamicApp = dynamicApp;
 function config(options) {
-    warnLog('vxe.error.delFunc', ['config', 'setConfig']);
+    warnLog$b('vxe.error.delFunc', ['config', 'setConfig']);
     return setConfig$1(options);
 }
 function setup(options) {
-    warnLog('vxe.error.delFunc', ['setup', 'setConfig']);
+    warnLog$b('vxe.error.delFunc', ['setup', 'setConfig']);
     return setConfig$1(options);
 }
 VxeUI.config = config;
@@ -3041,6 +3047,7 @@ dynamicApp.use(VxeTooltip);
 VxeUI.component(VxeTooltipComponent);
 const Tooltip = VxeTooltip;
 
+const { warnLog: warnLog$a } = createComponentLog('button');
 const VxeButtonComponent = defineVxeComponent({
     name: 'VxeButton',
     props: {
@@ -3759,7 +3766,7 @@ const VxeButtonComponent = defineVxeComponent({
         $xeButton.renderVN = renderVN;
         onMounted(() => {
             if (props.type === 'text') {
-                warnLog('vxe.error.delProp', ['[button] type=text', 'mode=text']);
+                warnLog$a('vxe.error.delProp', ['type=text', 'mode=text']);
             }
             globalEvents.on($xeButton, 'mousewheel', handleGlobalMousewheelEvent);
             globalEvents.on($xeButton, 'mousedown', handleGlobalMousedownEvent);
@@ -3786,12 +3793,13 @@ dynamicApp.use(VxeButton);
 VxeUI.component(VxeButtonComponent);
 const Button = VxeButton;
 
-function createInternalData$d() {
+const { errLog: errLog$h } = createComponentLog('backtop');
+function createInternalData$e() {
     return {
         targetEl: null
     };
 }
-function createReactData$a() {
+function createReactData$f() {
     return {
         showBtn: false,
         backtopZindex: 0
@@ -3870,8 +3878,8 @@ var VxeBacktopComponent = defineVxeComponent({
         const xID = XEUtils.uniqueId();
         const refElem = ref();
         const { computeSize } = useSize(props);
-        const internalData = createInternalData$d();
-        const reactData = reactive(createReactData$a());
+        const internalData = createInternalData$e();
+        const reactData = reactive(createReactData$f());
         const refMaps = {
             refElem
         };
@@ -3963,13 +3971,13 @@ var VxeBacktopComponent = defineVxeComponent({
                 const { target } = props;
                 if (!target) {
                     removeScrollEvent();
-                    errLog('vxe.error.reqProp', ['target']);
+                    errLog$h('vxe.error.reqProp', ['target']);
                     return;
                 }
                 if (XEUtils.isString(target)) {
                     const tEl = document.querySelector(target);
                     if (!tEl) {
-                        errLog('vxe.error.errProp', [`target=${target}`, 'body']);
+                        errLog$h('vxe.error.errProp', [`target=${target}`, 'body']);
                     }
                     const { targetEl } = internalData;
                     if (targetEl !== tEl) {
@@ -4048,8 +4056,8 @@ var VxeBacktopComponent = defineVxeComponent({
         });
         onBeforeUnmount(() => {
             removeScrollEvent();
-            XEUtils.assign(reactData, createReactData$a());
-            XEUtils.assign(internalData, createInternalData$d());
+            XEUtils.assign(reactData, createReactData$f());
+            XEUtils.assign(internalData, createInternalData$e());
         });
         $xeBacktop.renderVN = renderVN;
         return $xeBacktop;
@@ -4412,6 +4420,18 @@ dynamicApp.use(VxeButtonGroup);
 VxeUI.component(VxeButtonGroupComponent);
 const ButtonGroup = VxeButtonGroup;
 
+function getChunkDefaultNum(selectKey) {
+    const currDate = new Date();
+    switch (selectKey) {
+        case 'y': return currDate.getFullYear();
+        case 'M': return currDate.getMonth() + 1;
+        case 'd': return currDate.getDate();
+        case 'H': return currDate.getHours();
+        case 'm': return currDate.getMinutes();
+        case 's': return currDate.getSeconds();
+    }
+    return 0;
+}
 function hasTimestampValueType(valueFormat) {
     return valueFormat === 'timestamp';
 }
@@ -4475,7 +4495,7 @@ function getDateQuarter(date) {
     }
     return 4;
 }
-const parseDateValue = (val, type, options) => {
+function parseDateValue(val, type, options) {
     const { valueFormat } = options;
     if (val) {
         if (type === 'time') {
@@ -4490,7 +4510,7 @@ const parseDateValue = (val, type, options) => {
         return XEUtils.toStringDate(val, valueFormat);
     }
     return null;
-};
+}
 const parseDateString = (val, type, options) => {
     const dValue = parseDateValue(val, type, options);
     return dValue ? XEUtils.toDateString(dValue, options.valueFormat) : '';
@@ -4627,10 +4647,22 @@ function getRangeDateByCode(code, val, type, options) {
 /**
  * 判断周的年份是否跨年
  */
-const checkWeekOfsetYear = (W, M) => {
+function checkWeekOfsetYear(W, M) {
     return `${W}` === '1' && `${M}` === '12';
-};
+}
+function isAllSameChar(str, char) {
+    if (str.length === 0) {
+        return false;
+    }
+    for (let i = 0; i < str.length; i++) {
+        if (str[i] !== char) {
+            return false;
+        }
+    }
+    return true;
+}
 
+const { errLog: errLog$g } = createComponentLog('calendar');
 const { menus: menus$2, getConfig: getConfig$2, getI18n: getI18n$1 } = VxeUI;
 var VxeCalendarComponent = defineVxeComponent({
     name: 'VxeCalendar',
@@ -5898,7 +5930,7 @@ var VxeCalendarComponent = defineVxeComponent({
             const { menuConfig } = props;
             const VxeUIContextMenu = VxeUI.getComponent('VxeContextMenu');
             if (menuConfig && !VxeUIContextMenu) {
-                errLog('vxe.error.reqComp', ['vxe-context-menu']);
+                errLog$g('vxe.error.reqComp', ['vxe-context-menu']);
             }
             dateOpenPanel();
         });
@@ -6680,7 +6712,7 @@ function deNodeValue$1(nodeid) {
     return nodeid ? decodeURIComponent(`${nodeid}`) : nodeid;
 }
 
-function createReactData$9() {
+function createReactData$e() {
     return {
         scrollYLoad: false,
         bodyHeight: 0,
@@ -6691,7 +6723,7 @@ function createReactData$9() {
         items: []
     };
 }
-function createInternalData$c() {
+function createInternalData$d() {
     return {
         resizeObserver: undefined,
         fullData: [],
@@ -6734,8 +6766,8 @@ var VxeListComponent = defineVxeComponent({
         const xID = XEUtils.uniqueId();
         const browseObj = XEUtils.browse();
         const { computeSize } = useSize(props);
-        const reactData = reactive(createReactData$9());
-        const internalData = createInternalData$c();
+        const reactData = reactive(createReactData$e());
+        const internalData = createInternalData$d();
         const refElem = ref();
         const refVirtualWrapper = ref();
         const refVirtualBody = ref();
@@ -7067,8 +7099,8 @@ var VxeListComponent = defineVxeComponent({
                 resizeObserver.disconnect();
             }
             globalEvents.off($xeList, 'resize');
-            XEUtils.assign(reactData, createReactData$9());
-            XEUtils.assign(internalData, createInternalData$c());
+            XEUtils.assign(reactData, createReactData$e());
+            XEUtils.assign(internalData, createInternalData$d());
         });
         $xeList.renderVN = renderVN;
         return $xeList;
@@ -7100,6 +7132,7 @@ function toFloatValueFixed(inputValue, type, digitsValue, roundingMode) {
     }
 }
 
+const { warnLog: warnLog$9 } = createComponentLog('input');
 var VxeInputComponent = defineVxeComponent({
     name: 'VxeInput',
     props: {
@@ -9736,13 +9769,13 @@ var VxeInputComponent = defineVxeComponent({
         onMounted(() => {
             const { type } = props;
             if (['date', 'time', 'datetime', 'week', 'month', 'quarter', 'year'].includes(type)) {
-                warnLog('vxe.error.useNew', [`<vxe-input type="${type}" ... />`, `<vxe-date-picker type="${type}" ... />`]);
+                warnLog$9('vxe.error.useNew', [`<vxe-input type="${type}" ... />`, `<vxe-date-picker type="${type}" ... />`]);
             }
             else if (['number', 'integer', 'float'].includes(type)) {
-                warnLog('vxe.error.useNew', [`<vxe-input type="${type}" ... />`, `<vxe-number-input type="${type}" ... />`]);
+                warnLog$9('vxe.error.useNew', [`<vxe-input type="${type}" ... />`, `<vxe-number-input type="${type}" ... />`]);
             }
             else if (['password'].includes(type)) {
-                warnLog('vxe.error.useNew', [`<vxe-input type="${type}" ... />`, '<vxe-password-input ... />']);
+                warnLog$9('vxe.error.useNew', [`<vxe-input type="${type}" ... />`, '<vxe-password-input ... />']);
             }
             const inputElem = refInputTarget.value;
             if (inputElem) {
@@ -9774,13 +9807,14 @@ var VxeInputComponent = defineVxeComponent({
     }
 });
 
+const { errLog: errLog$f } = createComponentLog('cascader');
 /**
  * 生成节点的唯一主键
  */
 function getNodeUniqueId$1() {
     return XEUtils.uniqueId('node_');
 }
-function createReactData$8() {
+function createReactData$d() {
     return {
         initialized: false,
         searchValue: '',
@@ -9803,7 +9837,7 @@ function createReactData$8() {
         lazyOptFlag: 1
     };
 }
-function createInternalData$b() {
+function createInternalData$c() {
     return {
         // hpTimeout: undefined,
         listVirtualYOpts: {
@@ -9930,8 +9964,8 @@ var VxeCascaderComponent = defineVxeComponent({
         const refInpSearch = ref();
         const refChunkWrapper = ref();
         const refOptionPanel = ref();
-        const reactData = reactive(createReactData$8());
-        const internalData = createInternalData$b();
+        const reactData = reactive(createReactData$d());
+        const internalData = createInternalData$c();
         const refMaps = {
             refElem
         };
@@ -11447,7 +11481,7 @@ var VxeCascaderComponent = defineVxeComponent({
         loadData(props.options || []);
         onMounted(() => {
             if (props.filterable) {
-                errLog('vxe.error.notProp', ['filterable']);
+                errLog$f('vxe.error.notProp', ['filterable']);
             }
             globalEvents.on($xeCascader, 'mousewheel', handleGlobalMousewheelEvent);
             globalEvents.on($xeCascader, 'mousedown', handleGlobalMousedownEvent);
@@ -11459,7 +11493,7 @@ var VxeCascaderComponent = defineVxeComponent({
             globalEvents.off($xeCascader, 'mousedown');
             globalEvents.off($xeCascader, 'blur');
             globalEvents.off($xeCascader, 'resize');
-            XEUtils.assign(internalData, createInternalData$b());
+            XEUtils.assign(internalData, createInternalData$c());
         });
         provide('$xeCascader', $xeCascader);
         $xeCascader.renderVN = renderVN;
@@ -11792,7 +11826,10 @@ dynamicApp.use(VxeCheckboxButton);
 VxeUI.component(VxeCheckboxButtonComponent);
 const CheckboxButton = VxeCheckboxButton;
 
-function createInternalData$a() {
+function createReactData$c() {
+    return {};
+}
+function createInternalData$b() {
     return {
     // isLoaded: false
     };
@@ -11831,8 +11868,8 @@ var VxeCheckboxGroupComponent = defineVxeComponent({
         const $xeForm = inject('$xeForm', null);
         const formItemInfo = inject('xeFormItemInfo', null);
         const xID = XEUtils.uniqueId();
-        const reactData = reactive({});
-        const internalData = createInternalData$a();
+        const reactData = reactive(createReactData$c());
+        const internalData = createInternalData$b();
         const computeIsReadonly = computed(() => {
             const { readonly } = props;
             if (readonly === null) {
@@ -11991,7 +12028,8 @@ var VxeCheckboxGroupComponent = defineVxeComponent({
             });
         });
         onUnmounted(() => {
-            XEUtils.assign(internalData, createInternalData$a());
+            XEUtils.assign(reactData, createReactData$c());
+            XEUtils.assign(internalData, createInternalData$b());
         });
         provide('$xeCheckboxGroup', $xeCheckboxGroup);
         $xeCheckboxGroup.renderVN = renderVN;
@@ -12709,7 +12747,6 @@ var VxeNumberInputComponent = defineVxeComponent({
             type: String,
             default: () => getConfig$3().numberInput.size || getConfig$3().size
         },
-        // number、integer、float
         min: {
             type: [String, Number],
             default: null
@@ -12732,12 +12769,12 @@ var VxeNumberInputComponent = defineVxeComponent({
             default: () => getConfig$3().numberInput.currencySymbol
         },
         controlConfig: Object,
-        // float
+        // number、float、amount
         roundingMode: {
             type: String,
             default: () => getConfig$3().numberInput.roundingMode
         },
-        // float
+        // float、amount
         digits: {
             type: [String, Number],
             default: null
@@ -14734,12 +14771,12 @@ dynamicApp.use(VxeColorPicker);
 VxeUI.component(VxeColorPickerComponent);
 const ColorPicker = VxeColorPicker;
 
-function createInternalData$9() {
+function createInternalData$a() {
     return {
     // leaveTime: null
     };
 }
-function createReactData$7() {
+function createReactData$b() {
     return {
         visible: false,
         activeOption: null,
@@ -14794,8 +14831,8 @@ var VxeContextMenuComponent = defineVxeComponent({
         const xID = XEUtils.uniqueId();
         const refElem = ref();
         const { computeSize } = useSize(props);
-        const internalData = createInternalData$9();
-        const reactData = reactive(createReactData$7());
+        const internalData = createInternalData$a();
+        const reactData = reactive(createReactData$b());
         const refMaps = {
             refElem
         };
@@ -15350,8 +15387,8 @@ var VxeContextMenuComponent = defineVxeComponent({
             globalEvents.off($xeContextMenu, 'keydown');
             globalEvents.off($xeContextMenu, 'mousedown');
             globalEvents.off($xeContextMenu, 'blur');
-            XEUtils.assign(reactData, createReactData$7());
-            XEUtils.assign(internalData, createInternalData$9());
+            XEUtils.assign(reactData, createReactData$b());
+            XEUtils.assign(internalData, createInternalData$a());
         });
         $xeContextMenu.renderVN = renderVN;
         return $xeContextMenu;
@@ -17609,6 +17646,33 @@ dynamicApp.use(VxeDatePanel);
 VxeUI.component(VxeDatePanelComponent);
 const DatePanel = VxeDatePanel;
 
+const { warnLog: warnLog$8, errLog: errLog$e } = createComponentLog('date-picker');
+const maskedTypes = ['year', 'month', 'date', 'datetime', 'time'];
+const inputMaskedKeys = ['y', 'M', 'd', 'H', 'm', 'n', 's'];
+const parseInputKayMaps = {};
+inputMaskedKeys.forEach(key => {
+    parseInputKayMaps[key] = true;
+});
+function createReactData$a() {
+    return {
+        initialized: false,
+        panelIndex: 0,
+        visiblePanel: false,
+        isAniVisible: false,
+        panelStyle: {},
+        panelPlacement: '',
+        isActivated: false,
+        inputValue: '',
+        labelFlag: 0
+    };
+}
+function createInternalData$9() {
+    return {
+        // hpTimeout: undefined,
+        inputLabel: '',
+        laseFocusMasked: 0
+    };
+}
 var VxeDatePickerComponent = defineVxeComponent({
     name: 'VxeDatePicker',
     props: {
@@ -17700,6 +17764,7 @@ var VxeDatePickerComponent = defineVxeComponent({
             type: Boolean,
             default: () => getConfig$3().datePicker.autoClose
         },
+        maskedConfig: Object,
         prefixIcon: String,
         suffixIcon: String,
         placement: String,
@@ -17740,20 +17805,8 @@ var VxeDatePickerComponent = defineVxeComponent({
         const formItemInfo = inject('xeFormItemInfo', null);
         const xID = XEUtils.uniqueId();
         const { computeSize } = useSize(props);
-        const reactData = reactive({
-            initialized: false,
-            panelIndex: 0,
-            visiblePanel: false,
-            isAniVisible: false,
-            panelStyle: {},
-            panelPlacement: '',
-            isActivated: false,
-            inputValue: '',
-            inputLabel: ''
-        });
-        const internalData = {
-            hpTimeout: undefined
-        };
+        const reactData = reactive(createReactData$a());
+        const internalData = createInternalData$9();
         const refElem = ref();
         const refInputTarget = ref();
         const refInputPanel = ref();
@@ -17819,6 +17872,44 @@ var VxeDatePickerComponent = defineVxeComponent({
         const computeIsClearable = computed(() => {
             return props.clearable;
         });
+        const computeIsDatePanelType = computed(() => {
+            const isDateTimeType = computeIsDateTimeType.value;
+            return isDateTimeType || ['date', 'week', 'month', 'quarter', 'year'].indexOf(props.type) > -1;
+        });
+        const computeDateListValue = computed(() => {
+            const { modelValue, type, multiple } = props;
+            const isDatePanelType = computeIsDatePanelType.value;
+            const dateValueFormat = computeDateValueFormat.value;
+            if (multiple && modelValue && isDatePanelType) {
+                return XEUtils.toValueString(modelValue).split(',').map(item => {
+                    const date = parseDateValue(item, type, {
+                        valueFormat: dateValueFormat
+                    });
+                    if (XEUtils.isValidDate(date)) {
+                        return date;
+                    }
+                    return date;
+                });
+            }
+            return [];
+        });
+        const computeLimitMaxCount = computed(() => {
+            return props.multiple ? XEUtils.toNumber(props.limitCount) : 0;
+        });
+        const computeDateMultipleValue = computed(() => {
+            const dateListValue = computeDateListValue.value;
+            const dateValueFormat = computeDateValueFormat.value;
+            return dateListValue.map(date => XEUtils.toDateString(date, dateValueFormat));
+        });
+        const computeOverCount = computed(() => {
+            const { multiple } = props;
+            const limitMaxCount = computeLimitMaxCount.value;
+            const dateMultipleValue = computeDateMultipleValue.value;
+            if (multiple && limitMaxCount) {
+                return dateMultipleValue.length >= limitMaxCount;
+            }
+            return false;
+        });
         const computeInputReadonly = computed(() => {
             const { type, editable, multiple } = props;
             const formReadonly = computeFormReadonly.value;
@@ -17868,6 +17959,10 @@ var VxeDatePickerComponent = defineVxeComponent({
             const { type, valueFormat } = props;
             return handleValueFormat(type, valueFormat);
         });
+        const computeDateMaskedFormat = computed(() => {
+            const dateLabelFormat = computeDateLabelFormat.value;
+            return dateLabelFormat;
+        });
         const computeFirstDayOfWeek = computed(() => {
             const { startDay } = props;
             return XEUtils.toNumber(startDay);
@@ -17888,6 +17983,14 @@ var VxeDatePickerComponent = defineVxeComponent({
                 return dateObj.label;
             }).join(', ');
         });
+        const computeMaskedOpts = computed(() => {
+            return Object.assign({}, getConfig$3().datePicker.maskedConfig, props.maskedConfig);
+        });
+        const computeMaskChar = computed(() => {
+            const maskedOpts = computeMaskedOpts.value;
+            const { maskPlaceholder } = maskedOpts;
+            return (maskPlaceholder ? ('' + maskPlaceholder)[0] : '') || '*';
+        });
         const updateModelValue = () => {
             const { modelValue } = props;
             let val = '';
@@ -17901,6 +18004,12 @@ var VxeDatePickerComponent = defineVxeComponent({
             }
             reactData.inputValue = val;
         };
+        const handleInputLabel = (text, isUpdate) => {
+            internalData.inputLabel = text;
+            if (isUpdate) {
+                reactData.labelFlag++;
+            }
+        };
         const triggerEvent = (evnt) => {
             const { inputValue } = reactData;
             dispatchEvent(evnt.type, { value: inputValue }, evnt);
@@ -17946,7 +18055,7 @@ var VxeDatePickerComponent = defineVxeComponent({
         const inputEvent = (evnt) => {
             const inputElem = evnt.target;
             const value = inputElem.value;
-            reactData.inputLabel = value;
+            handleInputLabel(value, true);
             dispatchEvent('input', { value }, evnt);
         };
         const changeEvent = (evnt) => {
@@ -17955,15 +18064,6 @@ var VxeDatePickerComponent = defineVxeComponent({
                 triggerEvent(evnt);
             }
         };
-        const focusEvent = (evnt) => {
-            const popupOpts = computePopupOpts.value;
-            const { trigger } = popupOpts;
-            reactData.isActivated = true;
-            if (!trigger || trigger === 'default') {
-                datePickerOpenEvent(evnt);
-            }
-            triggerEvent(evnt);
-        };
         const clickPrefixEvent = (evnt) => {
             const isDisabled = computeIsDisabled.value;
             if (!isDisabled) {
@@ -17980,6 +18080,107 @@ var VxeDatePickerComponent = defineVxeComponent({
                 }, 350);
             });
         };
+        const dateChange = (date, isReload) => {
+            const { modelValue, multiple } = props;
+            const isDateTimeType = computeIsDateTimeType.value;
+            const dateValueFormat = computeDateValueFormat.value;
+            const firstDayOfWeek = computeFirstDayOfWeek.value;
+            if (props.type === 'week') {
+                const sWeek = XEUtils.toNumber(props.selectDay);
+                date = XEUtils.getWhatWeek(date, 0, sWeek, firstDayOfWeek);
+            }
+            const inpVal = XEUtils.toDateString(date, dateValueFormat, { firstDay: firstDayOfWeek });
+            if (multiple) {
+                const overCount = computeOverCount.value;
+                // 如果为多选
+                if (isDateTimeType) {
+                    // 如果是datetime特殊类型
+                    const dateListValue = [...computeDateListValue.value];
+                    const datetimeRest = [];
+                    const eqIndex = XEUtils.findIndexOf(dateListValue, val => XEUtils.isDateSame(date, val, 'yyyyMMdd'));
+                    if (eqIndex === -1) {
+                        if (overCount) {
+                            // 如果超出最大多选数量
+                            return;
+                        }
+                        dateListValue.push(date);
+                    }
+                    else {
+                        dateListValue.splice(eqIndex, 1);
+                    }
+                    dateListValue.forEach(item => {
+                        if (item) {
+                            datetimeRest.push(item);
+                        }
+                    });
+                    handleChange(datetimeRest.map(date => XEUtils.toDateString(date, dateValueFormat)).join(','), { type: 'update' });
+                }
+                else {
+                    const dateMultipleValue = computeDateMultipleValue.value;
+                    // 如果是日期类型
+                    if (dateMultipleValue.some(val => XEUtils.isEqual(val, inpVal))) {
+                        handleChange(dateMultipleValue.filter(val => !XEUtils.isEqual(val, inpVal)).join(','), { type: 'update' });
+                    }
+                    else {
+                        if (overCount) {
+                            // 如果超出最大多选数量
+                            return;
+                        }
+                        handleChange(dateMultipleValue.concat([inpVal]).join(','), { type: 'update' });
+                    }
+                }
+            }
+            else {
+                // 如果为单选
+                if (!XEUtils.isEqual(modelValue, inpVal)) {
+                    handleChange(inpVal, { type: 'update' });
+                }
+            }
+        };
+        const dateRevert = () => {
+            const panelLabel = computePanelLabel.value;
+            handleInputLabel(panelLabel, true);
+        };
+        const afterCheckValue = (inpVal) => {
+            const { type } = props;
+            const { inputLabel } = internalData;
+            const dateLabelFormat = computeDateLabelFormat.value;
+            if (!inpVal) {
+                handleChange('', { type: 'check' });
+                return;
+            }
+            let inpDateVal = parseDateValue(inpVal, type, {
+                valueFormat: dateLabelFormat
+            });
+            if (!XEUtils.isValidDate(inpDateVal)) {
+                dateRevert();
+                return;
+            }
+            if (type === 'time') {
+                inpDateVal = XEUtils.toDateString(inpDateVal, dateLabelFormat);
+                if (inputLabel !== inpDateVal) {
+                    handleChange(inpDateVal, { type: 'check' });
+                }
+                handleInputLabel(inpDateVal, true);
+                return;
+            }
+            let isChange = false;
+            const firstDayOfWeek = computeFirstDayOfWeek.value;
+            if (type === 'datetime') {
+                const dateValue = reactData.inputValue;
+                if (inpVal !== XEUtils.toDateString(dateValue, dateLabelFormat) || inpVal !== XEUtils.toDateString(inpDateVal, dateLabelFormat)) {
+                    isChange = true;
+                }
+            }
+            else {
+                isChange = true;
+            }
+            const label = XEUtils.toDateString(inpDateVal, dateLabelFormat, { firstDay: firstDayOfWeek });
+            handleInputLabel(label, true);
+            if (isChange) {
+                dateChange(inpDateVal);
+            }
+        };
         const clearValueEvent = (evnt, value) => {
             const isDatePickerType = computeIsDatePickerType.value;
             if (isDatePickerType) {
@@ -17995,6 +18196,298 @@ var VxeDatePickerComponent = defineVxeComponent({
                 dispatchEvent('suffix-click', { value: inputValue }, evnt);
             }
         };
+        const handleArrowInputDate = (evnt, isUpArrow, isDwArrow, isLtArrow, isRtArrow) => {
+            const { type, multiple } = props;
+            if (multiple) {
+                return;
+            }
+            const targetElem = refInputTarget.value;
+            if (!targetElem) {
+                return;
+            }
+            const inpValue = targetElem.value;
+            if (!inpValue) {
+                return;
+            }
+            const dateMaskedFormat = computeDateMaskedFormat.value;
+            const dateLabelFormat = computeDateLabelFormat.value;
+            const firstDayOfWeek = computeFirstDayOfWeek.value;
+            const maskChar = computeMaskChar.value;
+            const selectionStart = targetElem.selectionStart || 0;
+            let selectKey = dateMaskedFormat[selectionStart];
+            if (!parseInputKayMaps[selectKey]) {
+                selectKey = dateMaskedFormat[selectionStart - 1];
+            }
+            const skRest = dateMaskedFormat.match(new RegExp(selectKey + '+'));
+            if (!skRest) {
+                return;
+            }
+            if (isUpArrow || isDwArrow) {
+                const chunkFormat = skRest[0] || '';
+                const chunkStartIndex = skRest.index || 0;
+                const chunkEndIndex = chunkStartIndex + chunkFormat.length;
+                const chunkValue = inpValue.slice(chunkStartIndex, chunkEndIndex);
+                if (parseInputKayMaps[selectKey]) {
+                    const chunkNum = (isAllSameChar(chunkValue, maskChar) ? getChunkDefaultNum(selectKey) : XEUtils.toNumber(chunkValue)) + (isUpArrow ? 1 : -1);
+                    const restValue = inpValue.slice(0, chunkStartIndex) + XEUtils.padStart(chunkNum, chunkFormat.length, '0') + inpValue.slice(chunkEndIndex);
+                    evnt.preventDefault();
+                    if (restValue.indexOf(maskChar) === -1) {
+                        // 解析日期
+                        const inpDateVal = parseDateValue(restValue, type, {
+                            valueFormat: dateLabelFormat
+                        });
+                        if (XEUtils.isValidDate(inpDateVal)) {
+                            const label = XEUtils.toDateString(inpDateVal, dateLabelFormat, { firstDay: firstDayOfWeek });
+                            targetElem.value = label;
+                            handleInputLabel(label, false);
+                        }
+                    }
+                    else {
+                        targetElem.value = restValue;
+                        handleInputLabel(restValue, false);
+                    }
+                }
+                targetElem.setSelectionRange(chunkStartIndex, chunkEndIndex);
+            }
+            else if (isLtArrow || isRtArrow) {
+                const currKeyIndex = inputMaskedKeys.indexOf(selectKey);
+                if (currKeyIndex > -1) {
+                    const allMaskedKeys = XEUtils.map(dateMaskedFormat.match(new RegExp(`(${inputMaskedKeys.join('|')})+`, 'g')) || [], fullKey => fullKey[0]);
+                    const currIndex = XEUtils.findIndexOf(allMaskedKeys, key => selectKey === key[0]);
+                    const targetFormatKey = isLtArrow ? (allMaskedKeys[currIndex - 1] || allMaskedKeys[0]) : (allMaskedKeys[currIndex + 1] || allMaskedKeys[allMaskedKeys.length - 1]);
+                    const targetKey = targetFormatKey ? targetFormatKey[0] : '';
+                    const sktRest = dateMaskedFormat.match(new RegExp(targetKey + '+'));
+                    if (sktRest) {
+                        evnt.preventDefault();
+                        const mtStartIndex = sktRest.index || 0;
+                        const mtEndIndex = mtStartIndex + sktRest[0].length;
+                        targetElem.setSelectionRange(mtStartIndex, mtEndIndex);
+                    }
+                }
+            }
+            internalData.isTriggerMasked = true;
+        };
+        const handleMaskedInputDate = (evnt) => {
+            const { multiple } = props;
+            if (multiple) {
+                return;
+            }
+            const targetElem = refInputTarget.value;
+            if (!targetElem) {
+                return;
+            }
+            const isControlKey = hasControlKey(evnt);
+            if (isControlKey) {
+                return;
+            }
+            evnt.preventDefault();
+            const eKey = evnt.key;
+            const isDeleleKey = globalEvents.hasKey(evnt, GLOBAL_EVENT_KEYS.DELETE);
+            const isBackspaceKey = globalEvents.hasKey(evnt, GLOBAL_EVENT_KEYS.BACKSPACE);
+            const isNumKey = eKey >= '0' && eKey <= '9';
+            const numKey = isNumKey ? evnt.key : '';
+            if (!(isDeleleKey || isBackspaceKey || isNumKey)) {
+                return;
+            }
+            const { isTriggerMasked } = internalData;
+            const dateMaskedFormat = computeDateMaskedFormat.value;
+            const maskChar = computeMaskChar.value;
+            let inpValue = targetElem.value || dateMaskedFormat;
+            const selectionStart = targetElem.selectionStart || 0;
+            const selectionEnd = targetElem.selectionEnd || 0;
+            let selectKey = dateMaskedFormat[selectionStart];
+            if (!parseInputKayMaps[selectKey]) {
+                selectKey = dateMaskedFormat[selectionStart - 1];
+            }
+            const skRest = dateMaskedFormat.match(new RegExp(selectKey + '+'));
+            if (!skRest) {
+                return;
+            }
+            const allMaskedKeys = XEUtils.map(dateMaskedFormat.match(new RegExp(`(${inputMaskedKeys.join('|')})+`, 'g')) || [], fullKey => fullKey[0]);
+            const chunkFormat = skRest[0] || '';
+            const chunkStartIndex = skRest.index || 0;
+            const chunkEndIndex = chunkStartIndex + chunkFormat.length;
+            const currKeyIndex = allMaskedKeys.indexOf(selectKey);
+            // 全选 | 如果无效字符
+            const isAllSelected = !selectionStart && selectionEnd === inpValue.length;
+            const isNotMasked = inpValue && inpValue.length !== dateMaskedFormat.length;
+            if (isAllSelected || isNotMasked) {
+                inpValue = dateMaskedFormat;
+            }
+            let chunkValue = isDeleleKey ? '' : inpValue.slice(chunkStartIndex, chunkEndIndex);
+            const chunkNums = (chunkValue.match(/\d/g) || []);
+            const chunkNumList = isTriggerMasked && !isBackspaceKey ? [] : chunkNums.slice(0);
+            if (isNumKey) {
+                chunkNumList.push(numKey);
+            }
+            else if (isBackspaceKey) {
+                chunkNumList.pop();
+            }
+            chunkValue = chunkNumList.join('').padEnd(chunkFormat.length, maskChar);
+            let restValue = inpValue.slice(0, chunkStartIndex) + chunkValue + inpValue.slice(chunkEndIndex);
+            restValue = restValue.replace(new RegExp(`(${inputMaskedKeys.join('|')})`, 'g'), maskChar);
+            targetElem.value = restValue;
+            handleInputLabel(restValue, false);
+            // 如果是全选/删除
+            if (isAllSelected) {
+                if (isBackspaceKey || isDeleleKey) {
+                    const firstMaskedKeys = allMaskedKeys[0];
+                    const firstSkRest = dateMaskedFormat.match(new RegExp(`${firstMaskedKeys}+`));
+                    if (firstSkRest) {
+                        const firstChunkFormat = firstSkRest[0];
+                        targetElem.setSelectionRange(0, firstChunkFormat.length);
+                        internalData.isTriggerMasked = true;
+                        return;
+                    }
+                }
+            }
+            else {
+                if (isBackspaceKey && !chunkNums.length) {
+                    // 回退到上一个数字块
+                    for (let i = currKeyIndex - 1; i >= 0; i--) {
+                        const prveChunkKey = allMaskedKeys[i];
+                        const prveSkRest = dateMaskedFormat.match(new RegExp(`${prveChunkKey}+`));
+                        if (prveSkRest) {
+                            const prveChunkFormat = prveSkRest[0];
+                            const prveChunkStartIndex = prveSkRest.index || 0;
+                            const prveChunkEndIndex = prveChunkStartIndex + prveChunkFormat.length;
+                            let prveChunkValue = restValue.slice(prveChunkStartIndex, prveChunkEndIndex);
+                            const prveChunkNums = (prveChunkValue.match(/\d/g) || []);
+                            if (prveChunkNums.length) {
+                                prveChunkNums.pop();
+                                prveChunkValue = prveChunkNums.join('').padEnd(prveChunkFormat.length, maskChar);
+                                restValue = restValue.slice(0, prveChunkStartIndex) + prveChunkValue + restValue.slice(prveChunkEndIndex);
+                                targetElem.value = restValue;
+                                handleInputLabel(restValue, false);
+                                targetElem.setSelectionRange(prveChunkStartIndex, prveChunkEndIndex);
+                                return;
+                            }
+                        }
+                    }
+                    const firstMaskedKeys = allMaskedKeys[0];
+                    const firstSkRest = dateMaskedFormat.match(new RegExp(`${firstMaskedKeys}+`));
+                    if (firstSkRest) {
+                        const firstChunkFormat = firstSkRest[0];
+                        restValue = dateMaskedFormat.replace(new RegExp(`(${inputMaskedKeys.join('|')})`, 'g'), maskChar);
+                        targetElem.value = restValue;
+                        handleInputLabel(restValue, false);
+                        targetElem.setSelectionRange(0, firstChunkFormat.length);
+                        internalData.isTriggerMasked = true;
+                        return;
+                    }
+                    return;
+                }
+            }
+            let maskStartIndex = skRest.index || 0;
+            let maskEndIndex = maskStartIndex + skRest[0].length;
+            // 如果输入完成，跳转下一个
+            if (chunkNumList.length >= chunkValue.length) {
+                const nextKeys = allMaskedKeys.slice(currKeyIndex + 1);
+                if (currKeyIndex > -1) {
+                    const nextRest = nextKeys.length ? dateMaskedFormat.match(new RegExp(`(${nextKeys.join('|')})+`)) : null;
+                    // 如果当前数字块已输入，则跳转下一个数字块
+                    if (nextRest) {
+                        maskStartIndex = nextRest.index || 0;
+                        maskEndIndex = maskStartIndex + nextRest[0].length;
+                        targetElem.setSelectionRange(maskStartIndex, maskEndIndex);
+                    }
+                    else {
+                        targetElem.setSelectionRange(maskStartIndex, maskEndIndex);
+                    }
+                }
+                internalData.isTriggerMasked = true;
+                return;
+            }
+            targetElem.setSelectionRange(maskStartIndex, maskEndIndex);
+            internalData.isTriggerMasked = false;
+        };
+        const handleMaskedSelectedDate = (evnt, isFocus) => {
+            const { type, multiple, modelValue } = props;
+            if (multiple) {
+                return;
+            }
+            if (!maskedTypes.includes(type)) {
+                return;
+            }
+            const targetElem = refInputTarget.value;
+            if (!targetElem) {
+                return;
+            }
+            const { laseFocusMasked } = internalData;
+            if (laseFocusMasked && Date.now() - laseFocusMasked < 100) {
+                return;
+            }
+            const dateMaskedFormat = computeDateMaskedFormat.value;
+            const maskChar = computeMaskChar.value;
+            const selectionStart = targetElem.selectionStart || 0;
+            const selectionEnd = targetElem.selectionEnd || 0;
+            const inpValue = targetElem.value;
+            const allMaskedKeys = XEUtils.map(dateMaskedFormat.match(new RegExp(`(${inputMaskedKeys.join('|')})+`, 'g')) || [], fullKey => fullKey[0]);
+            // 如果为空
+            if (!inpValue) {
+                let restValue = dateMaskedFormat.replace(new RegExp(`(${inputMaskedKeys.join('|')})`, 'g'), maskChar);
+                // 还原值
+                if (isFocus && modelValue) {
+                    const chunkNums = (('' + XEUtils.toNumber(modelValue)).match(/\d/g) || []);
+                    let useNumIndex = 0;
+                    restValue = dateMaskedFormat.replace(new RegExp(`(${inputMaskedKeys.join('|')})`, 'g'), (txt) => chunkNums[useNumIndex++] || txt);
+                }
+                const firstMaskedKeys = allMaskedKeys[0];
+                const firstSkRest = dateMaskedFormat.match(new RegExp(`${firstMaskedKeys}+`));
+                if (firstSkRest) {
+                    evnt.preventDefault();
+                    const firstChunkFormat = firstSkRest[0];
+                    targetElem.value = restValue;
+                    handleInputLabel(restValue, false);
+                    targetElem.setSelectionRange(0, firstChunkFormat.length);
+                    internalData.laseFocusMasked = Date.now();
+                    return;
+                }
+            }
+            // 全选 | 如果无效字符
+            const isAllSelected = !selectionStart && selectionEnd === inpValue.length;
+            const isNotMasked = inpValue && inpValue.length !== dateMaskedFormat.length;
+            if (isAllSelected || isNotMasked) {
+                let restValue = '';
+                // 还原值
+                if (isNotMasked && inpValue) {
+                    const chunkNums = inpValue.match(/\d/g) || [];
+                    let useNumIndex = 0;
+                    restValue = dateMaskedFormat.replace(new RegExp(`(${inputMaskedKeys.join('|')})`, 'g'), () => chunkNums[useNumIndex++] || maskChar);
+                }
+                else {
+                    dateMaskedFormat.replace(new RegExp(`(${inputMaskedKeys.join('|')})`, 'g'), maskChar);
+                }
+                const firstMaskedKeys = allMaskedKeys[0];
+                const firstSkRest = dateMaskedFormat.match(new RegExp(`${firstMaskedKeys}+`));
+                if (firstSkRest) {
+                    evnt.preventDefault();
+                    const firstChunkFormat = firstSkRest[0];
+                    targetElem.value = restValue;
+                    handleInputLabel(restValue, false);
+                    targetElem.setSelectionRange(0, firstChunkFormat.length);
+                    internalData.laseFocusMasked = Date.now();
+                    return;
+                }
+            }
+            // 是否选择数字块
+            let selectKey = dateMaskedFormat[selectionStart];
+            if (!parseInputKayMaps[selectKey]) {
+                selectKey = dateMaskedFormat[selectionStart - 1];
+            }
+            if (selectKey) {
+                evnt.preventDefault();
+                const skRest = dateMaskedFormat.match(new RegExp(selectKey + '+'));
+                if (skRest) {
+                    const chunkFormat = skRest[0] || '';
+                    const chunkStartIndex = skRest.index || 0;
+                    const chunkEndIndex = chunkStartIndex + chunkFormat.length;
+                    targetElem.setSelectionRange(chunkStartIndex, chunkEndIndex);
+                    internalData.isTriggerMasked = true;
+                    internalData.laseFocusMasked = Date.now();
+                }
+            }
+        };
         const blurEvent = (evnt) => {
             const $datePanel = refDatePanel.value;
             const { inputValue } = reactData;
@@ -18004,10 +18497,14 @@ var VxeDatePickerComponent = defineVxeComponent({
                 handleChange(value, evnt);
             }
             if (!reactData.visiblePanel) {
+                const { inputLabel } = internalData;
                 reactData.isActivated = false;
                 // 未打开面板时才校验
                 if ($datePanel) {
-                    $datePanel.checkValue(reactData.inputLabel);
+                    $datePanel.checkValue(inputLabel);
+                }
+                else {
+                    afterCheckValue(inputLabel);
                 }
             }
             dispatchEvent('blur', { value }, evnt);
@@ -18016,7 +18513,81 @@ var VxeDatePickerComponent = defineVxeComponent({
                 $xeForm.triggerItemEvent(evnt, formItemInfo.itemConfig.field, value);
             }
         };
+        const focusEvent = (evnt) => {
+            const { multiple, editable, maskedConfig } = props;
+            const maskedOpts = computeMaskedOpts.value;
+            const popupOpts = computePopupOpts.value;
+            const { trigger } = popupOpts;
+            reactData.isActivated = true;
+            if (!trigger || trigger === 'default') {
+                datePickerOpenEvent(evnt);
+                setTimeout(() => {
+                    if (editable && !multiple && (isEnableConf(maskedConfig) || maskedOpts.enabled)) {
+                        handleMaskedSelectedDate(evnt, true);
+                    }
+                }, 15);
+            }
+            else if (trigger === 'icon') {
+                hidePanel();
+                setTimeout(() => {
+                    if (editable && !multiple && (isEnableConf(maskedConfig) || maskedOpts.enabled)) {
+                        handleMaskedSelectedDate(evnt, true);
+                    }
+                }, 15);
+            }
+            else {
+                if (editable && !multiple && (isEnableConf(maskedConfig) || maskedOpts.enabled)) {
+                    handleMaskedSelectedDate(evnt, true);
+                }
+            }
+            triggerEvent(evnt);
+        };
+        const clickEvent = (evnt) => {
+            const { editable, maskedConfig } = props;
+            const maskedOpts = computeMaskedOpts.value;
+            if (editable && (isEnableConf(maskedConfig) || maskedOpts.enabled)) {
+                handleMaskedSelectedDate(evnt);
+            }
+            triggerEvent(evnt);
+        };
         const keydownEvent = (evnt) => {
+            const { type, editable, maskedConfig } = props;
+            const { visiblePanel } = reactData;
+            const maskedOpts = computeMaskedOpts.value;
+            const isUpArrow = globalEvents.hasKey(evnt, GLOBAL_EVENT_KEYS.ARROW_UP);
+            const isDwArrow = globalEvents.hasKey(evnt, GLOBAL_EVENT_KEYS.ARROW_DOWN);
+            const isLtArrow = globalEvents.hasKey(evnt, GLOBAL_EVENT_KEYS.ARROW_LEFT);
+            const isRtArrow = globalEvents.hasKey(evnt, GLOBAL_EVENT_KEYS.ARROW_RIGHT);
+            const isEnter = globalEvents.hasKey(evnt, GLOBAL_EVENT_KEYS.ENTER);
+            if (editable) {
+                if (isEnter) {
+                    const $datePanel = refDatePanel.value;
+                    const { inputLabel } = internalData;
+                    const targetElem = refInputTarget.value;
+                    if (visiblePanel) {
+                        hidePanel();
+                    }
+                    if ($datePanel) {
+                        $datePanel.checkValue(inputLabel);
+                    }
+                    else {
+                        afterCheckValue(inputLabel);
+                    }
+                    if (targetElem) {
+                        targetElem.blur();
+                    }
+                }
+                else if (maskedTypes.includes(type)) {
+                    if (isEnableConf(maskedConfig) || maskedOpts.enabled) {
+                        if (maskedOpts.isArrow && (isUpArrow || isDwArrow || isLtArrow || isRtArrow)) {
+                            handleArrowInputDate(evnt, isUpArrow, isDwArrow, isLtArrow, isRtArrow);
+                        }
+                        else if (maskedOpts.isMasked) {
+                            handleMaskedInputDate(evnt);
+                        }
+                    }
+                }
+            }
             triggerEvent(evnt);
         };
         const keyupEvent = (evnt) => {
@@ -18044,7 +18615,7 @@ var VxeDatePickerComponent = defineVxeComponent({
             dispatchEvent('confirm', params, params.$event);
         };
         const panelRevertEvent = (params) => {
-            reactData.inputLabel = params.label;
+            handleInputLabel(params.label, true);
         };
         // 全局事件
         const handleGlobalMousedownEvent = (evnt) => {
@@ -18054,25 +18625,34 @@ var VxeDatePickerComponent = defineVxeComponent({
             const panelWrapperElem = refPanelWrapper.value;
             const isDisabled = computeIsDisabled.value;
             if (!isDisabled && isActivated) {
-                reactData.isActivated = getEventTargetNode(evnt, el).flag || getEventTargetNode(evnt, panelWrapperElem).flag;
-                if (!reactData.isActivated) {
+                const currActivated = getEventTargetNode(evnt, el).flag || getEventTargetNode(evnt, panelWrapperElem).flag;
+                if (currActivated !== isActivated) {
+                    reactData.isActivated = currActivated;
+                }
+                if (!currActivated) {
                     if (visiblePanel) {
                         hidePanel();
+                        const { inputLabel } = internalData;
                         if ($datePanel) {
-                            $datePanel.checkValue(reactData.inputLabel);
+                            $datePanel.checkValue(inputLabel);
+                        }
+                        else {
+                            afterCheckValue(inputLabel);
                         }
                     }
                 }
             }
         };
         const handleGlobalKeydownEvent = (evnt) => {
-            const { visiblePanel } = reactData;
+            const { isActivated, visiblePanel } = reactData;
             const isDisabled = computeIsDisabled.value;
             if (!isDisabled) {
                 const isTab = globalEvents.hasKey(evnt, GLOBAL_EVENT_KEYS.TAB);
                 const isEsc = globalEvents.hasKey(evnt, GLOBAL_EVENT_KEYS.ESCAPE);
                 if (isTab) {
-                    reactData.isActivated = false;
+                    if (isActivated) {
+                        reactData.isActivated = false;
+                    }
                 }
                 if (visiblePanel) {
                     if (isEsc || isTab) {
@@ -18107,7 +18687,7 @@ var VxeDatePickerComponent = defineVxeComponent({
             }
             if (visiblePanel || isActivated) {
                 if ($datePanel) {
-                    $datePanel.checkValue(reactData.inputLabel);
+                    $datePanel.checkValue(internalData.inputLabel);
                 }
                 const targetElem = refInputTarget.value;
                 if (targetElem) {
@@ -18137,6 +18717,9 @@ var VxeDatePickerComponent = defineVxeComponent({
             const { panelIndex } = reactData;
             const targetElem = refInputTarget.value;
             const panelElem = refInputPanel.value;
+            if (!panelElem) {
+                return nextTick();
+            }
             const btnTransfer = computeBtnTransfer.value;
             const popupOpts = computePopupOpts.value;
             const handleStyle = () => {
@@ -18184,15 +18767,18 @@ var VxeDatePickerComponent = defineVxeComponent({
             }
         };
         const clickIconEvent = (evnt) => {
+            const { visiblePanel } = reactData;
             const popupOpts = computePopupOpts.value;
             const { trigger } = popupOpts;
             if (!trigger || trigger === 'default' || trigger === 'icon') {
-                datePickerOpenEvent(evnt);
+                if (visiblePanel) {
+                    hidePanel();
+                }
+                else {
+                    datePickerOpenEvent(evnt);
+                }
             }
         };
-        const clickEvent = (evnt) => {
-            triggerEvent(evnt);
-        };
         const handleShortcutEvent = ({ option, $event }) => {
             const { type } = props;
             const { inputValue } = reactData;
@@ -18231,7 +18817,7 @@ var VxeDatePickerComponent = defineVxeComponent({
                             break;
                         }
                         default:
-                            errLog('vxe.error.notCommands', [`[date-picker] ${code}`]);
+                            errLog$e('vxe.error.notCommands', [code]);
                             break;
                     }
                 }
@@ -18302,6 +18888,10 @@ var VxeDatePickerComponent = defineVxeComponent({
             return renderEmptyElement($xeDatePicker);
         };
         const renderPanel = () => {
+            const popupOpts = computePopupOpts.value;
+            if (popupOpts.enabled === false) {
+                return renderEmptyElement($xeDatePicker);
+            }
             const { type, multiple, showClearButton, showConfirmButton } = props;
             const { initialized, isAniVisible, visiblePanel, panelPlacement, panelStyle, inputValue } = reactData;
             const vSize = computeSize.value;
@@ -18311,7 +18901,6 @@ var VxeDatePickerComponent = defineVxeComponent({
             const isDateTimeType = computeIsDateTimeType.value;
             const shortcutList = computeShortcutList.value;
             const timeOpts = computeTimeOpts.value;
-            const popupOpts = computePopupOpts.value;
             const { position } = shortcutOpts;
             const headerSlot = slots.header;
             const footerSlot = slots.footer;
@@ -18513,7 +19102,8 @@ var VxeDatePickerComponent = defineVxeComponent({
         };
         const renderVN = () => {
             const { className, type, name, autoComplete } = props;
-            const { inputValue, inputLabel, visiblePanel, isActivated } = reactData;
+            const { inputValue, visiblePanel, isActivated, labelFlag } = reactData;
+            const { inputLabel } = internalData;
             const vSize = computeSize.value;
             const isDisabled = computeIsDisabled.value;
             const formReadonly = computeFormReadonly.value;
@@ -18549,7 +19139,7 @@ var VxeDatePickerComponent = defineVxeComponent({
                     h('input', {
                         ref: refInputTarget,
                         class: 'vxe-date-picker--inner',
-                        value: inputLabel,
+                        value: labelFlag ? inputLabel : '',
                         name,
                         type: 'text',
                         placeholder: inpPlaceholder,
@@ -18571,7 +19161,7 @@ var VxeDatePickerComponent = defineVxeComponent({
             ]);
         };
         watch(computePanelLabel, (val) => {
-            reactData.inputLabel = val;
+            handleInputLabel(val, true);
         });
         watch(() => props.modelValue, () => {
             updateModelValue();
@@ -18583,6 +19173,17 @@ var VxeDatePickerComponent = defineVxeComponent({
             globalEvents.on($xeDatePicker, 'blur', handleGlobalBlurEvent);
             globalEvents.on($xeDatePicker, 'resize', handleGlobalResizeEvent);
         });
+        onMounted(() => {
+            const { type, multiple, maskedConfig } = props;
+            if (isEnableConf(maskedConfig)) {
+                if (multiple) {
+                    errLog$e('vxe.error.notSupportProp', ['multiple', 'control-config.enabled=true', 'control-config.enabled=false']);
+                }
+                if (!maskedTypes.includes(type)) {
+                    warnLog$8('vxe.error.notSupportProp', ['control-config.enabled=true', `type=${type}`, `type=${maskedTypes.join('|')}`]);
+                }
+            }
+        });
         onUnmounted(() => {
             globalEvents.off($xeDatePicker, 'mousewheel');
             globalEvents.off($xeDatePicker, 'mousedown');
@@ -18608,6 +19209,7 @@ dynamicApp.use(VxeDatePicker);
 VxeUI.component(VxeDatePickerComponent);
 const DatePicker = VxeDatePicker;
 
+const { errLog: errLog$d } = createComponentLog('date-range-picker');
 var VxeDateRangePickerComponent = defineVxeComponent({
     name: 'VxeDateRangePicker',
     props: {
@@ -19058,6 +19660,9 @@ var VxeDateRangePickerComponent = defineVxeComponent({
             if (!trigger || trigger === 'default') {
                 dateRangePickerOpenEvent(evnt);
             }
+            else if (trigger === 'icon') {
+                hidePanel();
+            }
             triggerEvent(evnt);
         };
         const clickPrefixEvent = (evnt) => {
@@ -19369,6 +19974,9 @@ var VxeDateRangePickerComponent = defineVxeComponent({
             const { panelIndex } = reactData;
             const targetElem = refInputTarget.value;
             const panelElem = refInputPanel.value;
+            if (!panelElem) {
+                return nextTick();
+            }
             const btnTransfer = computeBtnTransfer.value;
             const popupOpts = computePopupOpts.value;
             const handleStyle = () => {
@@ -19417,10 +20025,16 @@ var VxeDateRangePickerComponent = defineVxeComponent({
             }
         };
         const clickIconEvent = (evnt) => {
+            const { visiblePanel } = reactData;
             const popupOpts = computePopupOpts.value;
             const { trigger } = popupOpts;
             if (!trigger || trigger === 'default' || trigger === 'icon') {
-                dateRangePickerOpenEvent(evnt);
+                if (visiblePanel) {
+                    hidePanel();
+                }
+                else {
+                    dateRangePickerOpenEvent(evnt);
+                }
             }
         };
         const clickEvent = (evnt) => {
@@ -19473,7 +20087,7 @@ var VxeDateRangePickerComponent = defineVxeComponent({
                             break;
                         }
                         default:
-                            errLog('vxe.error.notCommands', [`[date-range-picker] ${code}`]);
+                            errLog$d('vxe.error.notCommands', [code]);
                             break;
                     }
                 }
@@ -19546,6 +20160,10 @@ var VxeDateRangePickerComponent = defineVxeComponent({
             return renderEmptyElement($xeDateRangePicker);
         };
         const renderPanel = () => {
+            const popupOpts = computePopupOpts.value;
+            if (popupOpts.enabled === false) {
+                return renderEmptyElement($xeDateRangePicker);
+            }
             const { type, separator, autoClose, showConfirmButton, showClearButton } = props;
             const { initialized, isAniVisible, visiblePanel, panelPlacement, panelStyle, startValue, endValue } = reactData;
             const vSize = computeSize.value;
@@ -19558,7 +20176,6 @@ var VxeDateRangePickerComponent = defineVxeComponent({
             const defaultDates = computeDefaultDates.value;
             const defaultTimes = computeDefaultTimes.value;
             const timeOpts = computeTimeOpts.value;
-            const popupOpts = computePopupOpts.value;
             const { startLabel, endLabel } = panelLabelObj;
             const { position } = shortcutOpts;
             const headerSlot = slots.header;
@@ -19998,6 +20615,7 @@ var VxeDrawerComponent = defineVxeComponent({
             type: Boolean,
             default: () => getConfig$3().drawer.showTitleOverflow
         },
+        preload: Boolean,
         width: [Number, String],
         height: [Number, String],
         resize: {
@@ -20504,6 +21122,7 @@ var VxeDrawerComponent = defineVxeComponent({
             }
         });
         onMounted(() => {
+            reactData.initialized = !!props.preload;
             nextTick(() => {
                 if (props.modelValue) {
                     openDrawer();
@@ -20673,6 +21292,7 @@ dynamicApp.use(VxeEmpty);
 VxeUI.component(VxeEmptyComponent);
 const Empty = VxeEmpty;
 
+const { errLog: errLog$c } = createComponentLog('form');
 class ItemInfo {
     constructor($xeForm, item) {
         const { field, itemRender, formatter } = item;
@@ -20680,22 +21300,22 @@ class ItemInfo {
             if (XEUtils.isString(formatter)) {
                 const gFormatOpts = formats.get(formatter);
                 if (!gFormatOpts || !gFormatOpts.formItemFormatMethod) {
-                    errLog('vxe.error.notFormats', [`[form] ${formatter}`]);
+                    errLog$c('vxe.error.notFormats', [formatter]);
                 }
             }
             else if (XEUtils.isArray(formatter)) {
                 const gFormatOpts = formats.get(formatter[0]);
                 if (!gFormatOpts || !gFormatOpts.formItemFormatMethod) {
-                    errLog('vxe.error.notFormats', [`[form] ${formatter[0]}`]);
+                    errLog$c('vxe.error.notFormats', [formatter[0]]);
                 }
             }
         }
         if (field && itemRender) {
             if (itemRender.startField && `${itemRender.startField}`.indexOf(field) >= 0) {
-                errLog('vxe.error.modelConflicts', [`[form] field=${field}`, `item-render.startField=${itemRender.startField}`]);
+                errLog$c('vxe.error.modelConflicts', [`field=${field}`, `item-render.startField=${itemRender.startField}`]);
             }
             if (itemRender.endField && `${itemRender.endField}`.indexOf(field) >= 0) {
-                errLog('vxe.error.modelConflicts', [`[form] field=${field}`, `item-render.endField=${itemRender.endField}`]);
+                errLog$c('vxe.error.modelConflicts', [`field=${field}`, `item-render.endField=${itemRender.endField}`]);
             }
         }
         Object.assign(this, {
@@ -21419,6 +22039,7 @@ const VxeFormConfigItem = defineVxeComponent({
     }
 });
 
+const { errLog: errLog$b } = createComponentLog('form');
 const componentDefaultModelProp = 'modelValue';
 /**
  * 已废弃
@@ -21505,7 +22126,7 @@ function getComponentOns(renderOpts, params, eFns, eventOns) {
     XEUtils.objectEach(events, (func, key) => {
         ons[getOnName(key)] = function (...args) {
             if (!XEUtils.isFunction(func)) {
-                errLog('vxe.error.errFunc', [`[form] ${func}`]);
+                errLog$b('vxe.error.errFunc', [func]);
             }
             func(params, ...args);
         };
@@ -21932,6 +22553,7 @@ renderer.mixin({
     // 以上已废弃
 });
 
+const { warnLog: warnLog$7, errLog: errLog$a } = createComponentLog('form');
 class Rule {
     constructor(rule) {
         Object.assign(this, {
@@ -22052,7 +22674,7 @@ function checkRuleStatus(rule, data, val) {
     }
     return true;
 }
-function createReactData$6() {
+function createReactData$9() {
     return {
         collapseAll: false,
         staticItems: [],
@@ -22169,7 +22791,7 @@ var VxeFormComponent = defineVxeComponent({
         const $xeGrid = inject('$xeGrid', null);
         const xID = XEUtils.uniqueId();
         const { computeSize } = useSize(props);
-        const reactData = reactive(createReactData$6());
+        const reactData = reactive(createReactData$9());
         const internalData = createInternalData$8();
         const refElem = ref();
         const refTooltip = ref();
@@ -22240,7 +22862,7 @@ var VxeFormComponent = defineVxeComponent({
                         XEUtils.each(item.slots, (func) => {
                             if (!XEUtils.isFunction(func)) {
                                 if (!slots[func]) {
-                                    errLog('vxe.error.notSlot', [`[form] ${func}`]);
+                                    errLog$a('vxe.error.notSlot', [func]);
                                 }
                             }
                         });
@@ -22463,11 +23085,11 @@ var VxeFormComponent = defineVxeComponent({
                                                 customValid = validatorMethod(validParams);
                                             }
                                             else {
-                                                warnLog('vxe.error.notValidators', [`[form] ${validator}`]);
+                                                warnLog$7('vxe.error.notValidators', [validator]);
                                             }
                                         }
                                         else {
-                                            errLog('vxe.error.notValidators', [`[form] ${validator}`]);
+                                            errLog$a('vxe.error.notValidators', [validator]);
                                         }
                                     }
                                     else {
@@ -22857,7 +23479,7 @@ var VxeFormComponent = defineVxeComponent({
         onMounted(() => {
             nextTick(() => {
                 if (props.customLayout && props.items) {
-                    errLog('vxe.error.errConflicts', ['[form] custom-layout', 'items']);
+                    errLog$a('vxe.error.errConflicts', ['custom-layout', 'items']);
                 }
             });
             globalEvents.on($xeForm, 'resize', handleGlobalResizeEvent);
@@ -24274,7 +24896,7 @@ function createInternalData$7() {
     // mdTime: 0
     };
 }
-function createReactData$5() {
+function createReactData$8() {
     return {};
 }
 var VxeImageComponent = defineVxeComponent({
@@ -24334,7 +24956,7 @@ var VxeImageComponent = defineVxeComponent({
         const refElem = ref();
         const { computeSize } = useSize(props);
         const internalData = createInternalData$7();
-        const reactData = reactive(createReactData$5());
+        const reactData = reactive(createReactData$8());
         const refMaps = {
             refElem
         };
@@ -24520,7 +25142,7 @@ var VxeImageComponent = defineVxeComponent({
             ]);
         };
         onBeforeUnmount(() => {
-            XEUtils.assign(reactData, createReactData$5());
+            XEUtils.assign(reactData, createReactData$8());
             XEUtils.assign(internalData, createInternalData$7());
         });
         $xeImage.renderVN = renderVN;
@@ -24813,7 +25435,7 @@ const LayoutAside = VxeLayoutAside;
 function createInternalData$6() {
     return {};
 }
-function createReactData$4() {
+function createReactData$7() {
     return {};
 }
 var VxeLayoutBodyComponent = defineVxeComponent({
@@ -24839,7 +25461,7 @@ var VxeLayoutBodyComponent = defineVxeComponent({
         const refElem = ref();
         const { computeSize } = useSize(props);
         const internalData = createInternalData$6();
-        const reactData = reactive(createReactData$4());
+        const reactData = reactive(createReactData$7());
         const refMaps = {
             refElem
         };
@@ -25263,6 +25885,7 @@ dynamicApp.use(VxeList);
 VxeUI.component(VxeListComponent);
 const List = VxeList;
 
+const { errLog: errLog$9 } = createComponentLog('menu');
 const { menus: menus$1, getConfig: getConfig$1, getIcon: getIcon$1 } = VxeUI;
 var VxeMenuComponent = defineVxeComponent({
     name: 'VxeMenu',
@@ -25749,7 +26372,7 @@ var VxeMenuComponent = defineVxeComponent({
             const { menuConfig } = props;
             const VxeUIContextMenu = VxeUI.getComponent('VxeContextMenu');
             if (menuConfig && !VxeUIContextMenu) {
-                errLog('vxe.error.reqComp', ['vxe-context-menu']);
+                errLog$9('vxe.error.reqComp', ['vxe-context-menu']);
             }
             globalEvents.on($xeMenu, 'resize', updateCollapseStyle);
             updateCollapseStyle();
@@ -25783,6 +26406,7 @@ dynamicApp.use(VxeMenu);
 VxeUI.component(VxeMenuComponent);
 const Menu = VxeMenu;
 
+const { warnLog: warnLog$6, errLog: errLog$8 } = createComponentLog('modal');
 const allActiveModals = [];
 const msgQueue = [];
 const notifyQueue = [];
@@ -25869,6 +26493,7 @@ var VxeModalComponent = defineVxeComponent({
             type: Boolean,
             default: () => getConfig$3().modal.showFooter
         },
+        preload: Boolean,
         showZoom: Boolean,
         zoomConfig: Object,
         showMaximize: {
@@ -27168,11 +27793,12 @@ var VxeModalComponent = defineVxeComponent({
         });
         onMounted(() => {
             if (props.type === 'modal' && props.showFooter && !(props.showConfirmButton || props.showCancelButton || slots.footer)) {
-                warnLog('vxe.modal.footPropErr');
+                warnLog$6('vxe.modal.footPropErr');
             }
+            reactData.initialized = !!props.preload;
             nextTick(() => {
                 if (props.storage && !props.id) {
-                    errLog('vxe.error.reqProp', ['[modal] id']);
+                    errLog$8('vxe.error.reqProp', ['id']);
                 }
                 if (props.modelValue) {
                     openModal();
@@ -27624,12 +28250,34 @@ dynamicApp.use(VxeOption);
 VxeUI.component(VxeOptionComponent);
 const Option = VxeOption;
 
+const { errLog: errLog$7 } = createComponentLog('select');
 function isOptionVisible(option) {
     return option.visible !== false;
 }
 function getOptUniqueId$1() {
     return XEUtils.uniqueId('opt_');
 }
+function createReactData$6() {
+    return {
+        initialized: false,
+        scrollYLoad: false,
+        bodyHeight: 0,
+        topSpaceHeight: 0,
+        optList: [],
+        staticOptions: [],
+        reactFlag: 0,
+        currentOption: null,
+        searchValue: '',
+        searchLoading: false,
+        panelIndex: 0,
+        panelStyle: {},
+        panelPlacement: null,
+        triggerFocusPanel: false,
+        visiblePanel: false,
+        isAniVisible: false,
+        isActivated: false
+    };
+}
 function createInternalData$5() {
     return {
         // isLoaded: false,
@@ -27805,25 +28453,7 @@ var VxeSelectComponent = defineVxeComponent({
         const refOptionPanel = ref();
         const refVirtualBody = ref();
         const { computeSize } = useSize(props);
-        const reactData = reactive({
-            initialized: false,
-            scrollYLoad: false,
-            bodyHeight: 0,
-            topSpaceHeight: 0,
-            optList: [],
-            staticOptions: [],
-            reactFlag: 0,
-            currentOption: null,
-            searchValue: '',
-            searchLoading: false,
-            panelIndex: 0,
-            panelStyle: {},
-            panelPlacement: null,
-            triggerFocusPanel: false,
-            visiblePanel: false,
-            isAniVisible: false,
-            isActivated: false
-        });
+        const reactData = reactive(createReactData$6());
         const internalData = createInternalData$5();
         const refMaps = {
             refElem
@@ -28855,7 +29485,7 @@ var VxeSelectComponent = defineVxeComponent({
                             });
                         }
                         else {
-                            errLog('vxe.error.notConflictProp', ['default-config.selectMode=all', 'multiple=true']);
+                            errLog$7('vxe.error.notConflictProp', ['default-config.selectMode=all', 'multiple=true']);
                         }
                     }
                     else if (selectMode === 'first' || selectMode === 'last') {
@@ -29345,6 +29975,7 @@ var VxeSelectComponent = defineVxeComponent({
             globalEvents.off($xeSelect, 'keydown');
             globalEvents.off($xeSelect, 'blur');
             globalEvents.off($xeSelect, 'resize');
+            XEUtils.assign(reactData, createReactData$6());
             XEUtils.assign(internalData, createInternalData$5());
         });
         provide('$xeSelect', $xeSelect);
@@ -29356,6 +29987,7 @@ var VxeSelectComponent = defineVxeComponent({
     }
 });
 
+const { warnLog: warnLog$5, errLog: errLog$6 } = createComponentLog('pager');
 var VxePagerComponent = defineVxeComponent({
     name: 'VxePager',
     props: {
@@ -29957,7 +30589,7 @@ var VxePagerComponent = defineVxeComponent({
              * @deprecated
              */
             jumpPage(currentPage) {
-                warnLog('vxe.error.delFunc', ['[pager] jumpPage', 'setCurrentPage']);
+                warnLog$5('vxe.error.delFunc', ['jumpPage', 'setCurrentPage']);
                 return $xePager.setCurrentPage(currentPage);
             }
         };
@@ -30028,7 +30660,7 @@ var VxePagerComponent = defineVxeComponent({
                     childNodes.push(renderFn());
                 }
                 else {
-                    errLog('vxe.error.notProp', [`[pager] layouts -> ${name}`]);
+                    errLog$6('vxe.error.notProp', [`layouts -> ${name}`]);
                 }
             });
             if (slots.right) {
@@ -30554,7 +31186,7 @@ function handlePrint(opts, printHtml = '') {
     if (styleUrls && styleUrls.length) {
         styleUrls.forEach(url => {
             if (!/.css$/.test(url)) {
-                warnLog('vxe.error.errProp', [url, `${url}.css`]);
+                warnLog$b('vxe.error.errProp', [url, `${url}.css`]);
             }
         });
     }
@@ -31783,6 +32415,9 @@ dynamicApp.use(VxeRadioButton);
 VxeUI.component(VxeRadioButtonComponent);
 const RadioButton = VxeRadioButton;
 
+function createReactData$5() {
+    return {};
+}
 function createInternalData$4() {
     return {
     // isLoaded: false
@@ -31824,7 +32459,7 @@ var VxeRadioGroupComponent = defineVxeComponent({
         const formItemInfo = inject('xeFormItemInfo', null);
         const xID = XEUtils.uniqueId();
         const { computeSize } = useSize(props);
-        const reactData = reactive({});
+        const reactData = reactive(createReactData$5());
         const internalData = createInternalData$4();
         const computeIsReadonly = computed(() => {
             const { readonly } = props;
@@ -31961,6 +32596,7 @@ var VxeRadioGroupComponent = defineVxeComponent({
             });
         });
         onUnmounted(() => {
+            XEUtils.assign(reactData, createReactData$5());
             XEUtils.assign(internalData, createInternalData$4());
         });
         provide('$xeRadioGroup', $xeRadioGroup);
@@ -32346,7 +32982,7 @@ dynamicApp.use(VxeRow);
 VxeUI.component(VxeRowComponent);
 const Row = VxeRow;
 
-function createReactData$3() {
+function createReactData$4() {
     return {
         groupName: XEUtils.uniqueId('xe_group_'),
         selectStyle: {
@@ -32387,7 +33023,7 @@ var VxeSegmentedComponent = defineVxeComponent({
         const refElem = ref();
         const refWrapperElem = ref();
         const refSelectedElem = ref();
-        const reactData = reactive(createReactData$3());
+        const reactData = reactive(createReactData$4());
         const refMaps = {
             refElem
         };
@@ -32560,7 +33196,7 @@ var VxeSegmentedComponent = defineVxeComponent({
             updateStyle();
         });
         onBeforeUnmount(() => {
-            XEUtils.assign(reactData, createReactData$3());
+            XEUtils.assign(reactData, createReactData$4());
         });
         $xeSegmented.renderVN = renderVN;
         return $xeSegmented;
@@ -32588,6 +33224,7 @@ dynamicApp.use(VxeSelect);
 VxeUI.component(VxeSelectComponent);
 const Select = VxeSelect;
 
+const { warnLog: warnLog$4, errLog: errLog$5 } = createComponentLog('splitter');
 var VxeSplitComponent = defineVxeComponent({
     name: 'VxeSplitter',
     props: {
@@ -32638,7 +33275,8 @@ var VxeSplitComponent = defineVxeComponent({
             staticItems: [],
             itemList: [],
             barWidth: 0,
-            barHeight: 0
+            barHeight: 0,
+            resizeFlag: 0
         });
         const internalData = {
             wrapperWidth: 0,
@@ -32786,13 +33424,13 @@ var VxeSplitComponent = defineVxeComponent({
             };
             reactData.itemList = list.map(item => {
                 if (item.showAction) {
-                    warnLog('vxe.error.removeProp', ['[splitter] show-action']);
+                    warnLog$4('vxe.error.removeProp', ['show-action']);
                 }
                 if (item.slots) {
                     XEUtils.each(item.slots, (func) => {
                         if (!XEUtils.isFunction(func)) {
                             if (!slots[func]) {
-                                errLog('vxe.error.notSlot', [`[splitter] ${func}`]);
+                                errLog$5('vxe.error.notSlot', [func]);
                             }
                         }
                     });
@@ -32802,10 +33440,10 @@ var VxeSplitComponent = defineVxeComponent({
                 });
             });
             if (staticItems.length) {
-                errLog('vxe.error.errConflicts', ['<vxe-splitter-panel ...>', 'items']);
+                errLog$5('vxe.error.errConflicts', ['<vxe-splitter-panel ...>', 'items']);
             }
             if ((showPrevButton || showNextButton) && reactData.itemList.length > 2) {
-                errLog('vxe.error.errConflicts', ['action-config.showPrevButton | action-config.showNextButton', 'Only supports 2 item']);
+                errLog$5('vxe.error.errConflicts', ['action-config.showPrevButton | action-config.showNextButton', 'Only supports 2 item']);
             }
             return recalculate();
         };
@@ -33141,6 +33779,7 @@ var VxeSplitComponent = defineVxeComponent({
             document.onmousemove = (evnt) => {
                 evnt.preventDefault();
                 handleDrag(evnt);
+                reactData.resizeFlag++;
             };
             document.onmouseup = (evnt) => {
                 document.onmousemove = null;
@@ -33152,6 +33791,7 @@ var VxeSplitComponent = defineVxeComponent({
                 removeClass(el, 'is--drag');
                 dispatchEvent('resize-end', { prevItem, nextItem, offsetHeight: targetOffsetHeight, offsetWidth: targetOffsetWidth }, evnt);
                 recalculate();
+                reactData.resizeFlag++;
             };
             if (rsSplitterLineEl) {
                 rsSplitterLineEl.style.display = 'block';
@@ -33206,6 +33846,7 @@ var VxeSplitComponent = defineVxeComponent({
                 dispatchEvent('toggle-expand', { prevItem, nextItem, expanded, item }, evnt);
             }
             recalculate();
+            reactData.resizeFlag++;
         };
         const handlePrevActionDblclickEvent = (evnt) => {
             const { itemList } = reactData;
@@ -33488,15 +34129,15 @@ var VxeSplitComponent = defineVxeComponent({
             const actionOpts = computeActionOpts.value;
             const { showPrevButton, showNextButton } = actionOpts;
             if (props.items && props.items.length) {
-                errLog('vxe.error.errConflicts', ['<vxe-splitter-panel ...>', 'items']);
+                errLog$5('vxe.error.errConflicts', ['<vxe-splitter-panel ...>', 'items']);
             }
             reactData.itemList = val || [];
             if ((showPrevButton || showNextButton) && reactData.itemList.length > 2) {
-                errLog('vxe.error.modelConflicts', ['[splitter] action-config.showPrevButton | action-config.showNextButton', '<vxe-splitter-panel ...> Only supports 2 panel']);
+                errLog$5('vxe.error.modelConflicts', ['action-config.showPrevButton | action-config.showNextButton', '<vxe-splitter-panel ...> Only supports 2 panel']);
             }
             reactData.itemList.forEach(item => {
                 if (item.showAction) {
-                    warnLog('vxe.error.removeProp', ['[splitter] showAction']);
+                    warnLog$4('vxe.error.removeProp', ['showAction']);
                 }
             });
             recalculate();
@@ -33515,7 +34156,7 @@ var VxeSplitComponent = defineVxeComponent({
             }
             const actionOpts = computeActionOpts.value;
             if (actionOpts.direction) {
-                errLog('vxe.error.delProp', ['[splitter] action-config.direction', 'action-config.showPrevButton | action-config.showNextButton']);
+                errLog$5('vxe.error.delProp', ['action-config.direction', 'action-config.showPrevButton | action-config.showNextButton']);
             }
             globalEvents.on($xeSplitter, 'resize', handleGlobalResizeEvent);
         });
@@ -34362,9 +35003,24 @@ dynamicApp.use(VxeTabPane);
 VxeUI.component(VxeTabPaneComponent);
 const TabPane = VxeTabPane;
 
+const { errLog: errLog$4 } = createComponentLog('table-select');
 function getRowUniqueId() {
     return XEUtils.uniqueId('row_');
 }
+function createReactData$3() {
+    return {
+        initialized: false,
+        tableColumns: [],
+        fullOptionList: [],
+        panelIndex: 0,
+        panelStyle: {},
+        panelPlacement: null,
+        triggerFocusPanel: false,
+        visiblePanel: false,
+        isAniVisible: false,
+        isActivated: false
+    };
+}
 function createInternalData$3() {
     return {
         // hpTimeout: undefined,
@@ -34444,18 +35100,7 @@ var VxeTableSelectComponent = defineVxeComponent({
         const refGridWrapper = ref();
         const refOptionPanel = ref();
         const refGrid = ref();
-        const reactData = reactive({
-            initialized: false,
-            tableColumns: [],
-            fullOptionList: [],
-            panelIndex: 0,
-            panelStyle: {},
-            panelPlacement: null,
-            triggerFocusPanel: false,
-            visiblePanel: false,
-            isAniVisible: false,
-            isActivated: false
-        });
+        const reactData = reactive(createReactData$3());
         const internalData = createInternalData$3();
         const refMaps = {
             refElem
@@ -34710,12 +35355,12 @@ var VxeTableSelectComponent = defineVxeComponent({
                         rowid = getRowUniqueId();
                     }
                     if (keyMaps[rowid]) {
-                        errLog('vxe.error.repeatKey', [`[table-select] ${rowKeyField}`, rowid]);
+                        errLog$4('vxe.error.repeatKey', [rowKeyField, rowid]);
                     }
                     keyMaps[rowid] = true;
                     const value = item[valueField];
                     if (rowMaps[value]) {
-                        errLog('vxe.error.repeatKey', [`[table-select] ${valueField}`, value]);
+                        errLog$4('vxe.error.repeatKey', [valueField, value]);
                     }
                     rowMaps[value] = { item, index, items, parent: null, nodes: [] };
                 });
@@ -35059,11 +35704,12 @@ var VxeTableSelectComponent = defineVxeComponent({
             globalEvents.off($xeTableSelect, 'mousedown');
             globalEvents.off($xeTableSelect, 'blur');
             globalEvents.off($xeTableSelect, 'resize');
+            XEUtils.assign(reactData, createReactData$3());
             XEUtils.assign(internalData, createInternalData$3());
         });
         nextTick(() => {
             if (!VxeTableGridComponent) {
-                errLog('vxe.error.reqComp', ['[table-select] vxe-grid']);
+                errLog$4('vxe.error.reqComp', ['vxe-grid']);
             }
         });
         provide('$xeTableSelect', $xeTableSelect);
@@ -35084,6 +35730,7 @@ dynamicApp.use(VxeTableSelect);
 VxeUI.component(VxeTableSelectComponent);
 const TableSelect = VxeTableSelect;
 
+const { warnLog: warnLog$3, errLog: errLog$3 } = createComponentLog('tabs');
 const scrollbarOffsetSize = 20;
 var VxeTabsComponent = defineVxeComponent({
     name: 'VxeTabs',
@@ -35439,7 +36086,7 @@ var VxeTabsComponent = defineVxeComponent({
                     });
                 }
                 else {
-                    errLog('vxe.error.notFunc', ['refresh-config.queryMethod']);
+                    errLog$3('vxe.error.notFunc', ['refresh-config.queryMethod']);
                 }
             }
         };
@@ -35620,11 +36267,11 @@ var VxeTabsComponent = defineVxeComponent({
                 return handlePrevNext(true);
             },
             prevTab() {
-                warnLog('vxe.error.delFunc', ['[tabs] prevTab', 'prev']);
+                warnLog$3('vxe.error.delFunc', ['prevTab', 'prev']);
                 return tabsMethods.prev();
             },
             nextTab() {
-                warnLog('vxe.error.delFunc', ['[tabs] nextTab', 'next']);
+                warnLog$3('vxe.error.delFunc', ['nextTab', 'next']);
                 return tabsMethods.next();
             }
         };
@@ -36392,6 +37039,7 @@ dynamicApp.use(VxeText);
 VxeUI.component(VxeTextComponent);
 const Text = VxeText;
 
+const { warnLog: warnLog$2 } = createComponentLog('textarea');
 let autoTxtElem;
 var VxeTextareaComponent = defineVxeComponent({
     name: 'VxeTextarea',
@@ -36756,7 +37404,7 @@ var VxeTextareaComponent = defineVxeComponent({
         nextTick(() => {
             const { autosize, autoSize } = props;
             if (autosize) {
-                warnLog('vxe.error.delProp', ['autosize', 'auto-size']);
+                warnLog$2('vxe.error.delProp', ['autosize', 'auto-size']);
             }
             if (autosize || autoSize) {
                 updateAutoTxt();
@@ -37128,6 +37776,7 @@ function clearRowAnimate(elem, clss) {
     }, 500);
 }
 
+const { errLog: errLog$2 } = createComponentLog('tree');
 const { menus, getConfig, getI18n, getIcon } = VxeUI;
 /**
  * 生成节点的唯一主键
@@ -37837,7 +38486,7 @@ var VxeTreeComponent = defineVxeComponent({
             handleData(true);
             if (sYLoad) {
                 if (!(props.height || props.maxHeight)) {
-                    errLog('vxe.error.reqProp', ['[tree] height | max-height | virtual-y-config.enabled=false']);
+                    errLog$2('vxe.error.reqProp', ['height | max-height | virtual-y-config.enabled=false']);
                 }
             }
             return computeScrollLoad().then(() => {
@@ -39773,17 +40422,17 @@ var VxeTreeComponent = defineVxeComponent({
             const { transform, drag, menuConfig } = props;
             const dragOpts = computeDragOpts.value;
             if (drag && !transform) {
-                errLog('vxe.error.notSupportProp', ['drag', 'transform=false', 'transform=true']);
+                errLog$2('vxe.error.notSupportProp', ['drag', 'transform=false', 'transform=true']);
             }
             if (dragOpts.isCrossTreeDrag) {
-                errLog('vxe.error.notProp', ['drag-config.isCrossTreeDrag']);
+                errLog$2('vxe.error.notProp', ['drag-config.isCrossTreeDrag']);
             }
             // if (valueField) {
             //   errLog('vxe.error.delProp', ['value-field', 'value-field'])
             // }
             const VxeUIContextMenu = VxeUI.getComponent('VxeContextMenu');
             if (menuConfig && !VxeUIContextMenu) {
-                errLog('vxe.error.reqComp', ['vxe-context-menu']);
+                errLog$2('vxe.error.reqComp', ['vxe-context-menu']);
             }
             if (props.autoResize) {
                 const el = refElem.value;
@@ -39832,6 +40481,7 @@ dynamicApp.use(VxeTree);
 VxeUI.component(VxeTreeComponent);
 const Tree = VxeTree;
 
+const { warnLog: warnLog$1, errLog: errLog$1 } = createComponentLog('tree-select');
 function getOptUniqueId() {
     return XEUtils.uniqueId('node_');
 }
@@ -40197,12 +40847,12 @@ var VxeTreeSelectComponent = defineVxeComponent({
                     nodeid = getOptUniqueId();
                 }
                 if (keyMaps[nodeid]) {
-                    errLog('vxe.error.repeatKey', [nodeKeyField, nodeid]);
+                    errLog$1('vxe.error.repeatKey', [nodeKeyField, nodeid]);
                 }
                 keyMaps[nodeid] = true;
                 const value = item[valueField];
                 if (nodeMaps[value]) {
-                    errLog('vxe.error.repeatKey', [valueField, value]);
+                    errLog$1('vxe.error.repeatKey', [valueField, value]);
                 }
                 nodeMaps[value] = {
                     item,
@@ -40799,7 +41449,7 @@ var VxeTreeSelectComponent = defineVxeComponent({
         cacheLazyDataMap();
         onMounted(() => {
             if (XEUtils.isBoolean(props.autoClose)) {
-                warnLog('vxe.error.delProp', ['auto-close', 'checked-closable | clear-closable']);
+                warnLog$1('vxe.error.delProp', ['auto-close', 'checked-closable | clear-closable']);
             }
             globalEvents.on($xeTreeSelect, 'mousewheel', handleGlobalMousewheelEvent);
             globalEvents.on($xeTreeSelect, 'mousedown', handleGlobalMousedownEvent);
@@ -40934,6 +41584,7 @@ const saveLocalFile = (options) => {
     return Promise.reject(new Error(getI18n$2('vxe.error.notExp')));
 };
 
+const { warnLog, errLog } = createComponentLog('upload');
 function createReactData() {
     return {
         isDragUploadStatus: false,
@@ -41141,8 +41792,12 @@ var VxeUploadComponent = defineVxeComponent({
         'remove-fail',
         'download',
         'download-fail',
+        'upload-start',
         'upload-success',
         'upload-error',
+        'upload-end',
+        'upload-queue-start',
+        'upload-queue-end',
         'sort-dragend',
         'more-visible'
     ],
@@ -41476,6 +42131,7 @@ var VxeUploadComponent = defineVxeComponent({
             const fileKey = getFieldKey(item);
             const uploadFn = props.uploadMethod || getConfig$3().upload.uploadMethod;
             if (uploadFn) {
+                dispatchEvent('upload-start', { option: item }, null);
                 return Promise.resolve(uploadFn({
                     $upload: $xeUpload,
                     file,
@@ -41516,6 +42172,7 @@ var VxeUploadComponent = defineVxeComponent({
                     if (cacheItem) {
                         cacheItem.loading = false;
                     }
+                    dispatchEvent('upload-end', { option: item }, null);
                 });
             }
             else {
@@ -41624,6 +42281,7 @@ var VxeUploadComponent = defineVxeComponent({
                     }
                 }
             }
+            dispatchEvent('upload-queue-start', { files: selectFiles }, evnt);
             const cacheMaps = Object.assign({}, reactData.fileCacheMaps);
             const newFileList = multiple ? fileList : [];
             const uploadPromiseRests = [];
@@ -41660,6 +42318,7 @@ var VxeUploadComponent = defineVxeComponent({
             });
             Promise.all(urlMode ? uploadPromiseRests : []).then(() => {
                 const restFileList = reactData.fileList;
+                dispatchEvent('upload-queue-end', { options: restFileList, files: selectFiles }, evnt);
                 handleChange(restFileList);
                 // 自动更新校验状态
                 if ($xeForm && formItemInfo) {
@@ -42721,10 +43380,10 @@ var VxeUploadComponent = defineVxeComponent({
         });
         onMounted(() => {
             if (props.multiple && props.singleMode) {
-                errLog('vxe.error.errConflicts', ['[upload] multiple', 'single-mode']);
+                errLog('vxe.error.errConflicts', ['multiple', 'single-mode']);
             }
             if (props.imageStyle) {
-                warnLog('vxe.error.delProp', ['[upload] image-style', 'image-config']);
+                warnLog('vxe.error.delProp', ['image-style', 'image-config']);
             }
             if (props.dragSort) {
                 initTpImg();