vxe-pc-ui 3.15.1 → 3.15.3

package/lib/index.umd.js

@@ -8430,6 +8430,26 @@ fixRegExpWellKnownSymbolLogic('match', function (MATCH, nativeMatch, maybeCallNa
 });
 
 
+/***/ }),
+
+/***/ 5701:
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+
+var $ = __webpack_require__(6518);
+var $padEnd = (__webpack_require__(533).end);
+var WEBKIT_BUG = __webpack_require__(3063);
+
+// `String.prototype.padEnd` method
+// https://tc39.es/ecma262/#sec-string.prototype.padend
+$({ target: 'String', proto: true, forced: WEBKIT_BUG }, {
+  padEnd: function padEnd(maxLength /* , fillString = ' ' */) {
+    return $padEnd(this, maxLength, arguments.length > 1 ? arguments[1] : undefined);
+  }
+});
+
+
 /***/ }),
 
 /***/ 8156:
@@ -13214,7 +13234,14 @@ function checkDynamic() {
 }
 ;// ./packages/ui/src/log.ts
 
-var log_version = "ui v".concat("3.15.1");
+
+var log_version = "ui v".concat("3.15.3");
+function createComponentLog(name) {
+  return {
+    warnLog: log.create('warn', "".concat(log_version, " ").concat(name)),
+    errLog: log.create('error', "".concat(log_version, " ").concat(name))
+  };
+}
 var warnLog = log.create('warn', log_version);
 var errLog = log.create('error', log_version);
 ;// ./packages/ui/index.ts
@@ -13222,7 +13249,7 @@ var errLog = log.create('error', log_version);
 
 
 
-var ui_version = "3.15.1";
+var ui_version = "3.15.3";
 VxeUI.uiVersion = ui_version;
 VxeUI.dynamicApp = dynamicApp;
 function config(options) {
@@ -16706,6 +16733,8 @@ var Tooltip = VxeTooltip;
 
 
 
+var _createComponentLog = createComponentLog('button'),
+  button_warnLog = _createComponentLog.warnLog;
 /* harmony default export */ var src_button = (/* define-vxe-component start */defineVxeComponent({
   name: 'VxeButton',
   mixins: [globalMixins.sizeMixin, globalMixins.permissionMixin],
@@ -17535,7 +17564,7 @@ var Tooltip = VxeTooltip;
     var $xeButton = this;
     var props = $xeButton;
     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', $xeButton.handleGlobalMousewheelEvent);
     globalEvents.on($xeButton, 'mousedown', $xeButton.handleGlobalMousedownEvent);
@@ -17584,6 +17613,8 @@ var Button = VxeButton;
 
 
 
+var backtop_createComponentLog = createComponentLog('backtop'),
+  backtop_errLog = backtop_createComponentLog.errLog;
 function createInternalData() {
   return {
     targetEl: null
@@ -17693,13 +17724,11 @@ function createReactData() {
   },
   data: function data() {
     var xID = external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().uniqueId();
-    var internalData = createInternalData();
     var reactData = createReactData();
-    return {
+    return _objectSpread2(_objectSpread2({}, {}), {}, {
       xID: xID,
-      internalData: internalData,
       reactData: reactData
-    };
+    });
   },
   computed: _objectSpread2(_objectSpread2({}, {}), {}, {
     computeWrapperStyle: function computeWrapperStyle() {
@@ -17817,13 +17846,13 @@ function createReactData() {
         var target = props.target;
         if (!target) {
           $xeBacktop.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)) {
           var tEl = document.querySelector(target);
           if (!tEl) {
-            errLog('vxe.error.errProp', ["target=".concat(target), 'body']);
+            backtop_errLog('vxe.error.errProp', ["target=".concat(target), 'body']);
           }
           var targetEl = internalData.targetEl;
           if (targetEl !== tEl) {
@@ -17887,6 +17916,10 @@ function createReactData() {
       }, bottomSlot({})) : renderEmptyElement($xeBacktop)]);
     }
   },
+  created: function created() {
+    var $xeBacktop = this;
+    $xeBacktop.internalData = createInternalData();
+  },
   mounted: function mounted() {
     var $xeBacktop = this;
     var props = $xeBacktop;
@@ -18361,6 +18394,24 @@ var ButtonGroup = VxeButtonGroup;
 
 
 
+function getChunkDefaultNum(selectKey) {
+  var 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';
 }
@@ -18437,10 +18488,10 @@ var parseDateValue = function parseDateValue(val, type, options) {
   }
   return null;
 };
-var parseDateString = function parseDateString(val, type, options) {
+function parseDateString(val, type, options) {
   var dValue = parseDateValue(val, type, options);
   return dValue ? external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().toDateString(dValue, options.valueFormat) : '';
-};
+}
 function parseDateObj(val, type, options) {
   var labelFormat = options.labelFormat,
     firstDay = options.firstDay;
@@ -18582,9 +18633,20 @@ function getRangeDateByCode(code, val, type, options) {
 /**
  * 判断周的年份是否跨年
  */
-var checkWeekOfsetYear = function checkWeekOfsetYear(W, M) {
+function checkWeekOfsetYear(W, M) {
   return "".concat(W) === '1' && "".concat(M) === '12';
-};
+}
+function isAllSameChar(str, char) {
+  if (str.length === 0) {
+    return false;
+  }
+  for (var i = 0; i < str.length; i++) {
+    if (str[i] !== char) {
+      return false;
+    }
+  }
+  return true;
+}
 ;// ./packages/calendar/src/calendar.ts
 
 
@@ -18613,6 +18675,8 @@ var checkWeekOfsetYear = function checkWeekOfsetYear(W, M) {
 
 
 
+var calendar_createComponentLog = createComponentLog('calendar'),
+  calendar_errLog = calendar_createComponentLog.errLog;
 var calendar_menus = VxeUI.menus,
   calendar_getConfig = VxeUI.getConfig,
   calendar_getI18n = VxeUI.getI18n;
@@ -20146,7 +20210,7 @@ var calendar_menus = VxeUI.menus,
     var menuConfig = props.menuConfig;
     var VxeUIContextMenu = VxeUI.getComponent('VxeContextMenu');
     if (menuConfig && !VxeUIContextMenu) {
-      errLog('vxe.error.reqComp', ['vxe-context-menu']);
+      calendar_errLog('vxe.error.reqComp', ['vxe-context-menu']);
     }
     $xeCalendar.dateOpenPanel();
   },
@@ -21159,12 +21223,10 @@ function list_createInternalData() {
   data: function data() {
     var xID = external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().uniqueId();
     var reactData = list_createReactData();
-    var internalData = list_createInternalData();
-    return {
+    return _objectSpread2(_objectSpread2({}, {}), {}, {
       xID: xID,
-      reactData: reactData,
-      internalData: internalData
-    };
+      reactData: reactData
+    });
   },
   computed: _objectSpread2(_objectSpread2({}, {}), {}, {
     computeSYOpts: function computeSYOpts() {
@@ -21535,6 +21597,7 @@ function list_createInternalData() {
   created: function created() {
     var $xeList = this;
     var props = $xeList;
+    $xeList.internalData = list_createInternalData();
     $xeList.loadData(props.data || []);
   },
   mounted: function mounted() {
@@ -21649,6 +21712,8 @@ function toFloatValueFixed(inputValue, type, digitsValue, roundingMode) {
 
 
 
+var input_createComponentLog = createComponentLog('input'),
+  input_warnLog = input_createComponentLog.warnLog;
 /* harmony default export */ var input = (/* define-vxe-component start */defineVxeComponent({
   name: 'VxeInput',
   mixins: [globalMixins.sizeMixin],
@@ -24680,11 +24745,11 @@ function toFloatValueFixed(inputValue, type, digitsValue, roundingMode) {
     var props = $xeInput;
     var type = props.type;
     if (['date', 'time', 'datetime', 'week', 'month', 'quarter', 'year'].includes(type)) {
-      warnLog('vxe.error.useNew', ["<vxe-input type=\"".concat(type, "\" ... />"), "<vxe-date-picker type=\"".concat(type, "\" ... />")]);
+      input_warnLog('vxe.error.useNew', ["<vxe-input type=\"".concat(type, "\" ... />"), "<vxe-date-picker type=\"".concat(type, "\" ... />")]);
     } else if (['number', 'integer', 'float'].includes(type)) {
-      warnLog('vxe.error.useNew', ["<vxe-input type=\"".concat(type, "\" ... />"), "<vxe-number-input type=\"".concat(type, "\" ... />")]);
+      input_warnLog('vxe.error.useNew', ["<vxe-input type=\"".concat(type, "\" ... />"), "<vxe-number-input type=\"".concat(type, "\" ... />")]);
     } else if (['password'].includes(type)) {
-      warnLog('vxe.error.useNew', ["<vxe-input type=\"".concat(type, "\" ... />"), '<vxe-password-input ... />']);
+      input_warnLog('vxe.error.useNew', ["<vxe-input type=\"".concat(type, "\" ... />"), '<vxe-password-input ... />']);
     }
     var inputElem = $xeInput.$refs.refInputTarget;
     if (inputElem) {
@@ -24752,6 +24817,8 @@ function toFloatValueFixed(inputValue, type, digitsValue, roundingMode) {
 
 
 
+var cascader_createComponentLog = createComponentLog('cascader'),
+  cascader_errLog = cascader_createComponentLog.errLog;
 /**
  * 生成节点的唯一主键
  */
@@ -24940,12 +25007,10 @@ function cascader_createInternalData() {
   data: function data() {
     var xID = external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().uniqueId();
     var reactData = cascader_createReactData();
-    var internalData = cascader_createInternalData();
-    return {
+    return _objectSpread2(_objectSpread2({}, {}), {}, {
       xID: xID,
-      reactData: reactData,
-      internalData: internalData
-    };
+      reactData: reactData
+    });
   },
   computed: _objectSpread2(_objectSpread2({}, {}), {}, {
     computeFormReadonly: function computeFormReadonly() {
@@ -26737,6 +26802,7 @@ function cascader_createInternalData() {
     var $xeCascader = this;
     var props = $xeCascader;
     var reactData = $xeCascader.reactData;
+    $xeCascader.internalData = cascader_createInternalData();
     if (!props.multiple) {
       reactData.selectRadioKey = enNodeValue(props.value);
     }
@@ -26746,7 +26812,7 @@ function cascader_createInternalData() {
     var $xeCascader = this;
     var props = $xeCascader;
     if (props.filterable) {
-      errLog('vxe.error.notProp', ['filterable']);
+      cascader_errLog('vxe.error.notProp', ['filterable']);
     }
     globalEvents.on($xeCascader, 'mousewheel', $xeCascader.handleGlobalMousewheelEvent);
     globalEvents.on($xeCascader, 'mousedown', $xeCascader.handleGlobalMousedownEvent);
@@ -27213,6 +27279,9 @@ var CheckboxButton = VxeCheckboxButton;
 
 
 
+function group_createReactData() {
+  return {};
+}
 function group_createInternalData() {
   return {
     // isLoaded: false
@@ -27261,13 +27330,11 @@ function group_createInternalData() {
     };
   },
   data: function data() {
-    var reactData = {};
-    var internalData = group_createInternalData();
-    return {
+    var reactData = group_createReactData();
+    return _objectSpread2(_objectSpread2({}, {}), {}, {
       xID: external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().uniqueId(),
-      reactData: reactData,
-      internalData: internalData
-    };
+      reactData: reactData
+    });
   },
   computed: _objectSpread2(_objectSpread2({}, {}), {}, {
     computeIsReadonly: function computeIsReadonly() {
@@ -27453,6 +27520,10 @@ function group_createInternalData() {
       $xeCheckboxGroup.loadData(val);
     }
   },
+  created: function created() {
+    var $xeCheckboxGroup = this;
+    $xeCheckboxGroup.internalData = group_createInternalData();
+  },
   mounted: function mounted() {
     var $xeCheckboxGroup = this;
     var props = $xeCheckboxGroup;
@@ -27463,6 +27534,13 @@ function group_createInternalData() {
       }
     });
   },
+  beforeDestroy: function beforeDestroy() {
+    var $xeCheckboxGroup = this;
+    var reactData = $xeCheckboxGroup.reactData;
+    var internalData = $xeCheckboxGroup.internalData;
+    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());
+  },
   render: function render(h) {
     return this.renderVN(h);
   }
@@ -28409,7 +28487,6 @@ var handleNumberString = function handleNumberString(val) {
         return getConfig().numberInput.size || getConfig().size;
       }
     },
-    // number、integer、float
     min: {
       type: [String, Number],
       default: null
@@ -28438,14 +28515,14 @@ var handleNumberString = function handleNumberString(val) {
       }
     },
     controlConfig: Object,
-    // float
+    // number、float、amount
     roundingMode: {
       type: String,
       default: function _default() {
         return getConfig().numberInput.roundingMode;
       }
     },
-    // float
+    // float、amount
     digits: {
       type: [String, Number],
       default: null
@@ -30962,13 +31039,11 @@ function closeMenu($xeContextMenu) {
     }
   },
   data: function data() {
-    var internalData = context_menu_createInternalData();
     var reactData = context_menu_createReactData();
-    return {
+    return _objectSpread2(_objectSpread2({}, {}), {}, {
       xID: external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().uniqueId(),
-      internalData: internalData,
       reactData: reactData
-    };
+    });
   },
   computed: _objectSpread2(_objectSpread2({}, {}), {}, {
     computeMenuGroups: function computeMenuGroups() {
@@ -31407,6 +31482,7 @@ function closeMenu($xeContextMenu) {
   },
   created: function created() {
     var $xeContextMenu = this;
+    $xeContextMenu.internalData = context_menu_createInternalData();
     $xeContextMenu.handleVisible();
     globalEvents.on($xeContextMenu, 'mousewheel', $xeContextMenu.handleGlobalMousewheelEvent);
     globalEvents.on($xeContextMenu, 'keydown', $xeContextMenu.handleGlobalKeydownEvent);
@@ -34080,6 +34156,8 @@ dynamicApp.use(VxeDatePanel);
 VxeUI.component(date_panel);
 var DatePanel = VxeDatePanel;
 /* harmony default export */ var packages_date_panel = (VxeDatePanel);
+// EXTERNAL MODULE: ./node_modules/core-js/modules/es.string.pad-end.js
+var es_string_pad_end = __webpack_require__(5701);
 ;// ./packages/date-picker/src/date-picker.ts
 
 
@@ -34105,6 +34183,54 @@ var DatePanel = VxeDatePanel;
 
 
 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+var date_picker_createComponentLog = createComponentLog('date-picker'),
+  date_picker_warnLog = date_picker_createComponentLog.warnLog,
+  date_picker_errLog = date_picker_createComponentLog.errLog;
+var maskedTypes = ['year', 'month', 'date', 'datetime', 'time'];
+var inputMaskedKeys = ['y', 'M', 'd', 'H', 'm', 'n', 's'];
+var parseInputKayMaps = {};
+inputMaskedKeys.forEach(function (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 = (/* define-vxe-component start */defineVxeComponent({
   name: 'VxeDatePicker',
   mixins: [globalMixins.sizeMixin],
@@ -34225,6 +34351,7 @@ var DatePanel = VxeDatePanel;
         return getConfig().datePicker.autoClose;
       }
     },
+    maskedConfig: Object,
     prefixIcon: String,
     suffixIcon: String,
     placement: String,
@@ -34264,25 +34391,11 @@ var DatePanel = VxeDatePanel;
   },
   data: function data() {
     var xID = external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().uniqueId();
-    var reactData = {
-      initialized: false,
-      panelIndex: 0,
-      visiblePanel: false,
-      isAniVisible: false,
-      panelStyle: {},
-      panelPlacement: '',
-      isActivated: false,
-      inputValue: '',
-      inputLabel: ''
-    };
-    var internalData = {
-      hpTimeout: undefined
-    };
-    return {
+    var reactData = date_picker_createReactData();
+    return _objectSpread2(_objectSpread2({}, {}), {}, {
       xID: xID,
-      reactData: reactData,
-      internalData: internalData
-    };
+      reactData: reactData
+    });
   },
   computed: _objectSpread2(_objectSpread2({}, {}), {}, {
     computeBtnTransfer: function computeBtnTransfer() {
@@ -34351,6 +34464,57 @@ var DatePanel = VxeDatePanel;
       var props = $xeDatePicker;
       return props.clearable;
     },
+    computeIsDatePanelType: function computeIsDatePanelType() {
+      var $xeDatePicker = this;
+      var props = $xeDatePicker;
+      var isDateTimeType = $xeDatePicker.computeIsDateTimeType;
+      return isDateTimeType || ['date', 'week', 'month', 'quarter', 'year'].indexOf(props.type) > -1;
+    },
+    computeDateListValue: function computeDateListValue() {
+      var $xeDatePicker = this;
+      var props = $xeDatePicker;
+      var modelValue = props.value,
+        type = props.type,
+        multiple = props.multiple;
+      var isDatePanelType = $xeDatePicker.computeIsDatePanelType;
+      var dateValueFormat = $xeDatePicker.computeDateValueFormat;
+      if (multiple && modelValue && isDatePanelType) {
+        return external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().toValueString(modelValue).split(',').map(function (item) {
+          var 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 [];
+    },
+    computeLimitMaxCount: function computeLimitMaxCount() {
+      var $xeDatePicker = this;
+      var props = $xeDatePicker;
+      return props.multiple ? external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().toNumber(props.limitCount) : 0;
+    },
+    computeDateMultipleValue: function computeDateMultipleValue() {
+      var $xeDatePicker = this;
+      var dateListValue = $xeDatePicker.computeDateListValue;
+      var dateValueFormat = $xeDatePicker.computeDateValueFormat;
+      return dateListValue.map(function (date) {
+        return external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().toDateString(date, dateValueFormat);
+      });
+    },
+    computeOverCount: function computeOverCount() {
+      var $xeDatePicker = this;
+      var props = $xeDatePicker;
+      var multiple = props.multiple;
+      var limitMaxCount = $xeDatePicker.computeLimitMaxCount;
+      var dateMultipleValue = $xeDatePicker.computeDateMultipleValue;
+      if (multiple && limitMaxCount) {
+        return dateMultipleValue.length >= limitMaxCount;
+      }
+      return false;
+    },
     computeInputReadonly: function computeInputReadonly() {
       var $xeDatePicker = this;
       var props = $xeDatePicker;
@@ -34420,6 +34584,11 @@ var DatePanel = VxeDatePanel;
         valueFormat = props.valueFormat;
       return handleValueFormat(type, valueFormat);
     },
+    computeDateMaskedFormat: function computeDateMaskedFormat() {
+      var $xeDatePicker = this;
+      var dateLabelFormat = $xeDatePicker.computeDateLabelFormat;
+      return dateLabelFormat;
+    },
     computeFirstDayOfWeek: function computeFirstDayOfWeek() {
       var $xeDatePicker = this;
       var props = $xeDatePicker;
@@ -34445,6 +34614,17 @@ var DatePanel = VxeDatePanel;
         });
         return dateObj.label;
       }).join(', ');
+    },
+    computeMaskedOpts: function computeMaskedOpts() {
+      var $xeDatePicker = this;
+      var props = $xeDatePicker;
+      return Object.assign({}, getConfig().datePicker.maskedConfig, props.maskedConfig);
+    },
+    computeMaskChar: function computeMaskChar() {
+      var $xeDatePicker = this;
+      var maskedOpts = $xeDatePicker.computeMaskedOpts;
+      var maskPlaceholder = maskedOpts.maskPlaceholder;
+      return (maskPlaceholder ? ('' + maskPlaceholder)[0] : '') || '*';
     }
   }),
   methods: {
@@ -34481,6 +34661,15 @@ var DatePanel = VxeDatePanel;
       }
       reactData.inputValue = val;
     },
+    handleInputLabel: function handleInputLabel(text, isUpdate) {
+      var $xeDatePicker = this;
+      var reactData = $xeDatePicker.reactData;
+      var internalData = $xeDatePicker.internalData;
+      internalData.inputLabel = text;
+      if (isUpdate) {
+        reactData.labelFlag++;
+      }
+    },
     triggerEvent: function triggerEvent(evnt) {
       var $xeDatePicker = this;
       var reactData = $xeDatePicker.reactData;
@@ -34544,10 +34733,9 @@ var DatePanel = VxeDatePanel;
     },
     inputEvent: function inputEvent(evnt) {
       var $xeDatePicker = this;
-      var reactData = $xeDatePicker.reactData;
       var inputElem = evnt.target;
       var value = inputElem.value;
-      reactData.inputLabel = value;
+      $xeDatePicker.handleInputLabel(value, true);
       $xeDatePicker.dispatchEvent('input', {
         value: value
       }, evnt);
@@ -34559,17 +34747,6 @@ var DatePanel = VxeDatePanel;
         $xeDatePicker.triggerEvent(evnt);
       }
     },
-    focusEvent: function focusEvent(evnt) {
-      var $xeDatePicker = this;
-      var reactData = $xeDatePicker.reactData;
-      var popupOpts = $xeDatePicker.computePopupOpts;
-      var trigger = popupOpts.trigger;
-      reactData.isActivated = true;
-      if (!trigger || trigger === 'default') {
-        $xeDatePicker.datePickerOpenEvent(evnt);
-      }
-      $xeDatePicker.triggerEvent(evnt);
-    },
     clickPrefixEvent: function clickPrefixEvent(evnt) {
       var $xeDatePicker = this;
       var reactData = $xeDatePicker.reactData;
@@ -34593,6 +34770,134 @@ var DatePanel = VxeDatePanel;
         }, 350);
       });
     },
+    dateChange: function dateChange(date, isReload) {
+      var $xeDatePicker = this;
+      var props = $xeDatePicker;
+      var modelValue = props.value,
+        multiple = props.multiple;
+      var isDateTimeType = $xeDatePicker.computeIsDateTimeType;
+      var dateValueFormat = $xeDatePicker.computeDateValueFormat;
+      var firstDayOfWeek = $xeDatePicker.computeFirstDayOfWeek;
+      if (props.type === 'week') {
+        var 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);
+      }
+      var inpVal = external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().toDateString(date, dateValueFormat, {
+        firstDay: firstDayOfWeek
+      });
+      if (multiple) {
+        var overCount = $xeDatePicker.computeOverCount;
+        // 如果为多选
+        if (isDateTimeType) {
+          // 如果是datetime特殊类型
+          var dateListValue = isReload ? [] : _toConsumableArray($xeDatePicker.computeDateListValue);
+          var datetimeRest = [];
+          var eqIndex = external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().findIndexOf(dateListValue, function (val) {
+            return 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(function (item) {
+            if (item) {
+              datetimeRest.push(item);
+            }
+          });
+          $xeDatePicker.handleChange(datetimeRest.map(function (date) {
+            return external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().toDateString(date, dateValueFormat);
+          }).join(','), {
+            type: 'update'
+          });
+        } else {
+          var dateMultipleValue = isReload ? [] : $xeDatePicker.computeDateMultipleValue;
+          // 如果是日期类型
+          if (dateMultipleValue.some(function (val) {
+            return external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().isEqual(val, inpVal);
+          })) {
+            $xeDatePicker.handleChange(dateMultipleValue.filter(function (val) {
+              return !external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().isEqual(val, inpVal);
+            }).join(','), {
+              type: 'update'
+            });
+          } else {
+            if (overCount) {
+              // 如果超出最大多选数量
+              return;
+            }
+            $xeDatePicker.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)) {
+          $xeDatePicker.handleChange(inpVal, {
+            type: 'update'
+          });
+        }
+      }
+    },
+    dateRevert: function dateRevert() {
+      var $xeDatePicker = this;
+      var panelLabel = $xeDatePicker.computePanelLabel;
+      $xeDatePicker.handleInputLabel(panelLabel, true);
+    },
+    afterCheckValue: function afterCheckValue(inpVal) {
+      var $xeDatePicker = this;
+      var props = $xeDatePicker;
+      var reactData = $xeDatePicker.reactData;
+      var internalData = $xeDatePicker.internalData;
+      var type = props.type;
+      var inputLabel = internalData.inputLabel;
+      var dateLabelFormat = $xeDatePicker.computeDateLabelFormat;
+      if (!inpVal) {
+        $xeDatePicker.handleChange('', {
+          type: 'check'
+        });
+        return;
+      }
+      var inpDateVal = parseDateValue(inpVal, type, {
+        valueFormat: dateLabelFormat
+      });
+      if (!external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().isValidDate(inpDateVal)) {
+        $xeDatePicker.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) {
+          $xeDatePicker.handleChange(inpDateVal, {
+            type: 'check'
+          });
+        }
+        $xeDatePicker.handleInputLabel(inpDateVal, true);
+        return;
+      }
+      var isChange = false;
+      var firstDayOfWeek = $xeDatePicker.computeFirstDayOfWeek;
+      if (type === 'datetime') {
+        var 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;
+      }
+      var label = external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().toDateString(inpDateVal, dateLabelFormat, {
+        firstDay: firstDayOfWeek
+      });
+      $xeDatePicker.handleInputLabel(label, true);
+      if (isChange) {
+        $xeDatePicker.dateChange(inpDateVal);
+      }
+    },
     clearValueEvent: function clearValueEvent(evnt, value) {
       var $xeDatePicker = this;
       var isDatePickerType = $xeDatePicker.computeIsDatePickerType;
@@ -34615,9 +34920,322 @@ var DatePanel = VxeDatePanel;
         }, evnt);
       }
     },
+    handleArrowInputDate: function handleArrowInputDate(evnt, isUpArrow, isDwArrow, isLtArrow, isRtArrow) {
+      var $xeDatePicker = this;
+      var props = $xeDatePicker;
+      var internalData = $xeDatePicker.internalData;
+      var type = props.type,
+        multiple = props.multiple;
+      if (multiple) {
+        return;
+      }
+      var targetElem = $xeDatePicker.$refs.refInputTarget;
+      if (!targetElem) {
+        return;
+      }
+      var inpValue = targetElem.value;
+      if (!inpValue) {
+        return;
+      }
+      var dateMaskedFormat = $xeDatePicker.computeDateMaskedFormat;
+      var dateLabelFormat = $xeDatePicker.computeDateLabelFormat;
+      var firstDayOfWeek = $xeDatePicker.computeFirstDayOfWeek;
+      var maskChar = $xeDatePicker.computeMaskChar;
+      var selectionStart = targetElem.selectionStart || 0;
+      var selectKey = dateMaskedFormat[selectionStart];
+      if (!parseInputKayMaps[selectKey]) {
+        selectKey = dateMaskedFormat[selectionStart - 1];
+      }
+      var skRest = dateMaskedFormat.match(new RegExp(selectKey + '+'));
+      if (!skRest) {
+        return;
+      }
+      if (isUpArrow || isDwArrow) {
+        var chunkFormat = skRest[0] || '';
+        var chunkStartIndex = skRest.index || 0;
+        var chunkEndIndex = chunkStartIndex + chunkFormat.length;
+        var chunkValue = inpValue.slice(chunkStartIndex, chunkEndIndex);
+        if (parseInputKayMaps[selectKey]) {
+          var chunkNum = (isAllSameChar(chunkValue, maskChar) ? getChunkDefaultNum(selectKey) : external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().toNumber(chunkValue)) + (isUpArrow ? 1 : -1);
+          var 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) {
+            // 解析日期
+            var inpDateVal = parseDateValue(restValue, type, {
+              valueFormat: dateLabelFormat
+            });
+            if (external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().isValidDate(inpDateVal)) {
+              var label = external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().toDateString(inpDateVal, dateLabelFormat, {
+                firstDay: firstDayOfWeek
+              });
+              targetElem.value = label;
+              $xeDatePicker.handleInputLabel(label, false);
+            }
+          } else {
+            targetElem.value = restValue;
+            $xeDatePicker.handleInputLabel(restValue, false);
+          }
+        }
+        targetElem.setSelectionRange(chunkStartIndex, chunkEndIndex);
+      } else if (isLtArrow || isRtArrow) {
+        var currKeyIndex = inputMaskedKeys.indexOf(selectKey);
+        if (currKeyIndex > -1) {
+          var allMaskedKeys = external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().map(dateMaskedFormat.match(new RegExp("(".concat(inputMaskedKeys.join('|'), ")+"), 'g')) || [], function (fullKey) {
+            return fullKey[0];
+          });
+          var currIndex = external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().findIndexOf(allMaskedKeys, function (key) {
+            return selectKey === key[0];
+          });
+          var targetFormatKey = isLtArrow ? allMaskedKeys[currIndex - 1] || allMaskedKeys[0] : allMaskedKeys[currIndex + 1] || allMaskedKeys[allMaskedKeys.length - 1];
+          var targetKey = targetFormatKey ? targetFormatKey[0] : '';
+          var sktRest = dateMaskedFormat.match(new RegExp(targetKey + '+'));
+          if (sktRest) {
+            evnt.preventDefault();
+            var mtStartIndex = sktRest.index || 0;
+            var mtEndIndex = mtStartIndex + sktRest[0].length;
+            targetElem.setSelectionRange(mtStartIndex, mtEndIndex);
+          }
+        }
+      }
+      internalData.isTriggerMasked = true;
+    },
+    handleMaskedInputDate: function handleMaskedInputDate(evnt) {
+      var $xeDatePicker = this;
+      var props = $xeDatePicker;
+      var internalData = $xeDatePicker.internalData;
+      var multiple = props.multiple;
+      if (multiple) {
+        return;
+      }
+      var targetElem = $xeDatePicker.$refs.refInputTarget;
+      if (!targetElem) {
+        return;
+      }
+      var isControlKey = hasControlKey(evnt);
+      if (isControlKey) {
+        return;
+      }
+      evnt.preventDefault();
+      var eKey = evnt.key;
+      var isDeleleKey = globalEvents.hasKey(evnt, GLOBAL_EVENT_KEYS.DELETE);
+      var isBackspaceKey = globalEvents.hasKey(evnt, GLOBAL_EVENT_KEYS.BACKSPACE);
+      var isNumKey = eKey >= '0' && eKey <= '9';
+      var numKey = isNumKey ? evnt.key : '';
+      if (!(isDeleleKey || isBackspaceKey || isNumKey)) {
+        return;
+      }
+      var isTriggerMasked = internalData.isTriggerMasked;
+      var dateMaskedFormat = $xeDatePicker.computeDateMaskedFormat;
+      var maskChar = $xeDatePicker.computeMaskChar;
+      var inpValue = targetElem.value || dateMaskedFormat;
+      var selectionStart = targetElem.selectionStart || 0;
+      var selectionEnd = targetElem.selectionEnd || 0;
+      var selectKey = dateMaskedFormat[selectionStart];
+      if (!parseInputKayMaps[selectKey]) {
+        selectKey = dateMaskedFormat[selectionStart - 1];
+      }
+      var skRest = dateMaskedFormat.match(new RegExp(selectKey + '+'));
+      if (!skRest) {
+        return;
+      }
+      var allMaskedKeys = external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().map(dateMaskedFormat.match(new RegExp("(".concat(inputMaskedKeys.join('|'), ")+"), 'g')) || [], function (fullKey) {
+        return fullKey[0];
+      });
+      var chunkFormat = skRest[0] || '';
+      var chunkStartIndex = skRest.index || 0;
+      var chunkEndIndex = chunkStartIndex + chunkFormat.length;
+      var currKeyIndex = allMaskedKeys.indexOf(selectKey);
+      // 全选 | 如果无效字符
+      var isAllSelected = !selectionStart && selectionEnd === inpValue.length;
+      var isNotMasked = inpValue && inpValue.length !== dateMaskedFormat.length;
+      if (isAllSelected || isNotMasked) {
+        inpValue = dateMaskedFormat;
+      }
+      var chunkValue = isDeleleKey ? '' : inpValue.slice(chunkStartIndex, chunkEndIndex);
+      var chunkNums = chunkValue.match(/\d/g) || [];
+      var chunkNumList = isTriggerMasked && !isBackspaceKey ? [] : chunkNums.slice(0);
+      if (isNumKey) {
+        chunkNumList.push(numKey);
+      } else if (isBackspaceKey) {
+        chunkNumList.pop();
+      }
+      chunkValue = chunkNumList.join('').padEnd(chunkFormat.length, maskChar);
+      var restValue = inpValue.slice(0, chunkStartIndex) + chunkValue + inpValue.slice(chunkEndIndex);
+      restValue = restValue.replace(new RegExp("(".concat(inputMaskedKeys.join('|'), ")"), 'g'), maskChar);
+      targetElem.value = restValue;
+      $xeDatePicker.handleInputLabel(restValue, false);
+      // 如果是全选/删除
+      if (isAllSelected) {
+        if (isBackspaceKey || isDeleleKey) {
+          var firstMaskedKeys = allMaskedKeys[0];
+          var firstSkRest = dateMaskedFormat.match(new RegExp("".concat(firstMaskedKeys, "+")));
+          if (firstSkRest) {
+            var firstChunkFormat = firstSkRest[0];
+            targetElem.setSelectionRange(0, firstChunkFormat.length);
+            internalData.isTriggerMasked = true;
+            return;
+          }
+        }
+      } else {
+        if (isBackspaceKey && !chunkNums.length) {
+          // 回退到上一个数字块
+          for (var i = currKeyIndex - 1; i >= 0; i--) {
+            var prveChunkKey = allMaskedKeys[i];
+            var prveSkRest = dateMaskedFormat.match(new RegExp("".concat(prveChunkKey, "+")));
+            if (prveSkRest) {
+              var prveChunkFormat = prveSkRest[0];
+              var prveChunkStartIndex = prveSkRest.index || 0;
+              var prveChunkEndIndex = prveChunkStartIndex + prveChunkFormat.length;
+              var prveChunkValue = restValue.slice(prveChunkStartIndex, prveChunkEndIndex);
+              var 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;
+                $xeDatePicker.handleInputLabel(restValue, false);
+                targetElem.setSelectionRange(prveChunkStartIndex, prveChunkEndIndex);
+                return;
+              }
+            }
+          }
+          var _firstMaskedKeys = allMaskedKeys[0];
+          var _firstSkRest = dateMaskedFormat.match(new RegExp("".concat(_firstMaskedKeys, "+")));
+          if (_firstSkRest) {
+            var _firstChunkFormat = _firstSkRest[0];
+            restValue = dateMaskedFormat.replace(new RegExp("(".concat(inputMaskedKeys.join('|'), ")"), 'g'), maskChar);
+            targetElem.value = restValue;
+            $xeDatePicker.handleInputLabel(restValue, false);
+            targetElem.setSelectionRange(0, _firstChunkFormat.length);
+            internalData.isTriggerMasked = true;
+            return;
+          }
+          return;
+        }
+      }
+      var maskStartIndex = skRest.index || 0;
+      var maskEndIndex = maskStartIndex + skRest[0].length;
+      // 如果输入完成，跳转下一个
+      if (chunkNumList.length >= chunkValue.length) {
+        var nextKeys = allMaskedKeys.slice(currKeyIndex + 1);
+        if (currKeyIndex > -1) {
+          var nextRest = nextKeys.length ? dateMaskedFormat.match(new RegExp("(".concat(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;
+    },
+    handleMaskedSelectedDate: function handleMaskedSelectedDate(evnt, isFocus) {
+      var $xeDatePicker = this;
+      var props = $xeDatePicker;
+      var internalData = $xeDatePicker.internalData;
+      var type = props.type,
+        multiple = props.multiple,
+        modelValue = props.value;
+      if (multiple) {
+        return;
+      }
+      if (!maskedTypes.includes(type)) {
+        return;
+      }
+      var targetElem = $xeDatePicker.$refs.refInputTarget;
+      if (!targetElem) {
+        return;
+      }
+      var laseFocusMasked = internalData.laseFocusMasked;
+      if (laseFocusMasked && Date.now() - laseFocusMasked < 100) {
+        return;
+      }
+      var dateMaskedFormat = $xeDatePicker.computeDateMaskedFormat;
+      var maskChar = $xeDatePicker.computeMaskChar;
+      var selectionStart = targetElem.selectionStart || 0;
+      var selectionEnd = targetElem.selectionEnd || 0;
+      var inpValue = targetElem.value;
+      var allMaskedKeys = external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().map(dateMaskedFormat.match(new RegExp("(".concat(inputMaskedKeys.join('|'), ")+"), 'g')) || [], function (fullKey) {
+        return fullKey[0];
+      });
+      // 如果为空
+      if (!inpValue) {
+        var restValue = dateMaskedFormat.replace(new RegExp("(".concat(inputMaskedKeys.join('|'), ")"), 'g'), maskChar);
+        // 还原值
+        if (isFocus && modelValue) {
+          var chunkNums = ('' + external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().toNumber(modelValue)).match(/\d/g) || [];
+          var useNumIndex = 0;
+          restValue = dateMaskedFormat.replace(new RegExp("(".concat(inputMaskedKeys.join('|'), ")"), 'g'), function (txt) {
+            return chunkNums[useNumIndex++] || txt;
+          });
+        }
+        var firstMaskedKeys = allMaskedKeys[0];
+        var firstSkRest = dateMaskedFormat.match(new RegExp("".concat(firstMaskedKeys, "+")));
+        if (firstSkRest) {
+          evnt.preventDefault();
+          var firstChunkFormat = firstSkRest[0];
+          targetElem.value = restValue;
+          $xeDatePicker.handleInputLabel(restValue, false);
+          targetElem.setSelectionRange(0, firstChunkFormat.length);
+          internalData.laseFocusMasked = Date.now();
+          return;
+        }
+      }
+      // 全选 | 如果无效字符
+      var isAllSelected = !selectionStart && selectionEnd === inpValue.length;
+      var isNotMasked = inpValue && inpValue.length !== dateMaskedFormat.length;
+      if (isAllSelected || isNotMasked) {
+        var _restValue = '';
+        // 还原值
+        if (isNotMasked && inpValue) {
+          var _chunkNums = inpValue.match(/\d/g) || [];
+          var _useNumIndex = 0;
+          _restValue = dateMaskedFormat.replace(new RegExp("(".concat(inputMaskedKeys.join('|'), ")"), 'g'), function () {
+            return _chunkNums[_useNumIndex++] || maskChar;
+          });
+        } else {
+          dateMaskedFormat.replace(new RegExp("(".concat(inputMaskedKeys.join('|'), ")"), 'g'), maskChar);
+        }
+        var _firstMaskedKeys2 = allMaskedKeys[0];
+        var _firstSkRest2 = dateMaskedFormat.match(new RegExp("".concat(_firstMaskedKeys2, "+")));
+        if (_firstSkRest2) {
+          evnt.preventDefault();
+          var _firstChunkFormat2 = _firstSkRest2[0];
+          targetElem.value = _restValue;
+          $xeDatePicker.handleInputLabel(_restValue, false);
+          targetElem.setSelectionRange(0, _firstChunkFormat2.length);
+          internalData.laseFocusMasked = Date.now();
+          return;
+        }
+      }
+      // 是否选择数字块
+      var selectKey = dateMaskedFormat[selectionStart];
+      if (!parseInputKayMaps[selectKey]) {
+        selectKey = dateMaskedFormat[selectionStart - 1];
+      }
+      if (selectKey) {
+        evnt.preventDefault();
+        var skRest = dateMaskedFormat.match(new RegExp(selectKey + '+'));
+        if (skRest) {
+          var chunkFormat = skRest[0] || '';
+          var chunkStartIndex = skRest.index || 0;
+          var chunkEndIndex = chunkStartIndex + chunkFormat.length;
+          targetElem.setSelectionRange(chunkStartIndex, chunkEndIndex);
+          internalData.isTriggerMasked = true;
+          internalData.laseFocusMasked = Date.now();
+        }
+      }
+    },
     blurEvent: function blurEvent(evnt) {
       var $xeDatePicker = this;
       var reactData = $xeDatePicker.reactData;
+      var internalData = $xeDatePicker.internalData;
       var $xeForm = $xeDatePicker.$xeForm;
       var formItemInfo = $xeDatePicker.formItemInfo;
       var $datePanel = $xeDatePicker.$refs.refDatePanel;
@@ -34628,10 +35246,13 @@ var DatePanel = VxeDatePanel;
         $xeDatePicker.handleChange(value, evnt);
       }
       if (!reactData.visiblePanel) {
+        var inputLabel = internalData.inputLabel;
         reactData.isActivated = false;
         // 未打开面板时才校验
         if ($datePanel) {
-          $datePanel.checkValue(reactData.inputLabel);
+          $datePanel.checkValue(inputLabel);
+        } else {
+          $xeDatePicker.afterCheckValue(inputLabel);
         }
       }
       $xeDatePicker.dispatchEvent('blur', {
@@ -34642,8 +35263,90 @@ var DatePanel = VxeDatePanel;
         $xeForm.triggerItemEvent(evnt, formItemInfo.itemConfig.field, value);
       }
     },
+    focusEvent: function focusEvent(evnt) {
+      var $xeDatePicker = this;
+      var props = $xeDatePicker;
+      var reactData = $xeDatePicker.reactData;
+      var multiple = props.multiple,
+        editable = props.editable,
+        maskedConfig = props.maskedConfig;
+      var maskedOpts = $xeDatePicker.computeMaskedOpts;
+      var popupOpts = $xeDatePicker.computePopupOpts;
+      var trigger = popupOpts.trigger;
+      reactData.isActivated = true;
+      if (!trigger || trigger === 'default') {
+        $xeDatePicker.datePickerOpenEvent(evnt);
+        setTimeout(function () {
+          if (editable && !multiple && (isEnableConf(maskedConfig) || maskedOpts.enabled)) {
+            $xeDatePicker.handleMaskedSelectedDate(evnt, true);
+          }
+        }, 15);
+      } else if (trigger === 'icon') {
+        $xeDatePicker.hidePanel();
+        setTimeout(function () {
+          if (editable && !multiple && (isEnableConf(maskedConfig) || maskedOpts.enabled)) {
+            $xeDatePicker.handleMaskedSelectedDate(evnt, true);
+          }
+        }, 15);
+      } else {
+        if (editable && !multiple && (isEnableConf(maskedConfig) || maskedOpts.enabled)) {
+          $xeDatePicker.handleMaskedSelectedDate(evnt, true);
+        }
+      }
+      $xeDatePicker.triggerEvent(evnt);
+    },
+    clickEvent: function clickEvent(evnt) {
+      var $xeDatePicker = this;
+      var props = $xeDatePicker;
+      var editable = props.editable,
+        maskedConfig = props.maskedConfig;
+      var maskedOpts = $xeDatePicker.computeMaskedOpts;
+      if (editable && (isEnableConf(maskedConfig) || maskedOpts.enabled)) {
+        $xeDatePicker.handleMaskedSelectedDate(evnt);
+      }
+      $xeDatePicker.triggerEvent(evnt);
+    },
     keydownEvent: function keydownEvent(evnt) {
       var $xeDatePicker = this;
+      var props = $xeDatePicker;
+      var reactData = $xeDatePicker.reactData;
+      var internalData = $xeDatePicker.internalData;
+      var type = props.type,
+        editable = props.editable,
+        maskedConfig = props.maskedConfig;
+      var visiblePanel = reactData.visiblePanel;
+      var maskedOpts = $xeDatePicker.computeMaskedOpts;
+      var isUpArrow = globalEvents.hasKey(evnt, GLOBAL_EVENT_KEYS.ARROW_UP);
+      var isDwArrow = globalEvents.hasKey(evnt, GLOBAL_EVENT_KEYS.ARROW_DOWN);
+      var isLtArrow = globalEvents.hasKey(evnt, GLOBAL_EVENT_KEYS.ARROW_LEFT);
+      var isRtArrow = globalEvents.hasKey(evnt, GLOBAL_EVENT_KEYS.ARROW_RIGHT);
+      var isEnter = globalEvents.hasKey(evnt, GLOBAL_EVENT_KEYS.ENTER);
+      if (editable) {
+        if (isEnter) {
+          var $datePanel = $xeDatePicker.$refs.refDatePanel;
+          var inputLabel = internalData.inputLabel;
+          var targetElem = $xeDatePicker.$refs.refInputTarget;
+          if (visiblePanel) {
+            $xeDatePicker.hidePanel();
+          }
+          if ($datePanel) {
+            $datePanel.checkValue(inputLabel);
+          } else {
+            $xeDatePicker.afterCheckValue(inputLabel);
+          }
+          if (targetElem) {
+            targetElem.blur();
+          }
+        } else if (maskedTypes.includes(type)) {
+          if (isEnableConf(maskedConfig) || maskedOpts.enabled) {
+            if (maskedOpts.isArrow && (isUpArrow || isDwArrow || isLtArrow || isRtArrow)) {
+              $xeDatePicker.handleArrowInputDate(evnt, isUpArrow, isDwArrow, isLtArrow, isRtArrow);
+            } else if (maskedOpts.isMasked) {
+              $xeDatePicker.handleMaskedInputDate(evnt);
+            }
+          }
+        }
+      }
       $xeDatePicker.triggerEvent(evnt);
     },
     keyupEvent: function keyupEvent(evnt) {
@@ -34679,13 +35382,13 @@ var DatePanel = VxeDatePanel;
     },
     panelRevertEvent: function panelRevertEvent(params) {
       var $xeDatePicker = this;
-      var reactData = $xeDatePicker.reactData;
-      reactData.inputLabel = params.label;
+      $xeDatePicker.handleInputLabel(params.label, true);
     },
     // 全局事件
     handleGlobalMousedownEvent: function handleGlobalMousedownEvent(evnt) {
       var $xeDatePicker = this;
       var reactData = $xeDatePicker.reactData;
+      var internalData = $xeDatePicker.internalData;
       var $datePanel = $xeDatePicker.$refs.refDatePanel;
       var visiblePanel = reactData.visiblePanel,
         isActivated = reactData.isActivated;
@@ -34693,12 +35396,18 @@ var DatePanel = VxeDatePanel;
       var panelWrapperElem = $xeDatePicker.$refs.refPanelWrapper;
       var isDisabled = $xeDatePicker.computeIsDisabled;
       if (!isDisabled && isActivated) {
-        reactData.isActivated = getEventTargetNode(evnt, el).flag || getEventTargetNode(evnt, panelWrapperElem).flag;
-        if (!reactData.isActivated) {
+        var currActivated = getEventTargetNode(evnt, el).flag || getEventTargetNode(evnt, panelWrapperElem).flag;
+        if (currActivated !== isActivated) {
+          reactData.isActivated = currActivated;
+        }
+        if (!currActivated) {
           if (visiblePanel) {
             $xeDatePicker.hidePanel();
+            var inputLabel = internalData.inputLabel;
             if ($datePanel) {
-              $datePanel.checkValue(reactData.inputLabel);
+              $datePanel.checkValue(inputLabel);
+            } else {
+              $xeDatePicker.afterCheckValue(inputLabel);
             }
           }
         }
@@ -34741,6 +35450,7 @@ var DatePanel = VxeDatePanel;
     handleGlobalBlurEvent: function handleGlobalBlurEvent() {
       var $xeDatePicker = this;
       var reactData = $xeDatePicker.reactData;
+      var internalData = $xeDatePicker.internalData;
       var $datePanel = $xeDatePicker.$refs.refDatePanel;
       var isActivated = reactData.isActivated,
         visiblePanel = reactData.visiblePanel;
@@ -34752,7 +35462,7 @@ var DatePanel = VxeDatePanel;
       }
       if (visiblePanel || isActivated) {
         if ($datePanel) {
-          $datePanel.checkValue(reactData.inputLabel);
+          $datePanel.checkValue(internalData.inputLabel);
         }
         var targetElem = $xeDatePicker.$refs.refInputTarget;
         if (targetElem) {
@@ -34789,6 +35499,9 @@ var DatePanel = VxeDatePanel;
       var panelIndex = reactData.panelIndex;
       var targetElem = $xeDatePicker.$refs.refInputTarget;
       var panelElem = $xeDatePicker.$refs.refInputPanel;
+      if (!panelElem) {
+        return $xeDatePicker.$nextTick();
+      }
       var btnTransfer = $xeDatePicker.computeBtnTransfer;
       var popupOpts = $xeDatePicker.computePopupOpts;
       var handleStyle = function handleStyle() {
@@ -34817,10 +35530,8 @@ var DatePanel = VxeDatePanel;
       if (!isDisabled && !visiblePanel) {
         if (!reactData.initialized) {
           reactData.initialized = true;
-          if (btnTransfer) {
-            if (panelElem) {
-              document.body.appendChild(panelElem);
-            }
+          if (btnTransfer && panelElem) {
+            document.body.appendChild(panelElem);
           }
         }
         if (internalData.hpTimeout) {
@@ -34848,16 +35559,18 @@ var DatePanel = VxeDatePanel;
     },
     clickIconEvent: function clickIconEvent(evnt) {
       var $xeDatePicker = this;
+      var reactData = $xeDatePicker.reactData;
+      var visiblePanel = reactData.visiblePanel;
       var popupOpts = $xeDatePicker.computePopupOpts;
       var trigger = popupOpts.trigger;
       if (!trigger || trigger === 'default' || trigger === 'icon') {
-        $xeDatePicker.datePickerOpenEvent(evnt);
+        if (visiblePanel) {
+          $xeDatePicker.hidePanel();
+        } else {
+          $xeDatePicker.datePickerOpenEvent(evnt);
+        }
       }
     },
-    clickEvent: function clickEvent(evnt) {
-      var $xeDatePicker = this;
-      $xeDatePicker.triggerEvent(evnt);
-    },
     handleShortcutEvent: function handleShortcutEvent(_ref) {
       var option = _ref.option,
         $event = _ref.$event;
@@ -34902,7 +35615,7 @@ var DatePanel = VxeDatePanel;
                 break;
               }
             default:
-              errLog('vxe.error.notCommands', ["[date-picker] ".concat(code)]);
+              date_picker_errLog('vxe.error.notCommands', [code]);
               break;
           }
         }
@@ -34983,6 +35696,10 @@ var DatePanel = VxeDatePanel;
       var props = $xeDatePicker;
       var slots = $xeDatePicker.$scopedSlots;
       var reactData = $xeDatePicker.reactData;
+      var popupOpts = $xeDatePicker.computePopupOpts;
+      if (popupOpts.enabled === false) {
+        return renderEmptyElement($xeDatePicker);
+      }
       var type = props.type,
         multiple = props.multiple,
         showClearButton = props.showClearButton,
@@ -35000,7 +35717,6 @@ var DatePanel = VxeDatePanel;
       var isDateTimeType = $xeDatePicker.computeIsDateTimeType;
       var shortcutList = $xeDatePicker.computeShortcutList;
       var timeOpts = $xeDatePicker.computeTimeOpts;
-      var popupOpts = $xeDatePicker.computePopupOpts;
       var position = shortcutOpts.position;
       var headerSlot = slots.header;
       var footerSlot = slots.footer;
@@ -35156,14 +35872,16 @@ var DatePanel = VxeDatePanel;
       var $xeDatePicker = this;
       var props = $xeDatePicker;
       var reactData = $xeDatePicker.reactData;
+      var internalData = $xeDatePicker.internalData;
       var className = props.className,
         type = props.type,
         name = props.name,
         autoComplete = props.autoComplete;
       var inputValue = reactData.inputValue,
-        inputLabel = reactData.inputLabel,
         visiblePanel = reactData.visiblePanel,
-        isActivated = reactData.isActivated;
+        isActivated = reactData.isActivated,
+        labelFlag = reactData.labelFlag;
+      var inputLabel = internalData.inputLabel;
       var vSize = $xeDatePicker.computeSize;
       var isDisabled = $xeDatePicker.computeIsDisabled;
       var formReadonly = $xeDatePicker.computeFormReadonly;
@@ -35191,7 +35909,7 @@ var DatePanel = VxeDatePanel;
         ref: 'refInputTarget',
         class: 'vxe-date-picker--inner',
         domProps: {
-          value: inputLabel
+          value: labelFlag ? inputLabel : ''
         },
         attrs: {
           name: name,
@@ -35218,8 +35936,7 @@ var DatePanel = VxeDatePanel;
   watch: {
     computePanelLabel: function computePanelLabel(val) {
       var $xeDatePicker = this;
-      var reactData = $xeDatePicker.reactData;
-      reactData.inputLabel = val;
+      $xeDatePicker.handleInputLabel(val, true);
     },
     value: function value() {
       var $xeDatePicker = this;
@@ -35228,6 +35945,19 @@ var DatePanel = VxeDatePanel;
   },
   created: function created() {
     var $xeDatePicker = this;
+    var props = $xeDatePicker;
+    $xeDatePicker.internalData = date_picker_createInternalData();
+    var type = props.type,
+      multiple = props.multiple,
+      maskedConfig = props.maskedConfig;
+    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=".concat(type), "type=".concat(maskedTypes.join('|'))]);
+      }
+    }
     $xeDatePicker.updateModelValue();
     globalEvents.on($xeDatePicker, 'mousewheel', $xeDatePicker.handleGlobalMousewheelEvent);
     globalEvents.on($xeDatePicker, 'mousedown', $xeDatePicker.handleGlobalMousedownEvent);
@@ -35237,6 +35967,8 @@ var DatePanel = VxeDatePanel;
   },
   beforeDestroy: function beforeDestroy() {
     var $xeDatePicker = this;
+    var reactData = $xeDatePicker.reactData;
+    var internalData = $xeDatePicker.internalData;
     var panelElem = $xeDatePicker.$refs.refInputPanel;
     if (panelElem && panelElem.parentNode) {
       panelElem.parentNode.removeChild(panelElem);
@@ -35245,6 +35977,8 @@ var DatePanel = VxeDatePanel;
     globalEvents.off($xeDatePicker, 'mousedown');
     globalEvents.off($xeDatePicker, 'blur');
     globalEvents.off($xeDatePicker, 'resize');
+    external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().assign(reactData, date_picker_createReactData());
+    external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().assign(internalData, date_picker_createInternalData());
   },
   render: function render(h) {
     return this.renderVN(h);
@@ -35291,6 +36025,8 @@ var DatePicker = VxeDatePicker;
 
 
 
+var date_range_picker_createComponentLog = createComponentLog('date-range-picker'),
+  date_range_picker_errLog = date_range_picker_createComponentLog.errLog;
 /* harmony default export */ var date_range_picker = (/* define-vxe-component start */defineVxeComponent({
   name: 'VxeDateRangePicker',
   mixins: [globalMixins.sizeMixin],
@@ -35857,6 +36593,8 @@ var DatePicker = VxeDatePicker;
       reactData.isActivated = true;
       if (!trigger || trigger === 'default') {
         $xeDateRangePicker.dateRangePickerOpenEvent(evnt);
+      } else if (trigger === 'icon') {
+        $xeDateRangePicker.hidePanel();
       }
       $xeDateRangePicker.triggerEvent(evnt);
     },
@@ -36243,6 +36981,9 @@ var DatePicker = VxeDatePicker;
       var panelIndex = reactData.panelIndex;
       var targetElem = $xeDateRangePicker.$refs.refInputTarget;
       var panelElem = $xeDateRangePicker.$refs.refInputPanel;
+      if (!panelElem) {
+        return $xeDateRangePicker.$nextTick();
+      }
       var btnTransfer = $xeDateRangePicker.computeBtnTransfer;
       var popupOpts = $xeDateRangePicker.computePopupOpts;
       var handleStyle = function handleStyle() {
@@ -36271,10 +37012,8 @@ var DatePicker = VxeDatePicker;
       if (!isDisabled && !visiblePanel) {
         if (!reactData.initialized) {
           reactData.initialized = true;
-          if (btnTransfer) {
-            if (panelElem) {
-              document.body.appendChild(panelElem);
-            }
+          if (btnTransfer && panelElem) {
+            document.body.appendChild(panelElem);
           }
         }
         if (internalData.hpTimeout) {
@@ -36303,10 +37042,16 @@ var DatePicker = VxeDatePicker;
     },
     clickIconEvent: function clickIconEvent(evnt) {
       var $xeDateRangePicker = this;
+      var reactData = $xeDateRangePicker.reactData;
+      var visiblePanel = reactData.visiblePanel;
       var popupOpts = $xeDateRangePicker.computePopupOpts;
       var trigger = popupOpts.trigger;
       if (!trigger || trigger === 'default' || trigger === 'icon') {
-        $xeDateRangePicker.dateRangePickerOpenEvent(evnt);
+        if (visiblePanel) {
+          $xeDateRangePicker.hidePanel();
+        } else {
+          $xeDateRangePicker.dateRangePickerOpenEvent(evnt);
+        }
       }
     },
     clickEvent: function clickEvent(evnt) {
@@ -36366,7 +37111,7 @@ var DatePicker = VxeDatePicker;
                 break;
               }
             default:
-              errLog('vxe.error.notCommands', ["[date-range-picker] ".concat(code)]);
+              date_range_picker_errLog('vxe.error.notCommands', [code]);
               break;
           }
         }
@@ -36449,6 +37194,10 @@ var DatePicker = VxeDatePicker;
       var props = $xeDateRangePicker;
       var slots = $xeDateRangePicker.$scopedSlots;
       var reactData = $xeDateRangePicker.reactData;
+      var popupOpts = $xeDateRangePicker.computePopupOpts;
+      if (popupOpts.enabled === false) {
+        return renderEmptyElement($xeDateRangePicker);
+      }
       var type = props.type,
         separator = props.separator,
         autoClose = props.autoClose,
@@ -36471,7 +37220,6 @@ var DatePicker = VxeDatePicker;
       var defaultDates = $xeDateRangePicker.computeDefaultDates;
       var defaultTimes = $xeDateRangePicker.computeDefaultTimes;
       var timeOpts = $xeDateRangePicker.computeTimeOpts;
-      var popupOpts = $xeDateRangePicker.computePopupOpts;
       var startLabel = panelLabelObj.startLabel,
         endLabel = panelLabelObj.endLabel;
       var position = shortcutOpts.position;
@@ -36937,6 +37685,7 @@ var allActiveDrawers = [];
         return getConfig().drawer.showTitleOverflow;
       }
     },
+    preload: Boolean,
     width: [Number, String],
     height: [Number, String],
     resize: {
@@ -37578,6 +38327,8 @@ var allActiveDrawers = [];
   mounted: function mounted() {
     var $xeDrawer = this;
     var props = $xeDrawer;
+    var reactData = $xeDrawer.reactData;
+    reactData.initialized = !!props.preload;
     $xeDrawer.$nextTick(function () {
       if (props.value) {
         $xeDrawer.openDrawer();
@@ -37784,6 +38535,8 @@ var empty_empty = Vxeempty;
 
 
 
+var itemInfo_createComponentLog = createComponentLog('form'),
+  itemInfo_errLog = itemInfo_createComponentLog.errLog;
 var ItemInfo = /*#__PURE__*/function () {
   function ItemInfo($xeForm, item) {
     _classCallCheck(this, ItemInfo);
@@ -37794,21 +38547,21 @@ var ItemInfo = /*#__PURE__*/function () {
       if (external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().isString(formatter)) {
         var gFormatOpts = formats.get(formatter);
         if (!gFormatOpts || !gFormatOpts.formItemFormatMethod) {
-          errLog('vxe.error.notFormats', ["[form] ".concat(formatter)]);
+          itemInfo_errLog('vxe.error.notFormats', [formatter]);
         }
       } else if (external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().isArray(formatter)) {
         var _gFormatOpts = formats.get(formatter[0]);
         if (!_gFormatOpts || !_gFormatOpts.formItemFormatMethod) {
-          errLog('vxe.error.notFormats', ["[form] ".concat(formatter[0])]);
+          itemInfo_errLog('vxe.error.notFormats', [formatter[0]]);
         }
       }
     }
     if (field && itemRender) {
       if (itemRender.startField && "".concat(itemRender.startField).indexOf(field) >= 0) {
-        errLog('vxe.error.modelConflicts', ["[form] field=".concat(field), "item-render.startField=".concat(itemRender.startField)]);
+        itemInfo_errLog('vxe.error.modelConflicts', ["field=".concat(field), "item-render.startField=".concat(itemRender.startField)]);
       }
       if (itemRender.endField && "".concat(itemRender.endField).indexOf(field) >= 0) {
-        errLog('vxe.error.modelConflicts', ["[form] field=".concat(field), "item-render.endField=".concat(itemRender.endField)]);
+        itemInfo_errLog('vxe.error.modelConflicts', ["field=".concat(field), "item-render.endField=".concat(itemRender.endField)]);
       }
     }
     Object.assign(this, {
@@ -38530,6 +39283,8 @@ function renderItemContent(h, $xeForm, item) {
 
 
 
+var render_createComponentLog = createComponentLog('form'),
+  render_errLog = render_createComponentLog.errLog;
 var componentDefaultModelProp = 'value';
 /**
  * 已废弃
@@ -38628,7 +39383,7 @@ function getComponentOns(renderOpts, params, eFns, eventOns) {
   external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().objectEach(events, function (func, key) {
     ons[getOnName(key)] = function () {
       if (!external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().isFunction(func)) {
-        errLog('vxe.error.errFunc', ["[form] ".concat(func)]);
+        render_errLog('vxe.error.errFunc', [func]);
       }
       for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
         args[_key3] = arguments[_key3];
@@ -39208,6 +39963,9 @@ renderer.mixin({
 
 
 
+var form_createComponentLog = createComponentLog('form'),
+  form_warnLog = form_createComponentLog.warnLog,
+  form_errLog = form_createComponentLog.errLog;
 var Rule = /*#__PURE__*/function () {
   function Rule(rule) {
     _classCallCheck(this, Rule);
@@ -39501,13 +40259,11 @@ function form_createInternalData() {
   data: function data() {
     var xID = external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().uniqueId();
     var reactData = form_createReactData();
-    var internalData = form_createInternalData();
-    return {
+    return _objectSpread2(_objectSpread2({}, {}), {}, {
       xID: xID,
       reactData: reactData,
-      internalData: internalData,
       recalcFlag: 0
-    };
+    });
   },
   computed: _objectSpread2(_objectSpread2({}, {}), {}, {
     computeValidOpts: function computeValidOpts() {
@@ -39585,7 +40341,7 @@ function form_createInternalData() {
             external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().each(item.slots, function (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] ".concat(func)]);
+                  form_errLog('vxe.error.notSlot', [func]);
                 }
               }
             });
@@ -39880,10 +40636,10 @@ function form_createInternalData() {
                       if (validatorMethod) {
                         customValid = validatorMethod(validParams);
                       } else {
-                        warnLog('vxe.error.notValidators', ["[form] ".concat(validator)]);
+                        form_warnLog('vxe.error.notValidators', [validator]);
                       }
                     } else {
-                      errLog('vxe.error.notValidators', ["[form] ".concat(validator)]);
+                      form_errLog('vxe.error.notValidators', [validator]);
                     }
                   } else {
                     customValid = validator(validParams);
@@ -40281,6 +41037,7 @@ function form_createInternalData() {
     var $xeForm = this;
     var props = $xeForm;
     var reactData = $xeForm.reactData;
+    $xeForm.internalData = form_createInternalData();
     reactData.collapseAll = !!props.collapseStatus;
   },
   mounted: function mounted() {
@@ -40291,15 +41048,17 @@ function form_createInternalData() {
     }
     $xeForm.$nextTick(function () {
       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', $xeForm.handleGlobalResizeEvent);
   },
   destroyed: function destroyed() {
     var $xeForm = this;
+    var reactData = $xeForm.reactData;
     var internalData = $xeForm.internalData;
     globalEvents.off($xeForm, 'resize');
+    external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().assign(reactData, form_createReactData());
     external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().assign(internalData, form_createInternalData());
   },
   render: function render(h) {
@@ -42248,13 +43007,11 @@ function image_createReactData() {
     getThumbnailUrlMethod: Function
   },
   data: function data() {
-    var internalData = image_createInternalData();
     var reactData = image_createReactData();
-    return {
+    return _objectSpread2(_objectSpread2({}, {}), {}, {
       xID: external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().uniqueId(),
-      reactData: reactData,
-      internalData: internalData
-    };
+      reactData: reactData
+    });
   },
   computed: _objectSpread2(_objectSpread2({}, {}), {}, {
     computeWrapperStyle: function computeWrapperStyle() {
@@ -42470,6 +43227,10 @@ function image_createReactData() {
       })]);
     }
   },
+  created: function created() {
+    var $xeImage = this;
+    $xeImage.internalData = image_createInternalData();
+  },
   beforeDestroy: function beforeDestroy() {
     var $xeImage = this;
     var reactData = $xeImage.reactData;
@@ -42877,14 +43638,12 @@ function layout_body_createReactData() {
   data: function data() {
     var xID = external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().uniqueId();
     var backtopId = "vxe_layout_body_backtop_".concat(xID);
-    var internalData = layout_body_createInternalData();
     var reactData = layout_body_createReactData();
-    return {
+    return _objectSpread2(_objectSpread2({}, {}), {}, {
       xID: xID,
       backtopId: backtopId,
-      internalData: internalData,
       reactData: reactData
-    };
+    });
   },
   computed: _objectSpread2(_objectSpread2({}, {}), {}, {
     computeBacktopOpts: function computeBacktopOpts() {
@@ -42959,6 +43718,17 @@ function layout_body_createReactData() {
       }) : renderEmptyElement($xeLayoutBody)]);
     }
   },
+  created: function created() {
+    var $xeLayoutBody = this;
+    $xeLayoutBody.internalData = layout_body_createInternalData();
+  },
+  beforeDestroy: function beforeDestroy() {
+    var $xeLayoutBody = this;
+    var reactData = $xeLayoutBody.reactData;
+    var internalData = $xeLayoutBody.internalData;
+    external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().assign(reactData, layout_body_createReactData());
+    external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().assign(internalData, layout_body_createInternalData());
+  },
   render: function render(h) {
     return this.renderVN(h);
   }
@@ -43363,6 +44133,8 @@ var List = VxeList;
 
 
 
+var menu_createComponentLog = createComponentLog('menu'),
+  menu_errLog = menu_createComponentLog.errLog;
 var menu_menus = VxeUI.menus,
   menu_getConfig = VxeUI.getConfig,
   menu_getIcon = VxeUI.getIcon;
@@ -43925,7 +44697,7 @@ var menu_menus = VxeUI.menus,
     var menuConfig = props.menuConfig;
     var 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', $xeMenu.updateCollapseStyle);
     $xeMenu.updateCollapseStyle();
@@ -43998,6 +44770,9 @@ var Menu = VxeMenu;
 
 
 
+var modal_createComponentLog = createComponentLog('modal'),
+  modal_warnLog = modal_createComponentLog.warnLog,
+  modal_errLog = modal_createComponentLog.errLog;
 var allActiveModals = [];
 var msgQueue = [];
 var notifyQueue = [];
@@ -44113,6 +44888,7 @@ var lockScrollCssWidthKey = '--vxe-ui-modal-lock-scroll-view-width';
         return getConfig().modal.showFooter;
       }
     },
+    preload: Boolean,
     showZoom: Boolean,
     zoomConfig: Object,
     showMaximize: {
@@ -45664,12 +46440,14 @@ var lockScrollCssWidthKey = '--vxe-ui-modal-lock-scroll-view-width';
     var $xeModal = this;
     var slots = $xeModal.$scopedSlots;
     var props = $xeModal;
+    var reactData = $xeModal.reactData;
     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;
     $xeModal.$nextTick(function () {
       if (props.storage && !props.id) {
-        errLog('vxe.error.reqProp', ['[modal] id']);
+        modal_errLog('vxe.error.reqProp', ['[modal] id']);
       }
       if (props.value) {
         $xeModal.openModal();
@@ -46361,12 +47139,35 @@ var Option = VxeOption;
 
 
 
+var select_createComponentLog = createComponentLog('select'),
+  select_errLog = select_createComponentLog.errLog;
 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,
@@ -46572,31 +47373,11 @@ function select_createInternalData() {
   },
   data: function data() {
     var xID = external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().uniqueId();
-    var reactData = {
-      initialized: false,
-      scrollYLoad: false,
-      bodyHeight: 0,
-      topSpaceHeight: 0,
-      optList: [],
-      staticOptions: [],
-      reactFlag: 1,
-      currentOption: null,
-      searchValue: '',
-      searchLoading: false,
-      panelIndex: 0,
-      panelStyle: {},
-      panelPlacement: null,
-      triggerFocusPanel: false,
-      visiblePanel: false,
-      isAniVisible: false,
-      isActivated: false
-    };
-    var internalData = select_createInternalData();
-    return {
+    var reactData = select_createReactData();
+    return _objectSpread2(_objectSpread2({}, {}), {}, {
       xID: xID,
-      reactData: reactData,
-      internalData: internalData
-    };
+      reactData: reactData
+    });
   },
   computed: _objectSpread2(_objectSpread2({}, {}), {}, {
     computeFormReadonly: function computeFormReadonly() {
@@ -47196,10 +47977,8 @@ function select_createInternalData() {
           reactData.initialized = true;
           var btnTransfer = $xeSelect.computeBtnTransfer;
           var panelElem = $xeSelect.$refs.refOptionPanel;
-          if (btnTransfer) {
-            if (panelElem) {
-              document.body.appendChild(panelElem);
-            }
+          if (btnTransfer && panelElem) {
+            document.body.appendChild(panelElem);
           }
         }
         reactData.isActivated = true;
@@ -47986,7 +48765,7 @@ function select_createInternalData() {
                 }));
               });
             } 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') {
             var selectItem = (external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default())[selectMode](datas);
@@ -48406,6 +49185,10 @@ function select_createInternalData() {
       $xeSelect.loadData(val);
     }
   },
+  created: function created() {
+    var $xeSelect = this;
+    $xeSelect.internalData = select_createInternalData();
+  },
   mounted: function mounted() {
     var $xeSelect = this;
     var props = $xeSelect;
@@ -48438,7 +49221,9 @@ function select_createInternalData() {
   },
   destroyed: function destroyed() {
     var $xeSelect = this;
+    var reactData = $xeSelect.reactData;
     var internalData = $xeSelect.internalData;
+    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());
   },
   render: function render(h) {
@@ -48462,6 +49247,9 @@ function select_createInternalData() {
 
 
 
+var pager_createComponentLog = createComponentLog('pager'),
+  pager_warnLog = pager_createComponentLog.warnLog,
+  pager_errLog = pager_createComponentLog.errLog;
 /* harmony default export */ var pager = (/* define-vxe-component start */defineVxeComponent({
   name: 'VxePager',
   mixins: [globalMixins.sizeMixin],
@@ -48723,7 +49511,7 @@ function select_createInternalData() {
      */
     jumpPage: function jumpPage(currentPage) {
       var $xePager = this;
-      warnLog('vxe.error.delFunc', ['[pager] jumpPage', 'setCurrentPage']);
+      pager_warnLog('vxe.error.delFunc', ['jumpPage', 'setCurrentPage']);
       return $xePager.setCurrentPage(currentPage);
     },
     getPageCount: function getPageCount(total, size) {
@@ -49355,7 +50143,7 @@ function select_createInternalData() {
         if (renderFn) {
           childNodes.push(renderFn(h));
         } else {
-          errLog('vxe.error.notProp', ["[pager] layouts -> ".concat(name)]);
+          pager_errLog('vxe.error.notProp', ["layouts -> ".concat(name)]);
         }
       });
       if (slots.right) {
@@ -51511,6 +52299,9 @@ var RadioButton = VxeRadioButton;
 
 
 
+function src_group_createReactData() {
+  return {};
+}
 function src_group_createInternalData() {
   return {
     // isLoaded: false
@@ -51562,14 +52353,12 @@ function src_group_createInternalData() {
     };
   },
   data: function data() {
-    var reactData = {};
-    var internalData = src_group_createInternalData();
-    return {
+    var reactData = src_group_createReactData();
+    return _objectSpread2(_objectSpread2({}, {}), {}, {
       xID: external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().uniqueId(),
       name: external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().uniqueId('xe_group_'),
-      reactData: reactData,
-      internalData: internalData
-    };
+      reactData: reactData
+    });
   },
   computed: _objectSpread2(_objectSpread2({}, {}), {}, {
     computeIsReadonly: function computeIsReadonly() {
@@ -51730,6 +52519,10 @@ function src_group_createInternalData() {
       $xeRadioGroup.loadData(val);
     }
   },
+  created: function created() {
+    var $xeRadioGroup = this;
+    $xeRadioGroup.internalData = src_group_createInternalData();
+  },
   mounted: function mounted() {
     var $xeRadioGroup = this;
     var props = $xeRadioGroup;
@@ -51742,8 +52535,10 @@ function src_group_createInternalData() {
   },
   beforeDestroy: function beforeDestroy() {
     var $xeRadioGroup = this;
+    var reactData = $xeRadioGroup.reactData;
     var internalData = $xeRadioGroup.internalData;
     external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().assign(internalData, src_group_createInternalData());
+    external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().assign(reactData, src_group_createReactData());
   },
   render: function render(h) {
     return this.renderVN(h);
@@ -52496,6 +53291,9 @@ var Select = VxeSelect;
 
 
 
+var splitter_createComponentLog = createComponentLog('splitter'),
+  splitter_warnLog = splitter_createComponentLog.warnLog,
+  splitter_errLog = splitter_createComponentLog.errLog;
 /* harmony default export */ var splitter = (/* define-vxe-component start */defineVxeComponent({
   name: 'VxeSplitter',
   mixins: [globalMixins.sizeMixin],
@@ -52544,7 +53342,8 @@ var Select = VxeSelect;
       staticItems: [],
       itemList: [],
       barWidth: 0,
-      barHeight: 0
+      barHeight: 0,
+      resizeFlag: 0
     };
     var internalData = {
       wrapperWidth: 0,
@@ -52648,15 +53447,15 @@ var Select = VxeSelect;
       var showPrevButton = actionOpts.showPrevButton,
         showNextButton = actionOpts.showNextButton;
       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 = reactData.staticItems || [];
       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(function (item) {
         if (item.showAction) {
-          warnLog('vxe.error.removeProp', ['[splitter] show-action']);
+          splitter_warnLog('vxe.error.removeProp', ['show-action']);
         }
       });
       $xeSplitter.recalculate();
@@ -52717,7 +53516,7 @@ var Select = VxeSelect;
           external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().each(item.slots, function (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] ".concat(func)]);
+                splitter_errLog('vxe.error.notSlot', [func]);
               }
             }
           });
@@ -52727,7 +53526,7 @@ var Select = VxeSelect;
         });
       });
       if (staticItems.length) {
-        errLog('vxe.error.errConflicts', ['<vxe-splitter-panel ...>', 'items']);
+        splitter_errLog('vxe.error.errConflicts', ['<vxe-splitter-panel ...>', 'items']);
       }
       return $xeSplitter.recalculate();
     },
@@ -53075,6 +53874,7 @@ var Select = VxeSelect;
       document.onmousemove = function (evnt) {
         evnt.preventDefault();
         handleDrag(evnt);
+        reactData.resizeFlag++;
       };
       document.onmouseup = function (evnt) {
         document.onmousemove = null;
@@ -53091,6 +53891,7 @@ var Select = VxeSelect;
           offsetWidth: targetOffsetWidth
         }, evnt);
         $xeSplitter.recalculate();
+        reactData.resizeFlag++;
       };
       if (rsSplitterLineEl) {
         rsSplitterLineEl.style.display = 'block';
@@ -53106,6 +53907,7 @@ var Select = VxeSelect;
     handleItemActionEvent: function handleItemActionEvent(evnt, prevItem, nextItem, isNext) {
       var $xeSplitter = this;
       var props = $xeSplitter;
+      var reactData = $xeSplitter.reactData;
       var vertical = props.vertical;
       var expanded = false;
       var item = prevItem;
@@ -53149,6 +53951,7 @@ var Select = VxeSelect;
         }, evnt);
       }
       $xeSplitter.recalculate();
+      reactData.resizeFlag++;
     },
     handlePrevActionDblclickEvent: function handlePrevActionDblclickEvent(evnt) {
       var $xeSplitter = this;
@@ -53488,7 +54291,7 @@ var Select = VxeSelect;
     }
     var actionOpts = $xeSplitter.computeActionOpts;
     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']);
     }
     $xeSplitter.$nextTick(function () {
       $xeSplitter.recalculate();
@@ -54604,9 +55407,25 @@ var TabPane = VxeTabPane;
 
 
 
+var table_select_createComponentLog = createComponentLog('table-select'),
+  table_select_errLog = table_select_createComponentLog.errLog;
 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,
@@ -54690,26 +55509,13 @@ function table_select_createInternalData() {
   },
   data: function data() {
     var xID = external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().uniqueId();
-    var reactData = {
-      initialized: false,
-      tableColumns: [],
-      fullOptionList: [],
-      panelIndex: 0,
-      panelStyle: {},
-      panelPlacement: null,
-      triggerFocusPanel: false,
-      visiblePanel: false,
-      isAniVisible: false,
-      isActivated: false
-    };
-    var internalData = table_select_createInternalData();
+    var reactData = table_select_createReactData();
     var gridEvents = {};
-    return {
+    return _objectSpread2(_objectSpread2({}, {}), {}, {
       xID: xID,
       reactData: reactData,
-      internalData: internalData,
       gridEvents: gridEvents
-    };
+    });
   },
   computed: _objectSpread2(_objectSpread2({}, {}), {}, {
     computeFormReadonly: function computeFormReadonly() {
@@ -55009,12 +55815,12 @@ function table_select_createInternalData() {
             rowid = getRowUniqueId();
           }
           if (keyMaps[rowid]) {
-            errLog('vxe.error.repeatKey', ["[table-select] ".concat(rowKeyField), rowid]);
+            table_select_errLog('vxe.error.repeatKey', [rowKeyField, rowid]);
           }
           keyMaps[rowid] = true;
           var value = item[valueField];
           if (rowMaps[value]) {
-            errLog('vxe.error.repeatKey', ["[table-select] ".concat(valueField), value]);
+            table_select_errLog('vxe.error.repeatKey', [valueField, value]);
           }
           rowMaps[value] = {
             item: item,
@@ -55398,6 +56204,7 @@ function table_select_createInternalData() {
   created: function created() {
     var $xeTableSelect = this;
     var props = $xeTableSelect;
+    $xeTableSelect.internalData = table_select_createInternalData();
     var gridEventKeys = ['form-submit', 'form-reset', 'form-collapse', 'page-change'];
     var gridEvents = $xeTableSelect.gridEvents;
     gridEventKeys.forEach(function (name) {
@@ -55415,7 +56222,7 @@ function table_select_createInternalData() {
     var VxeTableGridComponent = VxeUI.getComponent('vxe-grid');
     $xeTableSelect.$nextTick(function () {
       if (!VxeTableGridComponent) {
-        errLog('vxe.error.reqComp', ['[table-select] vxe-grid']);
+        table_select_errLog('vxe.error.reqComp', ['vxe-grid']);
       }
     });
     var gridConfig = props.gridConfig;
@@ -55431,6 +56238,8 @@ function table_select_createInternalData() {
   },
   beforeDestroy: function beforeDestroy() {
     var $xeTableSelect = this;
+    var reactData = $xeTableSelect.reactData;
+    var internalData = $xeTableSelect.internalData;
     var panelElem = $xeTableSelect.$refs.refOptionPanel;
     if (panelElem && panelElem.parentNode) {
       panelElem.parentNode.removeChild(panelElem);
@@ -55439,6 +56248,8 @@ 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());
   },
   render: function render(h) {
     return this.renderVN(h);
@@ -55489,6 +56300,9 @@ var TableSelect = VxeTableSelect;
 
 
 
+var tabs_createComponentLog = createComponentLog('tabs'),
+  tabs_warnLog = tabs_createComponentLog.warnLog,
+  tabs_errLog = tabs_createComponentLog.errLog;
 var scrollbarOffsetSize = 20;
 /* harmony default export */ var tabs = (/* define-vxe-component start */defineVxeComponent({
   name: 'VxeTabs',
@@ -55689,12 +56503,12 @@ var scrollbarOffsetSize = 20;
     },
     prevTab: function prevTab() {
       var $xeTabs = this;
-      warnLog('vxe.error.delFunc', ['[tabs] prevTab', 'prev']);
+      tabs_warnLog('vxe.error.delFunc', ['prevTab', 'prev']);
       return $xeTabs.prev();
     },
     nextTab: function nextTab() {
       var $xeTabs = this;
-      warnLog('vxe.error.delFunc', ['[tabs] nextTab', 'next']);
+      tabs_warnLog('vxe.error.delFunc', ['nextTab', 'next']);
       return $xeTabs.next();
     },
     handleFilterTab: function handleFilterTab(item) {
@@ -55964,7 +56778,7 @@ var scrollbarOffsetSize = 20;
             cacheItem.loading = false;
           });
         } else {
-          errLog('vxe.error.notFunc', ['refresh-config.queryMethod']);
+          tabs_errLog('vxe.error.notFunc', ['refresh-config.queryMethod']);
         }
       }
     },
@@ -57024,6 +57838,8 @@ var Text = VxeText;
 
 
 
+var textarea_createComponentLog = createComponentLog('textarea'),
+  textarea_warnLog = textarea_createComponentLog.warnLog;
 var autoTxtElem;
 /* harmony default export */ var src_textarea = (/* define-vxe-component start */defineVxeComponent({
   name: 'VxeTextarea',
@@ -57484,7 +58300,7 @@ var autoTxtElem;
       var autosize = props.autosize,
         autoSize = props.autoSize;
       if (autosize) {
-        warnLog('vxe.error.delProp', ['autosize', 'auto-size']);
+        textarea_warnLog('vxe.error.delProp', ['autosize', 'auto-size']);
       }
       if (autosize || autoSize) {
         $xeTextarea.updateAutoTxt();
@@ -57948,6 +58764,8 @@ function clearColAnimate(elem, clss) {
 
 
 
+var tree_createComponentLog = createComponentLog('tree'),
+  tree_errLog = tree_createComponentLog.errLog;
 var tree_menus = VxeUI.menus,
   tree_getConfig = VxeUI.getConfig,
   tree_getI18n = VxeUI.getI18n,
@@ -58632,15 +59450,13 @@ function tree_createReactData() {
   data: function data() {
     var xID = external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().uniqueId();
     var reactData = tree_createReactData();
-    var internalData = tree_createInternalData();
-    return {
+    return _objectSpread2(_objectSpread2({}, {}), {}, {
       xID: xID,
       reactData: reactData,
-      internalData: internalData,
       crossTreeDragNodeInfo: crossTreeDragNodeGlobal,
       hFlag: 0,
       dataFlag: 0
-    };
+    });
   },
   computed: _objectSpread2(_objectSpread2({}, {}), {}, {
     computeTitleField: function computeTitleField() {
@@ -59275,7 +60091,7 @@ function tree_createReactData() {
       $xeTree.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 $xeTree.computeScrollLoad().then(function () {
@@ -61022,6 +61838,7 @@ function tree_createReactData() {
     var $xeTree = this;
     var props = $xeTree;
     var reactData = $xeTree.reactData;
+    $xeTree.internalData = tree_createInternalData();
     reactData.selectRadioKey = util_enNodeValue(props.checkNodeKey);
     $xeTree.loadData(props.data || []);
   },
@@ -61034,17 +61851,17 @@ function tree_createReactData() {
       menuConfig = props.menuConfig;
     var dragOpts = $xeTree.computeDragOpts;
     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'])
     // }
     var 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) {
       var el = $xeTree.$refs.refElem;
@@ -61118,6 +61935,9 @@ var Tree = VxeTree;
 
 
 
+var tree_select_createComponentLog = createComponentLog('tree-select'),
+  tree_select_warnLog = tree_select_createComponentLog.warnLog,
+  tree_select_errLog = tree_select_createComponentLog.errLog;
 function tree_select_getOptUniqueId() {
   return external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().uniqueId('node_');
 }
@@ -61313,12 +62133,10 @@ function tree_select_createInternalData() {
   data: function data() {
     var xID = external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().uniqueId();
     var reactData = tree_select_createReactData();
-    var internalData = tree_select_createInternalData();
-    return {
+    return _objectSpread2(_objectSpread2({}, {}), {}, {
       xID: xID,
-      reactData: reactData,
-      internalData: internalData
-    };
+      reactData: reactData
+    });
   },
   computed: _objectSpread2(_objectSpread2({}, {}), {}, {
     computeFormReadonly: function computeFormReadonly() {
@@ -61571,12 +62389,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;
         var value = item[valueField];
         if (nodeMaps[value]) {
-          errLog('vxe.error.repeatKey', [valueField, value]);
+          tree_select_errLog('vxe.error.repeatKey', [valueField, value]);
         }
         nodeMaps[value] = {
           item: item,
@@ -62256,6 +63074,7 @@ function tree_select_createInternalData() {
   },
   created: function created() {
     var $xeTreeSelect = this;
+    $xeTreeSelect.internalData = tree_select_createInternalData();
     $xeTreeSelect.cacheDataMap();
     $xeTreeSelect.cacheLazyDataMap();
   },
@@ -62263,7 +63082,7 @@ function tree_select_createInternalData() {
     var $xeTreeSelect = this;
     var props = $xeTreeSelect;
     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', $xeTreeSelect.handleGlobalMousewheelEvent);
     globalEvents.on($xeTreeSelect, 'mousedown', $xeTreeSelect.handleGlobalMousedownEvent);
@@ -62487,6 +63306,9 @@ var saveLocalFile = function saveLocalFile(options) {
 
 
 
+var upload_createComponentLog = createComponentLog('upload'),
+  upload_warnLog = upload_createComponentLog.warnLog,
+  upload_errLog = upload_createComponentLog.errLog;
 function getUniqueKey() {
   return external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().uniqueId();
 }
@@ -62866,12 +63688,10 @@ function upload_createInternalData() {
   data: function data() {
     var xID = external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().uniqueId();
     var reactData = upload_createReactData();
-    var internalData = upload_createInternalData();
-    return {
+    return _objectSpread2(_objectSpread2({}, {}), {}, {
       xID: xID,
-      reactData: reactData,
-      internalData: internalData
-    };
+      reactData: reactData
+    });
   },
   computed: _objectSpread2(_objectSpread2({}, {}), {}, {
     computeFormReadonly: function computeFormReadonly() {
@@ -63355,6 +64175,9 @@ function upload_createInternalData() {
       var fileKey = $xeUpload.getFieldKey(item);
       var uploadFn = props.uploadMethod || getConfig().upload.uploadMethod;
       if (uploadFn) {
+        $xeUpload.dispatchEvent('upload-start', {
+          option: item
+        }, null);
         return Promise.resolve(uploadFn({
           $upload: $xeUpload,
           file: file,
@@ -63410,6 +64233,9 @@ function upload_createInternalData() {
           if (cacheItem) {
             cacheItem.loading = false;
           }
+          $xeUpload.dispatchEvent('upload-end', {
+            option: item
+          }, null);
         });
       } else {
         var fileCacheMaps = reactData.fileCacheMaps;
@@ -63533,6 +64359,9 @@ function upload_createInternalData() {
           }
         }
       }
+      $xeUpload.dispatchEvent('upload-queue-start', {
+        files: selectFiles
+      }, evnt);
       var cacheMaps = Object.assign({}, reactData.fileCacheMaps);
       var newFileList = multiple ? fileList : [];
       var uploadPromiseRests = [];
@@ -63568,6 +64397,10 @@ function upload_createInternalData() {
       });
       Promise.all(urlMode ? uploadPromiseRests : []).then(function () {
         var restFileList = reactData.fileList;
+        $xeUpload.dispatchEvent('upload-queue-end', {
+          options: restFileList,
+          files: selectFiles
+        }, evnt);
         $xeUpload.handleChange(restFileList);
         // 自动更新校验状态
         if ($xeForm && formItemInfo) {
@@ -64566,16 +65399,17 @@ function upload_createInternalData() {
   },
   created: function created() {
     var $xeUpload = this;
+    $xeUpload.internalData = upload_createInternalData();
     $xeUpload.updateFileList();
   },
   mounted: function mounted() {
     var $xeUpload = this;
     var props = $xeUpload;
     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();