vxe-pc-ui 4.15.2 → 4.15.3

package/lib/index.umd.js

@@ -4646,7 +4646,13 @@ function checkDynamic() {
 }
 ;// ./packages/ui/src/log.ts
 
-const log_version = `ui v${"4.15.2"}`;
+const log_version = `ui v${"4.15.3"}`;
+function createComponentLog(name) {
+  return {
+    warnLog: log.create('warn', `${log_version} ${name}`),
+    errLog: log.create('error', `${log_version} ${name}`)
+  };
+}
 const warnLog = log.create('warn', log_version);
 const errLog = log.create('error', log_version);
 ;// ./packages/ui/index.ts
@@ -4654,7 +4660,7 @@ const errLog = log.create('error', log_version);
 
 
 
-const ui_version = "4.15.2";
+const ui_version = "4.15.3";
 VxeUI.uiVersion = ui_version;
 VxeUI.dynamicApp = dynamicApp;
 function config(options) {
@@ -7818,6 +7824,9 @@ const Tooltip = VxeTooltip;
 
 
 
+const {
+  warnLog: button_warnLog
+} = createComponentLog('button');
 const VxeButtonComponent = defineVxeComponent({
   name: 'VxeButton',
   props: {
@@ -8615,7 +8624,7 @@ const VxeButtonComponent = defineVxeComponent({
     $xeButton.renderVN = renderVN;
     (0,external_commonjs_vue_commonjs2_vue_root_Vue_.onMounted)(() => {
       if (props.type === 'text') {
-        warnLog('vxe.error.delProp', ['[button] type=text', 'mode=text']);
+        button_warnLog('vxe.error.delProp', ['type=text', 'mode=text']);
       }
       globalEvents.on($xeButton, 'mousewheel', handleGlobalMousewheelEvent);
       globalEvents.on($xeButton, 'mousedown', handleGlobalMousedownEvent);
@@ -8655,6 +8664,9 @@ const Button = VxeButton;
 
 
 
+const {
+  errLog: backtop_errLog
+} = createComponentLog('backtop');
 function createInternalData() {
   return {
     targetEl: null
@@ -8857,13 +8869,13 @@ function createReactData() {
         } = props;
         if (!target) {
           removeScrollEvent();
-          errLog('vxe.error.reqProp', ['target']);
+          backtop_errLog('vxe.error.reqProp', ['target']);
           return;
         }
         if (external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().isString(target)) {
           const tEl = document.querySelector(target);
           if (!tEl) {
-            errLog('vxe.error.errProp', [`target=${target}`, 'body']);
+            backtop_errLog('vxe.error.errProp', [`target=${target}`, 'body']);
           }
           const {
             targetEl
@@ -9379,6 +9391,24 @@ const ButtonGroup = VxeButtonGroup;
 /* harmony default export */ var packages_button_group = (VxeButtonGroup);
 ;// ./packages/date-panel/src/util.ts
 
+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';
 }
@@ -9399,18 +9429,6 @@ function handleValueFormat(type, valueFormat) {
   }
   return 'yyyy-MM-dd';
 }
-function handleInputFormat(type, inputFormat) {
-  if (inputFormat) {
-    return inputFormat;
-  }
-  if (type === 'time') {
-    return 'HH:mm:ss';
-  }
-  if (type === 'datetime') {
-    return 'yyyy-MM-dd HH:mm:ss';
-  }
-  return 'yyyy-MM-dd';
-}
 function toStringTimeDate(str) {
   const rest = new Date(2e3, 0, 1);
   if (str) {
@@ -9451,7 +9469,7 @@ function getDateQuarter(date) {
   }
   return 4;
 }
-const parseDateValue = (val, type, options) => {
+function parseDateValue(val, type, options) {
   const {
     valueFormat
   } = options;
@@ -9468,7 +9486,7 @@ const parseDateValue = (val, type, options) => {
     return external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().toStringDate(val, valueFormat);
   }
   return null;
-};
+}
 const parseDateString = (val, type, options) => {
   const dValue = parseDateValue(val, type, options);
   return dValue ? external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().toDateString(dValue, options.valueFormat) : '';
@@ -9620,9 +9638,20 @@ 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;
+}
 ;// ./packages/calendar/src/calendar.ts
 
 
@@ -9639,6 +9668,9 @@ const checkWeekOfsetYear = (W, M) => {
 
 
 
+const {
+  errLog: calendar_errLog
+} = createComponentLog('calendar');
 const {
   menus: calendar_menus,
   getConfig: calendar_getConfig,
@@ -11027,7 +11059,7 @@ const {
       } = props;
       const VxeUIContextMenu = VxeUI.getComponent('VxeContextMenu');
       if (menuConfig && !VxeUIContextMenu) {
-        errLog('vxe.error.reqComp', ['vxe-context-menu']);
+        calendar_errLog('vxe.error.reqComp', ['vxe-context-menu']);
       }
       dateOpenPanel();
     });
@@ -12365,6 +12397,9 @@ function toFloatValueFixed(inputValue, type, digitsValue, roundingMode) {
 
 
 
+const {
+  warnLog: input_warnLog
+} = createComponentLog('input');
 /* harmony default export */ var input = (defineVxeComponent({
   name: 'VxeInput',
   props: {
@@ -15125,11 +15160,11 @@ function toFloatValueFixed(inputValue, type, digitsValue, roundingMode) {
         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}" ... />`]);
+        input_warnLog('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}" ... />`]);
+        input_warnLog('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 ... />']);
+        input_warnLog('vxe.error.useNew', [`<vxe-input type="${type}" ... />`, '<vxe-password-input ... />']);
       }
       const inputElem = refInputTarget.value;
       if (inputElem) {
@@ -15180,6 +15215,9 @@ function toFloatValueFixed(inputValue, type, digitsValue, roundingMode) {
 
 
 
+const {
+  errLog: cascader_errLog
+} = createComponentLog('cascader');
 /**
  * 生成节点的唯一主键
  */
@@ -17096,7 +17134,7 @@ function cascader_createInternalData() {
     loadData(props.options || []);
     (0,external_commonjs_vue_commonjs2_vue_root_Vue_.onMounted)(() => {
       if (props.filterable) {
-        errLog('vxe.error.notProp', ['filterable']);
+        cascader_errLog('vxe.error.notProp', ['filterable']);
       }
       globalEvents.on($xeCascader, 'mousewheel', handleGlobalMousewheelEvent);
       globalEvents.on($xeCascader, 'mousedown', handleGlobalMousedownEvent);
@@ -17504,6 +17542,9 @@ const CheckboxButton = VxeCheckboxButton;
 
 
 
+function group_createReactData() {
+  return {};
+}
 function group_createInternalData() {
   return {
     // isLoaded: false
@@ -17542,7 +17583,7 @@ function group_createInternalData() {
     const $xeForm = (0,external_commonjs_vue_commonjs2_vue_root_Vue_.inject)('$xeForm', null);
     const formItemInfo = (0,external_commonjs_vue_commonjs2_vue_root_Vue_.inject)('xeFormItemInfo', null);
     const xID = external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().uniqueId();
-    const reactData = (0,external_commonjs_vue_commonjs2_vue_root_Vue_.reactive)({});
+    const reactData = (0,external_commonjs_vue_commonjs2_vue_root_Vue_.reactive)(group_createReactData());
     const internalData = group_createInternalData();
     const computeIsReadonly = (0,external_commonjs_vue_commonjs2_vue_root_Vue_.computed)(() => {
       const {
@@ -17721,6 +17762,7 @@ function group_createInternalData() {
       });
     });
     (0,external_commonjs_vue_commonjs2_vue_root_Vue_.onUnmounted)(() => {
+      external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().assign(reactData, group_createReactData());
       external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().assign(internalData, group_createInternalData());
     });
     (0,external_commonjs_vue_commonjs2_vue_root_Vue_.provide)('$xeCheckboxGroup', $xeCheckboxGroup);
@@ -23820,6 +23862,40 @@ const DatePanel = VxeDatePanel;
 
 
 
+
+
+
+
+const {
+  warnLog: date_picker_warnLog,
+  errLog: date_picker_errLog
+} = 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 date_picker_createReactData() {
+  return {
+    initialized: false,
+    panelIndex: 0,
+    visiblePanel: false,
+    isAniVisible: false,
+    panelStyle: {},
+    panelPlacement: '',
+    isActivated: false,
+    inputValue: '',
+    labelFlag: 0
+  };
+}
+function date_picker_createInternalData() {
+  return {
+    // hpTimeout: undefined,
+    inputLabel: '',
+    laseFocusMasked: 0
+  };
+}
 /* harmony default export */ var date_picker = (defineVxeComponent({
   name: 'VxeDatePicker',
   props: {
@@ -23882,7 +23958,6 @@ const DatePanel = VxeDatePanel;
     labelFormat: String,
     valueFormat: String,
     timeFormat: String,
-    inputFormat: String,
     editable: {
       type: Boolean,
       default: true
@@ -23912,7 +23987,7 @@ const DatePanel = VxeDatePanel;
       type: Boolean,
       default: () => getConfig().datePicker.autoClose
     },
-    controlConfig: Object,
+    maskedConfig: Object,
     prefixIcon: String,
     suffixIcon: String,
     placement: String,
@@ -23941,21 +24016,8 @@ const DatePanel = VxeDatePanel;
     const {
       computeSize
     } = useSize(props);
-    const reactData = (0,external_commonjs_vue_commonjs2_vue_root_Vue_.reactive)({
-      initialized: false,
-      panelIndex: 0,
-      visiblePanel: false,
-      isAniVisible: false,
-      panelStyle: {},
-      panelPlacement: '',
-      isActivated: false,
-      inputValue: '',
-      inputLabel: ''
-    });
-    const internalData = {
-      // hpTimeout: undefined,
-      parseInputKayMaps: {}
-    };
+    const reactData = (0,external_commonjs_vue_commonjs2_vue_root_Vue_.reactive)(date_picker_createReactData());
+    const internalData = date_picker_createInternalData();
     const refElem = (0,external_commonjs_vue_commonjs2_vue_root_Vue_.ref)();
     const refInputTarget = (0,external_commonjs_vue_commonjs2_vue_root_Vue_.ref)();
     const refInputPanel = (0,external_commonjs_vue_commonjs2_vue_root_Vue_.ref)();
@@ -24029,6 +24091,50 @@ const DatePanel = VxeDatePanel;
     const computeIsClearable = (0,external_commonjs_vue_commonjs2_vue_root_Vue_.computed)(() => {
       return props.clearable;
     });
+    const computeIsDatePanelType = (0,external_commonjs_vue_commonjs2_vue_root_Vue_.computed)(() => {
+      const isDateTimeType = computeIsDateTimeType.value;
+      return isDateTimeType || ['date', 'week', 'month', 'quarter', 'year'].indexOf(props.type) > -1;
+    });
+    const computeDateListValue = (0,external_commonjs_vue_commonjs2_vue_root_Vue_.computed)(() => {
+      const {
+        modelValue,
+        type,
+        multiple
+      } = props;
+      const isDatePanelType = computeIsDatePanelType.value;
+      const dateValueFormat = computeDateValueFormat.value;
+      if (multiple && modelValue && isDatePanelType) {
+        return external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().toValueString(modelValue).split(',').map(item => {
+          const date = parseDateValue(item, type, {
+            valueFormat: dateValueFormat
+          });
+          if (external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().isValidDate(date)) {
+            return date;
+          }
+          return date;
+        });
+      }
+      return [];
+    });
+    const computeLimitMaxCount = (0,external_commonjs_vue_commonjs2_vue_root_Vue_.computed)(() => {
+      return props.multiple ? external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().toNumber(props.limitCount) : 0;
+    });
+    const computeDateMultipleValue = (0,external_commonjs_vue_commonjs2_vue_root_Vue_.computed)(() => {
+      const dateListValue = computeDateListValue.value;
+      const dateValueFormat = computeDateValueFormat.value;
+      return dateListValue.map(date => external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().toDateString(date, dateValueFormat));
+    });
+    const computeOverCount = (0,external_commonjs_vue_commonjs2_vue_root_Vue_.computed)(() => {
+      const {
+        multiple
+      } = props;
+      const limitMaxCount = computeLimitMaxCount.value;
+      const dateMultipleValue = computeDateMultipleValue.value;
+      if (multiple && limitMaxCount) {
+        return dateMultipleValue.length >= limitMaxCount;
+      }
+      return false;
+    });
     const computeInputReadonly = (0,external_commonjs_vue_commonjs2_vue_root_Vue_.computed)(() => {
       const {
         type,
@@ -24093,12 +24199,9 @@ const DatePanel = VxeDatePanel;
       } = props;
       return handleValueFormat(type, valueFormat);
     });
-    const computeDateInputFormat = (0,external_commonjs_vue_commonjs2_vue_root_Vue_.computed)(() => {
-      const {
-        type,
-        inputFormat
-      } = props;
-      return handleInputFormat(type, inputFormat);
+    const computeDateMaskedFormat = (0,external_commonjs_vue_commonjs2_vue_root_Vue_.computed)(() => {
+      const dateLabelFormat = computeDateLabelFormat.value;
+      return dateLabelFormat;
     });
     const computeFirstDayOfWeek = (0,external_commonjs_vue_commonjs2_vue_root_Vue_.computed)(() => {
       const {
@@ -24127,8 +24230,15 @@ const DatePanel = VxeDatePanel;
         return dateObj.label;
       }).join(', ');
     });
-    const computeControlOpts = (0,external_commonjs_vue_commonjs2_vue_root_Vue_.computed)(() => {
-      return Object.assign({}, getConfig().datePicker.controlConfig, props.controlConfig);
+    const computeMaskedOpts = (0,external_commonjs_vue_commonjs2_vue_root_Vue_.computed)(() => {
+      return Object.assign({}, getConfig().datePicker.maskedConfig, props.maskedConfig);
+    });
+    const computeMaskChar = (0,external_commonjs_vue_commonjs2_vue_root_Vue_.computed)(() => {
+      const maskedOpts = computeMaskedOpts.value;
+      const {
+        maskPlaceholder
+      } = maskedOpts;
+      return (maskPlaceholder ? ('' + maskPlaceholder)[0] : '') || '*';
     });
     const updateModelValue = () => {
       const {
@@ -24144,6 +24254,12 @@ const DatePanel = VxeDatePanel;
       }
       reactData.inputValue = val;
     };
+    const handleInputLabel = (text, isUpdate) => {
+      internalData.inputLabel = text;
+      if (isUpdate) {
+        reactData.labelFlag++;
+      }
+    };
     const triggerEvent = evnt => {
       const {
         inputValue
@@ -24205,7 +24321,7 @@ const DatePanel = VxeDatePanel;
     const inputEvent = evnt => {
       const inputElem = evnt.target;
       const value = inputElem.value;
-      reactData.inputLabel = value;
+      handleInputLabel(value, true);
       dispatchEvent('input', {
         value
       }, evnt);
@@ -24216,19 +24332,6 @@ const DatePanel = VxeDatePanel;
         triggerEvent(evnt);
       }
     };
-    const focusEvent = evnt => {
-      const popupOpts = computePopupOpts.value;
-      const {
-        trigger
-      } = popupOpts;
-      reactData.isActivated = true;
-      if (!trigger || trigger === 'default') {
-        datePickerOpenEvent(evnt);
-      } else if (trigger === 'icon') {
-        hidePanel();
-      }
-      triggerEvent(evnt);
-    };
     const clickPrefixEvent = evnt => {
       const isDisabled = computeIsDisabled.value;
       if (!isDisabled) {
@@ -24249,6 +24352,125 @@ const DatePanel = VxeDatePanel;
         }, 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 = external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().toNumber(props.selectDay);
+        date = external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().getWhatWeek(date, 0, sWeek, firstDayOfWeek);
+      }
+      const inpVal = external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().toDateString(date, dateValueFormat, {
+        firstDay: firstDayOfWeek
+      });
+      if (multiple) {
+        const overCount = computeOverCount.value;
+        // 如果为多选
+        if (isDateTimeType) {
+          // 如果是datetime特殊类型
+          const dateListValue = isReload ? [] : [...computeDateListValue.value];
+          const datetimeRest = [];
+          const eqIndex = external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().findIndexOf(dateListValue, val => external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().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 => external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().toDateString(date, dateValueFormat)).join(','), {
+            type: 'update'
+          });
+        } else {
+          const dateMultipleValue = isReload ? [] : computeDateMultipleValue.value;
+          // 如果是日期类型
+          if (dateMultipleValue.some(val => external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().isEqual(val, inpVal))) {
+            handleChange(dateMultipleValue.filter(val => !external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().isEqual(val, inpVal)).join(','), {
+              type: 'update'
+            });
+          } else {
+            if (overCount) {
+              // 如果超出最大多选数量
+              return;
+            }
+            handleChange(dateMultipleValue.concat([inpVal]).join(','), {
+              type: 'update'
+            });
+          }
+        }
+      } else {
+        // 如果为单选
+        if (!external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().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 (!external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().isValidDate(inpDateVal)) {
+        dateRevert();
+        return;
+      }
+      if (type === 'time') {
+        inpDateVal = external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().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 !== external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().toDateString(dateValue, dateLabelFormat) || inpVal !== external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().toDateString(inpDateVal, dateLabelFormat)) {
+          isChange = true;
+        }
+      } else {
+        isChange = true;
+      }
+      const label = external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().toDateString(inpDateVal, dateLabelFormat, {
+        firstDay: firstDayOfWeek
+      });
+      handleInputLabel(label, true);
+      if (isChange) {
+        dateChange(inpDateVal);
+      }
+    };
     const clearValueEvent = (evnt, value) => {
       const isDatePickerType = computeIsDatePickerType.value;
       if (isDatePickerType) {
@@ -24270,17 +24492,225 @@ const DatePanel = VxeDatePanel;
         }, evnt);
       }
     };
-    const handleArrowInputDate = (evnt, isUpArrow) => {
+    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) : external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().toNumber(chunkValue)) + (isUpArrow ? 1 : -1);
+          const restValue = inpValue.slice(0, chunkStartIndex) + external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().padStart(chunkNum, chunkFormat.length, '0') + inpValue.slice(chunkEndIndex);
+          evnt.preventDefault();
+          if (restValue.indexOf(maskChar) === -1) {
+            // 解析日期
+            const inpDateVal = parseDateValue(restValue, type, {
+              valueFormat: dateLabelFormat
+            });
+            if (external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().isValidDate(inpDateVal)) {
+              const label = external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().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 = external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().map(dateMaskedFormat.match(new RegExp(`(${inputMaskedKeys.join('|')})+`, 'g')) || [], fullKey => fullKey[0]);
+          const currIndex = external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().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 {
-        inputValue
-      } = reactData;
-      if (!inputValue) {
+        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 = external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().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;
@@ -24288,17 +24718,79 @@ const DatePanel = VxeDatePanel;
         return;
       }
       const {
-        parseInputKayMaps
+        laseFocusMasked
       } = internalData;
-      const inputFormat = computeDateInputFormat.value;
+      if (laseFocusMasked && Date.now() - laseFocusMasked < 100) {
+        return;
+      }
+      const dateMaskedFormat = computeDateMaskedFormat.value;
+      const maskChar = computeMaskChar.value;
       const selectionStart = targetElem.selectionStart || 0;
-      let selectKey = inputFormat[selectionStart];
+      const selectionEnd = targetElem.selectionEnd || 0;
+      const inpValue = targetElem.value;
+      const allMaskedKeys = external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().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 = ('' + external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().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 = inputFormat[selectionStart - 1];
+        selectKey = dateMaskedFormat[selectionStart - 1];
       }
-      const inputPaesrFn = parseInputKayMaps[selectKey];
-      if (inputPaesrFn) {
-        inputPaesrFn(evnt, targetElem, isUpArrow);
+      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 => {
@@ -24312,10 +24804,15 @@ const DatePanel = VxeDatePanel;
         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', {
@@ -24326,15 +24823,92 @@ const DatePanel = VxeDatePanel;
         $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 {
-        controlConfig
+        type,
+        editable,
+        maskedConfig
       } = props;
-      const controlOpts = computeControlOpts.value;
+      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);
-      if ((isUpArrow || isDwArrow) && controlOpts.isArrow && (controlConfig || controlOpts.enabled)) {
-        handleArrowInputDate(evnt, isUpArrow);
+      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);
     };
@@ -24369,7 +24943,7 @@ const DatePanel = VxeDatePanel;
       dispatchEvent('confirm', params, params.$event);
     };
     const panelRevertEvent = params => {
-      reactData.inputLabel = params.label;
+      handleInputLabel(params.label, true);
     };
     // 全局事件
     const handleGlobalMousedownEvent = evnt => {
@@ -24382,12 +24956,20 @@ const DatePanel = VxeDatePanel;
       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);
             }
           }
         }
@@ -24395,6 +24977,7 @@ const DatePanel = VxeDatePanel;
     };
     const handleGlobalKeydownEvent = evnt => {
       const {
+        isActivated,
         visiblePanel
       } = reactData;
       const isDisabled = computeIsDisabled.value;
@@ -24402,7 +24985,9 @@ const DatePanel = VxeDatePanel;
         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) {
@@ -24441,7 +25026,7 @@ const DatePanel = VxeDatePanel;
       }
       if (visiblePanel || isActivated) {
         if ($datePanel) {
-          $datePanel.checkValue(reactData.inputLabel);
+          $datePanel.checkValue(internalData.inputLabel);
         }
         const targetElem = refInputTarget.value;
         if (targetElem) {
@@ -24543,9 +25128,6 @@ const DatePanel = VxeDatePanel;
         }
       }
     };
-    const clickEvent = evnt => {
-      triggerEvent(evnt);
-    };
     const handleShortcutEvent = ({
       option,
       $event
@@ -24596,7 +25178,7 @@ const DatePanel = VxeDatePanel;
                 break;
               }
             default:
-              errLog('vxe.error.notCommands', [`[date-picker] ${code}`]);
+              date_picker_errLog('vxe.error.notCommands', [code]);
               break;
           }
         }
@@ -24847,10 +25429,13 @@ const DatePanel = VxeDatePanel;
       } = props;
       const {
         inputValue,
-        inputLabel,
         visiblePanel,
-        isActivated
+        isActivated,
+        labelFlag
       } = reactData;
+      const {
+        inputLabel
+      } = internalData;
       const vSize = computeSize.value;
       const isDisabled = computeIsDisabled.value;
       const formReadonly = computeFormReadonly.value;
@@ -24883,7 +25468,7 @@ const DatePanel = VxeDatePanel;
       }, [(0,external_commonjs_vue_commonjs2_vue_root_Vue_.h)('input', {
         ref: refInputTarget,
         class: 'vxe-date-picker--inner',
-        value: inputLabel,
+        value: labelFlag ? inputLabel : '',
         name,
         type: 'text',
         placeholder: inpPlaceholder,
@@ -24902,7 +25487,7 @@ const DatePanel = VxeDatePanel;
       renderPanel()]);
     };
     (0,external_commonjs_vue_commonjs2_vue_root_Vue_.watch)(computePanelLabel, val => {
-      reactData.inputLabel = val;
+      handleInputLabel(val, true);
     });
     (0,external_commonjs_vue_commonjs2_vue_root_Vue_.watch)(() => props.modelValue, () => {
       updateModelValue();
@@ -24916,14 +25501,18 @@ const DatePanel = VxeDatePanel;
     });
     (0,external_commonjs_vue_commonjs2_vue_root_Vue_.onMounted)(() => {
       const {
-        parseInputKayMaps
-      } = internalData;
-      const inputKeys = ['y', 'M', 'd', 'H', 'm', 'n'];
-      inputKeys.forEach(key => {
-        parseInputKayMaps[key] = evnt => {
-          evnt.preventDefault();
-        };
-      });
+        type,
+        multiple,
+        maskedConfig
+      } = props;
+      if (isEnableConf(maskedConfig)) {
+        if (multiple) {
+          date_picker_errLog('vxe.error.notSupportProp', ['multiple', 'control-config.enabled=true', 'control-config.enabled=false']);
+        }
+        if (!maskedTypes.includes(type)) {
+          date_picker_warnLog('vxe.error.notSupportProp', ['control-config.enabled=true', `type=${type}`, `type=${maskedTypes.join('|')}`]);
+        }
+      }
     });
     (0,external_commonjs_vue_commonjs2_vue_root_Vue_.onUnmounted)(() => {
       globalEvents.off($xeDatePicker, 'mousewheel');
@@ -24968,6 +25557,9 @@ const DatePicker = VxeDatePicker;
 
 
 
+const {
+  errLog: date_range_picker_errLog
+} = createComponentLog('date-range-picker');
 /* harmony default export */ var date_range_picker = (defineVxeComponent({
   name: 'VxeDateRangePicker',
   props: {
@@ -25979,7 +26571,7 @@ const DatePicker = VxeDatePicker;
                 break;
               }
             default:
-              errLog('vxe.error.notCommands', [`[date-range-picker] ${code}`]);
+              date_range_picker_errLog('vxe.error.notCommands', [code]);
               break;
           }
         }
@@ -26488,6 +27080,7 @@ const allActiveDrawers = [];
       type: Boolean,
       default: () => getConfig().drawer.showTitleOverflow
     },
+    preload: Boolean,
     width: [Number, String],
     height: [Number, String],
     resize: {
@@ -27036,6 +27629,7 @@ const allActiveDrawers = [];
       }
     });
     (0,external_commonjs_vue_commonjs2_vue_root_Vue_.onMounted)(() => {
+      reactData.initialized = !!props.preload;
       (0,external_commonjs_vue_commonjs2_vue_root_Vue_.nextTick)(() => {
         if (props.modelValue) {
           openDrawer();
@@ -27225,6 +27819,9 @@ const Empty = VxeEmpty;
 
 
 
+const {
+  errLog: itemInfo_errLog
+} = createComponentLog('form');
 class ItemInfo {
   constructor($xeForm, item) {
     const {
@@ -27236,21 +27833,21 @@ class ItemInfo {
       if (external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().isString(formatter)) {
         const gFormatOpts = formats.get(formatter);
         if (!gFormatOpts || !gFormatOpts.formItemFormatMethod) {
-          errLog('vxe.error.notFormats', [`[form] ${formatter}`]);
+          itemInfo_errLog('vxe.error.notFormats', [formatter]);
         }
       } else if (external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().isArray(formatter)) {
         const gFormatOpts = formats.get(formatter[0]);
         if (!gFormatOpts || !gFormatOpts.formItemFormatMethod) {
-          errLog('vxe.error.notFormats', [`[form] ${formatter[0]}`]);
+          itemInfo_errLog('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}`]);
+        itemInfo_errLog('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}`]);
+        itemInfo_errLog('vxe.error.modelConflicts', [`field=${field}`, `item-render.endField=${itemRender.endField}`]);
       }
     }
     Object.assign(this, {
@@ -28183,6 +28780,9 @@ const VxeFormConfigItem = defineVxeComponent({
 
 
 
+const {
+  errLog: render_errLog
+} = createComponentLog('form');
 const componentDefaultModelProp = 'modelValue';
 /**
  * 已废弃
@@ -28287,7 +28887,7 @@ function getComponentOns(renderOpts, params, eFns, eventOns) {
   external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().objectEach(events, (func, key) => {
     ons[getOnName(key)] = function (...args) {
       if (!external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().isFunction(func)) {
-        errLog('vxe.error.errFunc', [`[form] ${func}`]);
+        render_errLog('vxe.error.errFunc', [func]);
       }
       func(params, ...args);
     };
@@ -28896,6 +29496,10 @@ renderer.mixin({
 
 
 
+const {
+  warnLog: form_warnLog,
+  errLog: form_errLog
+} = createComponentLog('form');
 class Rule {
   constructor(rule) {
     Object.assign(this, {
@@ -29216,7 +29820,7 @@ function form_createInternalData() {
             external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().each(item.slots, func => {
               if (!external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().isFunction(func)) {
                 if (!slots[func]) {
-                  errLog('vxe.error.notSlot', [`[form] ${func}`]);
+                  form_errLog('vxe.error.notSlot', [func]);
                 }
               }
             });
@@ -29499,10 +30103,10 @@ function form_createInternalData() {
                       if (validatorMethod) {
                         customValid = validatorMethod(validParams);
                       } else {
-                        warnLog('vxe.error.notValidators', [`[form] ${validator}`]);
+                        form_warnLog('vxe.error.notValidators', [validator]);
                       }
                     } else {
-                      errLog('vxe.error.notValidators', [`[form] ${validator}`]);
+                      form_errLog('vxe.error.notValidators', [validator]);
                     }
                   } else {
                     customValid = validator(validParams);
@@ -29934,7 +30538,7 @@ function form_createInternalData() {
     (0,external_commonjs_vue_commonjs2_vue_root_Vue_.onMounted)(() => {
       (0,external_commonjs_vue_commonjs2_vue_root_Vue_.nextTick)(() => {
         if (props.customLayout && props.items) {
-          errLog('vxe.error.errConflicts', ['[form] custom-layout', 'items']);
+          form_errLog('vxe.error.errConflicts', ['custom-layout', 'items']);
         }
       });
       globalEvents.on($xeForm, 'resize', handleGlobalResizeEvent);
@@ -32618,6 +33222,9 @@ const List = VxeList;
 
 
 
+const {
+  errLog: menu_errLog
+} = createComponentLog('menu');
 const {
   menus: menu_menus,
   getConfig: menu_getConfig,
@@ -33166,7 +33773,7 @@ const {
       } = props;
       const VxeUIContextMenu = VxeUI.getComponent('VxeContextMenu');
       if (menuConfig && !VxeUIContextMenu) {
-        errLog('vxe.error.reqComp', ['vxe-context-menu']);
+        menu_errLog('vxe.error.reqComp', ['vxe-context-menu']);
       }
       globalEvents.on($xeMenu, 'resize', updateCollapseStyle);
       updateCollapseStyle();
@@ -33219,6 +33826,10 @@ const Menu = VxeMenu;
 
 
 
+const {
+  warnLog: modal_warnLog,
+  errLog: modal_errLog
+} = createComponentLog('modal');
 const allActiveModals = [];
 const msgQueue = [];
 const notifyQueue = [];
@@ -33305,6 +33916,7 @@ const lockScrollCssWidthKey = '--vxe-ui-modal-lock-scroll-view-width';
       type: Boolean,
       default: () => getConfig().modal.showFooter
     },
+    preload: Boolean,
     showZoom: Boolean,
     zoomConfig: Object,
     showMaximize: {
@@ -34701,11 +35313,12 @@ const lockScrollCssWidthKey = '--vxe-ui-modal-lock-scroll-view-width';
     });
     (0,external_commonjs_vue_commonjs2_vue_root_Vue_.onMounted)(() => {
       if (props.type === 'modal' && props.showFooter && !(props.showConfirmButton || props.showCancelButton || slots.footer)) {
-        warnLog('vxe.modal.footPropErr');
+        modal_warnLog('vxe.modal.footPropErr');
       }
+      reactData.initialized = !!props.preload;
       (0,external_commonjs_vue_commonjs2_vue_root_Vue_.nextTick)(() => {
         if (props.storage && !props.id) {
-          errLog('vxe.error.reqProp', ['[modal] id']);
+          modal_errLog('vxe.error.reqProp', ['id']);
         }
         if (props.modelValue) {
           openModal();
@@ -35246,12 +35859,36 @@ const Option = VxeOption;
 
 
 
+const {
+  errLog: select_errLog
+} = createComponentLog('select');
 function isOptionVisible(option) {
   return option.visible !== false;
 }
 function getOptUniqueId() {
   return external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().uniqueId('opt_');
 }
+function select_createReactData() {
+  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 select_createInternalData() {
   return {
     // isLoaded: false,
@@ -35421,25 +36058,7 @@ function select_createInternalData() {
     const {
       computeSize
     } = useSize(props);
-    const reactData = (0,external_commonjs_vue_commonjs2_vue_root_Vue_.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 = (0,external_commonjs_vue_commonjs2_vue_root_Vue_.reactive)(select_createReactData());
     const internalData = select_createInternalData();
     const refMaps = {
       refElem
@@ -36645,7 +37264,7 @@ function select_createInternalData() {
                 emitDefaultValue(datas.map(item => item[valueField]));
               });
             } else {
-              errLog('vxe.error.notConflictProp', ['default-config.selectMode=all', 'multiple=true']);
+              select_errLog('vxe.error.notConflictProp', ['default-config.selectMode=all', 'multiple=true']);
             }
           } else if (selectMode === 'first' || selectMode === 'last') {
             const selectItem = (external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default())[selectMode](datas);
@@ -37117,6 +37736,7 @@ function select_createInternalData() {
       globalEvents.off($xeSelect, 'keydown');
       globalEvents.off($xeSelect, 'blur');
       globalEvents.off($xeSelect, 'resize');
+      external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().assign(reactData, select_createReactData());
       external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().assign(internalData, select_createInternalData());
     });
     (0,external_commonjs_vue_commonjs2_vue_root_Vue_.provide)('$xeSelect', $xeSelect);
@@ -37139,6 +37759,10 @@ function select_createInternalData() {
 
 
 
+const {
+  warnLog: pager_warnLog,
+  errLog: pager_errLog
+} = createComponentLog('pager');
 /* harmony default export */ var pager = (defineVxeComponent({
   name: 'VxePager',
   props: {
@@ -37848,7 +38472,7 @@ function select_createInternalData() {
        * @deprecated
        */
       jumpPage(currentPage) {
-        warnLog('vxe.error.delFunc', ['[pager] jumpPage', 'setCurrentPage']);
+        pager_warnLog('vxe.error.delFunc', ['jumpPage', 'setCurrentPage']);
         return $xePager.setCurrentPage(currentPage);
       }
     };
@@ -37924,7 +38548,7 @@ function select_createInternalData() {
         if (renderFn) {
           childNodes.push(renderFn());
         } else {
-          errLog('vxe.error.notProp', [`[pager] layouts -> ${name}`]);
+          pager_errLog('vxe.error.notProp', [`layouts -> ${name}`]);
         }
       });
       if (slots.right) {
@@ -39851,6 +40475,9 @@ const RadioButton = VxeRadioButton;
 
 
 
+function src_group_createReactData() {
+  return {};
+}
 function src_group_createInternalData() {
   return {
     // isLoaded: false
@@ -39893,7 +40520,7 @@ function src_group_createInternalData() {
     const {
       computeSize
     } = useSize(props);
-    const reactData = (0,external_commonjs_vue_commonjs2_vue_root_Vue_.reactive)({});
+    const reactData = (0,external_commonjs_vue_commonjs2_vue_root_Vue_.reactive)(src_group_createReactData());
     const internalData = src_group_createInternalData();
     const computeIsReadonly = (0,external_commonjs_vue_commonjs2_vue_root_Vue_.computed)(() => {
       const {
@@ -40051,6 +40678,7 @@ function src_group_createInternalData() {
       });
     });
     (0,external_commonjs_vue_commonjs2_vue_root_Vue_.onUnmounted)(() => {
+      external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().assign(reactData, src_group_createReactData());
       external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().assign(internalData, src_group_createInternalData());
     });
     (0,external_commonjs_vue_commonjs2_vue_root_Vue_.provide)('$xeRadioGroup', $xeRadioGroup);
@@ -40769,6 +41397,10 @@ const Select = VxeSelect;
 
 
 
+const {
+  warnLog: splitter_warnLog,
+  errLog: splitter_errLog
+} = createComponentLog('splitter');
 /* harmony default export */ var splitter = (defineVxeComponent({
   name: 'VxeSplitter',
   props: {
@@ -40989,13 +41621,13 @@ const Select = VxeSelect;
       };
       reactData.itemList = list.map(item => {
         if (item.showAction) {
-          warnLog('vxe.error.removeProp', ['[splitter] show-action']);
+          splitter_warnLog('vxe.error.removeProp', ['show-action']);
         }
         if (item.slots) {
           external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().each(item.slots, func => {
             if (!external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().isFunction(func)) {
               if (!slots[func]) {
-                errLog('vxe.error.notSlot', [`[splitter] ${func}`]);
+                splitter_errLog('vxe.error.notSlot', [func]);
               }
             }
           });
@@ -41005,10 +41637,10 @@ const Select = VxeSelect;
         });
       });
       if (staticItems.length) {
-        errLog('vxe.error.errConflicts', ['<vxe-splitter-panel ...>', 'items']);
+        splitter_errLog('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']);
+        splitter_errLog('vxe.error.errConflicts', ['action-config.showPrevButton | action-config.showNextButton', 'Only supports 2 item']);
       }
       return recalculate();
     };
@@ -41748,15 +42380,15 @@ const Select = VxeSelect;
         showNextButton
       } = actionOpts;
       if (props.items && props.items.length) {
-        errLog('vxe.error.errConflicts', ['<vxe-splitter-panel ...>', 'items']);
+        splitter_errLog('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']);
+        splitter_errLog('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']);
+          splitter_warnLog('vxe.error.removeProp', ['showAction']);
         }
       });
       recalculate();
@@ -41775,7 +42407,7 @@ const Select = VxeSelect;
       }
       const actionOpts = computeActionOpts.value;
       if (actionOpts.direction) {
-        errLog('vxe.error.delProp', ['[splitter] action-config.direction', 'action-config.showPrevButton | action-config.showNextButton']);
+        splitter_errLog('vxe.error.delProp', ['action-config.direction', 'action-config.showPrevButton | action-config.showNextButton']);
       }
       globalEvents.on($xeSplitter, 'resize', handleGlobalResizeEvent);
     });
@@ -42723,9 +43355,26 @@ const TabPane = VxeTabPane;
 
 
 
+const {
+  errLog: table_select_errLog
+} = createComponentLog('table-select');
 function getRowUniqueId() {
   return external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().uniqueId('row_');
 }
+function table_select_createReactData() {
+  return {
+    initialized: false,
+    tableColumns: [],
+    fullOptionList: [],
+    panelIndex: 0,
+    panelStyle: {},
+    panelPlacement: null,
+    triggerFocusPanel: false,
+    visiblePanel: false,
+    isAniVisible: false,
+    isActivated: false
+  };
+}
 function table_select_createInternalData() {
   return {
     // hpTimeout: undefined,
@@ -42799,18 +43448,7 @@ function table_select_createInternalData() {
     const refGridWrapper = (0,external_commonjs_vue_commonjs2_vue_root_Vue_.ref)();
     const refOptionPanel = (0,external_commonjs_vue_commonjs2_vue_root_Vue_.ref)();
     const refGrid = (0,external_commonjs_vue_commonjs2_vue_root_Vue_.ref)();
-    const reactData = (0,external_commonjs_vue_commonjs2_vue_root_Vue_.reactive)({
-      initialized: false,
-      tableColumns: [],
-      fullOptionList: [],
-      panelIndex: 0,
-      panelStyle: {},
-      panelPlacement: null,
-      triggerFocusPanel: false,
-      visiblePanel: false,
-      isAniVisible: false,
-      isActivated: false
-    });
+    const reactData = (0,external_commonjs_vue_commonjs2_vue_root_Vue_.reactive)(table_select_createReactData());
     const internalData = table_select_createInternalData();
     const refMaps = {
       refElem
@@ -43101,12 +43739,12 @@ function table_select_createInternalData() {
             rowid = getRowUniqueId();
           }
           if (keyMaps[rowid]) {
-            errLog('vxe.error.repeatKey', [`[table-select] ${rowKeyField}`, rowid]);
+            table_select_errLog('vxe.error.repeatKey', [rowKeyField, rowid]);
           }
           keyMaps[rowid] = true;
           const value = item[valueField];
           if (rowMaps[value]) {
-            errLog('vxe.error.repeatKey', [`[table-select] ${valueField}`, value]);
+            table_select_errLog('vxe.error.repeatKey', [valueField, value]);
           }
           rowMaps[value] = {
             item,
@@ -43484,11 +44122,12 @@ function table_select_createInternalData() {
       globalEvents.off($xeTableSelect, 'mousedown');
       globalEvents.off($xeTableSelect, 'blur');
       globalEvents.off($xeTableSelect, 'resize');
+      external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().assign(reactData, table_select_createReactData());
       external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().assign(internalData, table_select_createInternalData());
     });
     (0,external_commonjs_vue_commonjs2_vue_root_Vue_.nextTick)(() => {
       if (!VxeTableGridComponent) {
-        errLog('vxe.error.reqComp', ['[table-select] vxe-grid']);
+        table_select_errLog('vxe.error.reqComp', ['vxe-grid']);
       }
     });
     (0,external_commonjs_vue_commonjs2_vue_root_Vue_.provide)('$xeTableSelect', $xeTableSelect);
@@ -43529,6 +44168,10 @@ const TableSelect = VxeTableSelect;
 
 
 
+const {
+  warnLog: tabs_warnLog,
+  errLog: tabs_errLog
+} = createComponentLog('tabs');
 const scrollbarOffsetSize = 20;
 /* harmony default export */ var tabs = (defineVxeComponent({
   name: 'VxeTabs',
@@ -43963,7 +44606,7 @@ const scrollbarOffsetSize = 20;
             cacheItem.loading = false;
           });
         } else {
-          errLog('vxe.error.notFunc', ['refresh-config.queryMethod']);
+          tabs_errLog('vxe.error.notFunc', ['refresh-config.queryMethod']);
         }
       }
     };
@@ -44180,11 +44823,11 @@ const scrollbarOffsetSize = 20;
         return handlePrevNext(true);
       },
       prevTab() {
-        warnLog('vxe.error.delFunc', ['[tabs] prevTab', 'prev']);
+        tabs_warnLog('vxe.error.delFunc', ['prevTab', 'prev']);
         return tabsMethods.prev();
       },
       nextTab() {
-        warnLog('vxe.error.delFunc', ['[tabs] nextTab', 'next']);
+        tabs_warnLog('vxe.error.delFunc', ['nextTab', 'next']);
         return tabsMethods.next();
       }
     };
@@ -45007,6 +45650,9 @@ const Text = VxeText;
 
 
 
+const {
+  warnLog: textarea_warnLog
+} = createComponentLog('textarea');
 let autoTxtElem;
 /* harmony default export */ var src_textarea = (defineVxeComponent({
   name: 'VxeTextarea',
@@ -45423,7 +46069,7 @@ let autoTxtElem;
         autoSize
       } = props;
       if (autosize) {
-        warnLog('vxe.error.delProp', ['autosize', 'auto-size']);
+        textarea_warnLog('vxe.error.delProp', ['autosize', 'auto-size']);
       }
       if (autosize || autoSize) {
         updateAutoTxt();
@@ -45905,6 +46551,9 @@ function clearColAnimate(elem, clss) {
 
 
 
+const {
+  errLog: tree_errLog
+} = createComponentLog('tree');
 const {
   menus: tree_menus,
   getConfig: tree_getConfig,
@@ -46692,7 +47341,7 @@ function tree_createReactData() {
       handleData(true);
       if (sYLoad) {
         if (!(props.height || props.maxHeight)) {
-          errLog('vxe.error.reqProp', ['[tree] height | max-height | virtual-y-config.enabled=false']);
+          tree_errLog('vxe.error.reqProp', ['height | max-height | virtual-y-config.enabled=false']);
         }
       }
       return computeScrollLoad().then(() => {
@@ -48934,17 +49583,17 @@ function tree_createReactData() {
       } = props;
       const dragOpts = computeDragOpts.value;
       if (drag && !transform) {
-        errLog('vxe.error.notSupportProp', ['drag', 'transform=false', 'transform=true']);
+        tree_errLog('vxe.error.notSupportProp', ['drag', 'transform=false', 'transform=true']);
       }
       if (dragOpts.isCrossTreeDrag) {
-        errLog('vxe.error.notProp', ['drag-config.isCrossTreeDrag']);
+        tree_errLog('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']);
+        tree_errLog('vxe.error.reqComp', ['vxe-context-menu']);
       }
       if (props.autoResize) {
         const el = refElem.value;
@@ -49013,6 +49662,10 @@ const Tree = VxeTree;
 
 
 
+const {
+  warnLog: tree_select_warnLog,
+  errLog: tree_select_errLog
+} = createComponentLog('tree-select');
 function tree_select_getOptUniqueId() {
   return external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().uniqueId('node_');
 }
@@ -49406,12 +50059,12 @@ function tree_select_createInternalData() {
           nodeid = tree_select_getOptUniqueId();
         }
         if (keyMaps[nodeid]) {
-          errLog('vxe.error.repeatKey', [nodeKeyField, nodeid]);
+          tree_select_errLog('vxe.error.repeatKey', [nodeKeyField, nodeid]);
         }
         keyMaps[nodeid] = true;
         const value = item[valueField];
         if (nodeMaps[value]) {
-          errLog('vxe.error.repeatKey', [valueField, value]);
+          tree_select_errLog('vxe.error.repeatKey', [valueField, value]);
         }
         nodeMaps[value] = {
           item,
@@ -50044,7 +50697,7 @@ function tree_select_createInternalData() {
     cacheLazyDataMap();
     (0,external_commonjs_vue_commonjs2_vue_root_Vue_.onMounted)(() => {
       if (external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().isBoolean(props.autoClose)) {
-        warnLog('vxe.error.delProp', ['auto-close', 'checked-closable | clear-closable']);
+        tree_select_warnLog('vxe.error.delProp', ['auto-close', 'checked-closable | clear-closable']);
       }
       globalEvents.on($xeTreeSelect, 'mousewheel', handleGlobalMousewheelEvent);
       globalEvents.on($xeTreeSelect, 'mousedown', handleGlobalMousedownEvent);
@@ -50222,6 +50875,10 @@ const saveLocalFile = options => {
 
 
 
+const {
+  warnLog: upload_warnLog,
+  errLog: upload_errLog
+} = createComponentLog('upload');
 function upload_createReactData() {
   return {
     isDragUploadStatus: false,
@@ -50422,7 +51079,7 @@ function upload_createInternalData() {
       default: () => getConfig().upload.size || getConfig().size
     }
   },
-  emits: ['update:modelValue', 'add', 'remove', 'remove-fail', 'download', 'download-fail', 'upload-success', 'upload-error', 'sort-dragend', 'more-visible'],
+  emits: ['update:modelValue', 'add', 'remove', 'remove-fail', 'download', 'download-fail', 'upload-start', 'upload-success', 'upload-error', 'upload-end', 'upload-queue-start', 'upload-queue-end', 'sort-dragend', 'more-visible'],
   setup(props, context) {
     const {
       emit,
@@ -50803,6 +51460,9 @@ function upload_createInternalData() {
       const fileKey = getFieldKey(item);
       const uploadFn = props.uploadMethod || getConfig().upload.uploadMethod;
       if (uploadFn) {
+        dispatchEvent('upload-start', {
+          option: item
+        }, null);
         return Promise.resolve(uploadFn({
           $upload: $xeUpload,
           file,
@@ -50856,6 +51516,9 @@ function upload_createInternalData() {
           if (cacheItem) {
             cacheItem.loading = false;
           }
+          dispatchEvent('upload-end', {
+            option: item
+          }, null);
         });
       } else {
         const {
@@ -50982,6 +51645,9 @@ function upload_createInternalData() {
           }
         }
       }
+      dispatchEvent('upload-queue-start', {
+        files: selectFiles
+      }, evnt);
       const cacheMaps = Object.assign({}, reactData.fileCacheMaps);
       const newFileList = multiple ? fileList : [];
       const uploadPromiseRests = [];
@@ -51025,6 +51691,10 @@ function upload_createInternalData() {
       });
       Promise.all(urlMode ? uploadPromiseRests : []).then(() => {
         const restFileList = reactData.fileList;
+        dispatchEvent('upload-queue-end', {
+          options: restFileList,
+          files: selectFiles
+        }, evnt);
         handleChange(restFileList);
         // 自动更新校验状态
         if ($xeForm && formItemInfo) {
@@ -52149,10 +52819,10 @@ function upload_createInternalData() {
     });
     (0,external_commonjs_vue_commonjs2_vue_root_Vue_.onMounted)(() => {
       if (props.multiple && props.singleMode) {
-        errLog('vxe.error.errConflicts', ['[upload] multiple', 'single-mode']);
+        upload_errLog('vxe.error.errConflicts', ['multiple', 'single-mode']);
       }
       if (props.imageStyle) {
-        warnLog('vxe.error.delProp', ['[upload] image-style', 'image-config']);
+        upload_warnLog('vxe.error.delProp', ['image-style', 'image-config']);
       }
       if (props.dragSort) {
         initTpImg();