vxe-pc-ui 4.20.34 → 4.20.35

package/lib/date-picker/src/date-picker.js

@@ -73,1639 +73,1642 @@ function createInternalData() {
     laseFocusMasked: 0
   };
 }
-var date_picker_default = (0, import_comp.defineVxeComponent)({
-  name: "VxeDatePicker",
-  props: {
-    modelValue: [String, Number, Date],
-    immediate: {
-      type: Boolean,
-      default: true
-    },
-    name: String,
-    type: {
-      type: String,
-      default: "date"
-    },
-    width: [Number, String],
-    clearable: {
-      type: Boolean,
-      default: () => getConfig().datePicker.clearable
-    },
-    readonly: {
-      type: Boolean,
-      default: null
-    },
-    disabled: {
-      type: Boolean,
-      default: null
-    },
-    placeholder: String,
-    autoComplete: {
-      type: String,
-      default: "off"
-    },
-    form: String,
-    className: String,
-    inputClassName: {
-      type: String,
-      default: () => getConfig().datePicker.inputClassName
-    },
-    zIndex: Number,
-    size: {
-      type: String,
-      default: () => getConfig().datePicker.size || getConfig().size
-    },
-    multiple: Boolean,
-    limitCount: {
-      type: [String, Number],
-      default: () => getConfig().datePicker.limitCount
-    },
-    // date、week、month、quarter、year
-    startDate: {
-      type: [String, Number, Date],
-      default: () => getConfig().datePicker.startDate
-    },
-    endDate: {
-      type: [String, Number, Date],
-      default: () => getConfig().datePicker.endDate
-    },
-    defaultDate: [String, Number, Date],
-    defaultTime: [String, Number, Date],
-    minDate: [String, Number, Date],
-    maxDate: [String, Number, Date],
-    startDay: {
-      type: [String, Number],
-      default: () => getConfig().datePicker.startDay
-    },
-    labelFormat: String,
-    valueFormat: String,
-    timeFormat: String,
-    parseInputMethod: Function,
-    editable: {
-      type: Boolean,
-      default: true
-    },
-    festivalMethod: Function,
-    disabledMethod: Function,
-    // week
-    selectDay: {
-      type: [String, Number],
-      default: () => getConfig().datePicker.selectDay
-    },
-    showClearButton: {
-      type: Boolean,
-      default: () => getConfig().datePicker.showClearButton
-    },
-    showConfirmButton: {
-      type: Boolean,
-      default: () => getConfig().datePicker.showConfirmButton
-    },
-    autoClose: {
-      type: Boolean,
-      default: () => getConfig().datePicker.autoClose
-    },
-    maskedConfig: Object,
-    prefixIcon: String,
-    suffixIcon: String,
-    /**
-     * 已废弃，请使用 popupConfig.placement
-     * @deprecated
-     */
-    placement: String,
-    /**
-     * 已废弃，请使用 popupConfig.transfer
-     * @deprecated
-     */
-    transfer: {
-      type: Boolean,
-      default: null
+var date_picker_default = (
+  /* define-vxe-component start */
+  (0, import_comp.defineVxeComponent)({
+    name: "VxeDatePicker",
+    props: {
+      modelValue: [String, Number, Date],
+      immediate: {
+        type: Boolean,
+        default: true
+      },
+      name: String,
+      type: {
+        type: String,
+        default: "date"
+      },
+      width: [Number, String],
+      clearable: {
+        type: Boolean,
+        default: () => getConfig().datePicker.clearable
+      },
+      readonly: {
+        type: Boolean,
+        default: null
+      },
+      disabled: {
+        type: Boolean,
+        default: null
+      },
+      placeholder: String,
+      autoComplete: {
+        type: String,
+        default: "off"
+      },
+      form: String,
+      className: String,
+      inputClassName: {
+        type: String,
+        default: () => getConfig().datePicker.inputClassName
+      },
+      zIndex: Number,
+      size: {
+        type: String,
+        default: () => getConfig().datePicker.size || getConfig().size
+      },
+      multiple: Boolean,
+      limitCount: {
+        type: [String, Number],
+        default: () => getConfig().datePicker.limitCount
+      },
+      // date、week、month、quarter、year
+      startDate: {
+        type: [String, Number, Date],
+        default: () => getConfig().datePicker.startDate
+      },
+      endDate: {
+        type: [String, Number, Date],
+        default: () => getConfig().datePicker.endDate
+      },
+      defaultDate: [String, Number, Date],
+      defaultTime: [String, Number, Date],
+      minDate: [String, Number, Date],
+      maxDate: [String, Number, Date],
+      startDay: {
+        type: [String, Number],
+        default: () => getConfig().datePicker.startDay
+      },
+      labelFormat: String,
+      valueFormat: String,
+      timeFormat: String,
+      parseInputMethod: Function,
+      editable: {
+        type: Boolean,
+        default: true
+      },
+      festivalMethod: Function,
+      disabledMethod: Function,
+      // week
+      selectDay: {
+        type: [String, Number],
+        default: () => getConfig().datePicker.selectDay
+      },
+      showClearButton: {
+        type: Boolean,
+        default: () => getConfig().datePicker.showClearButton
+      },
+      showConfirmButton: {
+        type: Boolean,
+        default: () => getConfig().datePicker.showConfirmButton
+      },
+      autoClose: {
+        type: Boolean,
+        default: () => getConfig().datePicker.autoClose
+      },
+      maskedConfig: Object,
+      prefixIcon: String,
+      suffixIcon: String,
+      /**
+       * 已废弃，请使用 popupConfig.placement
+       * @deprecated
+       */
+      placement: String,
+      /**
+       * 已废弃，请使用 popupConfig.transfer
+       * @deprecated
+       */
+      transfer: {
+        type: Boolean,
+        default: null
+      },
+      timeConfig: Object,
+      popupConfig: Object,
+      shortcutConfig: Object,
+      /**
+       * 已废弃 startWeek，被 startDay 替换
+       * @deprecated
+       */
+      startWeek: Number
     },
-    timeConfig: Object,
-    popupConfig: Object,
-    shortcutConfig: Object,
-    /**
-     * 已废弃 startWeek，被 startDay 替换
-     * @deprecated
-     */
-    startWeek: Number
-  },
-  emits: ["update:modelValue", "input", "change", "keydown", "keyup", "click", "focus", "blur", "clear", "confirm", "prefix-click", "suffix-click", "date-prev", "date-today", "date-next", "shortcut-click"],
-  setup(props, context) {
-    const { slots, emit } = context;
-    const $xeModal = (0, import_vue.inject)("$xeModal", null);
-    const $xeDrawer = (0, import_vue.inject)("$xeDrawer", null);
-    const $xeTable = (0, import_vue.inject)("$xeTable", null);
-    const $xeCard = (0, import_vue.inject)("$xeCard", null);
-    const $xeForm = (0, import_vue.inject)("$xeForm", null);
-    const formItemInfo = (0, import_vue.inject)("xeFormItemInfo", null);
-    const xID = import_xe_utils.default.uniqueId();
-    const { computeSize } = useFns.useSize(props);
-    const reactData = (0, import_vue.reactive)(createReactData());
-    const internalData = createInternalData();
-    const defaultFuncProps = {
-      parseInputMethod: getConfig().datePicker.parseInputMethod,
-      festivalMethod: getConfig().datePicker.festivalMethod,
-      disabledMethod: getConfig().datePicker.disabledMethod
-    };
-    const refElem = (0, import_vue.ref)();
-    const refInputTarget = (0, import_vue.ref)();
-    const refInputPanel = (0, import_vue.ref)();
-    const refPanelWrapper = (0, import_vue.ref)();
-    const refDatePanel = (0, import_vue.ref)();
-    const refMaps = {
-      refElem,
-      refInput: refInputTarget
-    };
-    const $xeDatePicker = {
-      xID,
-      props,
-      context,
-      reactData,
-      internalData,
-      getRefMaps: () => refMaps
-    };
-    const computeBtnTransfer = (0, import_vue.computed)(() => {
-      const { transfer } = props;
-      const popupOpts = computePopupOpts.value;
-      if (import_xe_utils.default.isBoolean(popupOpts.transfer)) {
-        return popupOpts.transfer;
-      }
-      if (transfer === null) {
-        const globalTransfer = getConfig().datePicker.transfer;
-        if (import_xe_utils.default.isBoolean(globalTransfer)) {
-          return globalTransfer;
-        }
-        if ($xeTable || $xeModal || $xeDrawer || $xeCard || $xeForm) {
-          return true;
-        }
-      }
-      return transfer;
-    });
-    const computeFormReadonly = (0, import_vue.computed)(() => {
-      const { readonly } = props;
-      if (readonly === null) {
-        if ($xeForm) {
-          return $xeForm.props.readonly;
-        }
-        return false;
-      }
-      return readonly;
-    });
-    const computeIsDisabled = (0, import_vue.computed)(() => {
-      const { disabled } = props;
-      if (disabled === null) {
-        if ($xeForm) {
-          return $xeForm.props.disabled;
+    emits: ["update:modelValue", "input", "change", "keydown", "keyup", "click", "focus", "blur", "clear", "confirm", "prefix-click", "suffix-click", "date-prev", "date-today", "date-next", "shortcut-click"],
+    setup(props, context) {
+      const { slots, emit } = context;
+      const $xeModal = (0, import_vue.inject)("$xeModal", null);
+      const $xeDrawer = (0, import_vue.inject)("$xeDrawer", null);
+      const $xeTable = (0, import_vue.inject)("$xeTable", null);
+      const $xeCard = (0, import_vue.inject)("$xeCard", null);
+      const $xeForm = (0, import_vue.inject)("$xeForm", null);
+      const formItemInfo = (0, import_vue.inject)("xeFormItemInfo", null);
+      const xID = import_xe_utils.default.uniqueId();
+      const { computeSize } = useFns.useSize(props);
+      const reactData = (0, import_vue.reactive)(createReactData());
+      const internalData = createInternalData();
+      const defaultFuncProps = {
+        parseInputMethod: getConfig().datePicker.parseInputMethod,
+        festivalMethod: getConfig().datePicker.festivalMethod,
+        disabledMethod: getConfig().datePicker.disabledMethod
+      };
+      const refElem = (0, import_vue.ref)();
+      const refInputTarget = (0, import_vue.ref)();
+      const refInputPanel = (0, import_vue.ref)();
+      const refPanelWrapper = (0, import_vue.ref)();
+      const refDatePanel = (0, import_vue.ref)();
+      const refMaps = {
+        refElem,
+        refInput: refInputTarget
+      };
+      const $xeDatePicker = {
+        xID,
+        props,
+        context,
+        reactData,
+        internalData,
+        getRefMaps: () => refMaps
+      };
+      const computeBtnTransfer = (0, import_vue.computed)(() => {
+        const { transfer } = props;
+        const popupOpts = computePopupOpts.value;
+        if (import_xe_utils.default.isBoolean(popupOpts.transfer)) {
+          return popupOpts.transfer;
         }
-        return false;
-      }
-      return disabled;
-    });
-    const computeIsTimeType = (0, import_vue.computed)(() => {
-      const { type } = props;
-      return type === "time";
-    });
-    const computeIsTimeOrDateTimeType = (0, import_vue.computed)(() => {
-      const { type } = props;
-      const isTimeType = computeIsTimeType.value;
-      return isTimeType || type === "datetime";
-    });
-    const computeIsDatePickerType = (0, import_vue.computed)(() => {
-      const isTimeOrDateTimeType = computeIsTimeOrDateTimeType.value;
-      return isTimeOrDateTimeType || ["date", "week", "month", "quarter", "year"].indexOf(props.type) > -1;
-    });
-    const computeIsClearable = (0, import_vue.computed)(() => {
-      return props.clearable;
-    });
-    const computeIsDatePanelType = (0, import_vue.computed)(() => {
-      const isTimeOrDateTimeType = computeIsTimeOrDateTimeType.value;
-      return isTimeOrDateTimeType || ["date", "week", "month", "quarter", "year"].indexOf(props.type) > -1;
-    });
-    const computeDateListValue = (0, import_vue.computed)(() => {
-      const { modelValue, type, multiple } = props;
-      const isDatePanelType = computeIsDatePanelType.value;
-      const dateValueFormat = computeDateValueFormat.value;
-      if (multiple && modelValue && isDatePanelType) {
-        return import_xe_utils.default.toValueString(modelValue).split(",").map((item) => {
-          const date = (0, import_util.parseDateValue)(item, type, {
-            valueFormat: dateValueFormat
-          });
-          if (import_xe_utils.default.isValidDate(date)) {
-            return date;
+        if (transfer === null) {
+          const globalTransfer = getConfig().datePicker.transfer;
+          if (import_xe_utils.default.isBoolean(globalTransfer)) {
+            return globalTransfer;
           }
-          return date;
-        });
-      }
-      return [];
-    });
-    const computeCurrStyle = (0, import_vue.computed)(() => {
-      const { width } = props;
-      const stys = {};
-      if (width) {
-        stys.width = (0, import_dom.toCssUnit)(width);
-      }
-      return stys;
-    });
-    const computeDateStartDate = (0, import_vue.computed)(() => {
-      return props.startDate ? import_xe_utils.default.toStringDate(props.startDate) : null;
-    });
-    const computeDateEndDate = (0, import_vue.computed)(() => {
-      return props.endDate ? import_xe_utils.default.toStringDate(props.endDate) : null;
-    });
-    const computeLimitMaxCount = (0, import_vue.computed)(() => {
-      return props.multiple ? import_xe_utils.default.toNumber(props.limitCount) : 0;
-    });
-    const computeDateMultipleValue = (0, import_vue.computed)(() => {
-      const dateListValue = computeDateListValue.value;
-      const dateValueFormat = computeDateValueFormat.value;
-      return dateListValue.map((date) => import_xe_utils.default.toDateString(date, dateValueFormat));
-    });
-    const computeOverCount = (0, import_vue.computed)(() => {
-      const { multiple } = props;
-      const limitMaxCount = computeLimitMaxCount.value;
-      const dateMultipleValue = computeDateMultipleValue.value;
-      if (multiple && limitMaxCount) {
-        return dateMultipleValue.length >= limitMaxCount;
-      }
-      return false;
-    });
-    const computeInputReadonly = (0, import_vue.computed)(() => {
-      const { type, editable, multiple } = props;
-      const formReadonly = computeFormReadonly.value;
-      return formReadonly || multiple || !editable || type === "week" || type === "quarter";
-    });
-    const computeInpPlaceholder = (0, import_vue.computed)(() => {
-      const { placeholder } = props;
-      if (placeholder) {
-        return (0, import_utils.getFuncText)(placeholder);
-      }
-      const globalPlaceholder = getConfig().datePicker.placeholder;
-      if (globalPlaceholder) {
-        return (0, import_utils.getFuncText)(globalPlaceholder);
-      }
-      return getI18n("vxe.base.pleaseSelect");
-    });
-    const computeInpImmediate = (0, import_vue.computed)(() => {
-      const { immediate } = props;
-      return immediate;
-    });
-    const computeTimeOpts = (0, import_vue.computed)(() => {
-      return Object.assign({}, getConfig().datePicker.timeConfig, props.timeConfig);
-    });
-    const computePopupOpts = (0, import_vue.computed)(() => {
-      return Object.assign({}, getConfig().datePicker.popupConfig, props.popupConfig);
-    });
-    const computeShortcutOpts = (0, import_vue.computed)(() => {
-      return Object.assign({}, getConfig().datePicker.shortcutConfig, props.shortcutConfig);
-    });
-    const computeShortcutList = (0, import_vue.computed)(() => {
-      const shortcutOpts = computeShortcutOpts.value;
-      const { options } = shortcutOpts;
-      if (options) {
-        return options.map((option, index) => {
-          return Object.assign(
-            {
-              name: `${option.name || option.code || index}`
-            },
-            option
-          );
-        });
-      }
-      return [];
-    });
-    const computeDateLabelFormat = (0, import_vue.computed)(() => {
-      const { labelFormat } = props;
-      return labelFormat || getI18n(`vxe.input.date.labelFormat.${props.type}`);
-    });
-    const computeDateValueFormat = (0, import_vue.computed)(() => {
-      const { type, valueFormat } = props;
-      return (0, import_util.handleValueFormat)(type, valueFormat);
-    });
-    const computeDateMaskedFormat = (0, import_vue.computed)(() => {
-      const dateLabelFormat = computeDateLabelFormat.value;
-      return dateLabelFormat;
-    });
-    const computeFirstDayOfWeek = (0, import_vue.computed)(() => {
-      const { startDay } = props;
-      return import_xe_utils.default.toNumber(startDay);
-    });
-    const computePanelLabel = (0, import_vue.computed)(() => {
-      const { type, multiple } = props;
-      const { inputValue } = reactData;
-      const dateLabelFormat = computeDateLabelFormat.value;
-      const dateValueFormat = computeDateValueFormat.value;
-      const firstDayOfWeek = computeFirstDayOfWeek.value;
-      const vals = inputValue ? multiple ? inputValue.split(",") : [inputValue] : [];
-      return vals.map((val) => {
-        const dateObj = (0, import_util.parseDateObj)(val, type, {
-          valueFormat: dateValueFormat,
-          labelFormat: dateLabelFormat,
-          firstDay: firstDayOfWeek
-        });
-        return dateObj.label;
-      }).join(", ");
-    });
-    const computeMaskedOpts = (0, import_vue.computed)(() => {
-      return Object.assign({}, getConfig().datePicker.maskedConfig, props.maskedConfig);
-    });
-    const computeMaskChar = (0, import_vue.computed)(() => {
-      const maskedOpts = computeMaskedOpts.value;
-      const { maskPlaceholder } = maskedOpts;
-      return (maskPlaceholder ? ("" + maskPlaceholder)[0] : "") || defaultMaskPlaceholder;
-    });
-    const updateModelValue = () => {
-      const { modelValue } = props;
-      let val = "";
-      if (modelValue) {
-        if (import_xe_utils.default.isNumber(modelValue) && /^[0-9]{11,15}$/.test(`${modelValue}`)) {
-          val = new Date(modelValue);
-        } else {
-          val = modelValue;
-        }
-      }
-      reactData.inputValue = val;
-    };
-    const handleInputLabel = (text, isUpdate) => {
-      internalData.inputLabel = text;
-      if (isUpdate) {
-        reactData.labelFlag++;
-      }
-    };
-    const triggerEvent = (evnt) => {
-      const { inputValue } = reactData;
-      dispatchEvent(evnt.type, { value: inputValue }, evnt);
-    };
-    const handleChange = (value, evnt) => {
-      const { type, modelValue, valueFormat } = props;
-      const dateValueFormat = computeDateValueFormat.value;
-      reactData.inputValue = value;
-      if ((0, import_util.hasTimestampValueType)(valueFormat)) {
-        const dateVal = (0, import_util.parseDateValue)(value, type, { valueFormat: dateValueFormat });
-        const timeNum = dateVal ? dateVal.getTime() : null;
-        emitModel(timeNum);
-        if (modelValue !== timeNum) {
-          dispatchEvent("change", { value: timeNum }, evnt);
-          if ($xeForm && formItemInfo) {
-            $xeForm.triggerItemEvent(evnt, formItemInfo.itemConfig.field, timeNum);
+          if ($xeTable || $xeModal || $xeDrawer || $xeCard || $xeForm) {
+            return true;
           }
         }
-      } else if ((0, import_util.hasDateValueType)(valueFormat)) {
-        const dateVal = (0, import_util.parseDateValue)(value, type, { valueFormat: dateValueFormat });
-        emitModel(dateVal);
-        if (modelValue && dateVal ? import_xe_utils.default.toStringDate(modelValue).getTime() !== dateVal.getTime() : modelValue !== dateVal) {
-          dispatchEvent("change", { value: dateVal }, evnt);
-          if ($xeForm && formItemInfo) {
-            $xeForm.triggerItemEvent(evnt, formItemInfo.itemConfig.field, dateVal);
+        return transfer;
+      });
+      const computeFormReadonly = (0, import_vue.computed)(() => {
+        const { readonly } = props;
+        if (readonly === null) {
+          if ($xeForm) {
+            return $xeForm.props.readonly;
           }
+          return false;
         }
-      } else {
-        emitModel(value);
-        if (import_xe_utils.default.toValueString(modelValue) !== value) {
-          dispatchEvent("change", { value }, evnt);
-          if ($xeForm && formItemInfo) {
-            $xeForm.triggerItemEvent(evnt, formItemInfo.itemConfig.field, value);
+        return readonly;
+      });
+      const computeIsDisabled = (0, import_vue.computed)(() => {
+        const { disabled } = props;
+        if (disabled === null) {
+          if ($xeForm) {
+            return $xeForm.props.disabled;
           }
+          return false;
         }
-      }
-    };
-    const inputEvent = (evnt) => {
-      const inputElem = evnt.target;
-      const value = inputElem.value;
-      handleInputLabel(value, true);
-      dispatchEvent("input", { value }, evnt);
-    };
-    const changeEvent = (evnt) => {
-      const inpImmediate = computeInpImmediate.value;
-      if (!inpImmediate) {
-        triggerEvent(evnt);
-      }
-    };
-    const clickPrefixEvent = (evnt) => {
-      const isDisabled = computeIsDisabled.value;
-      if (!isDisabled) {
-        const { inputValue } = reactData;
-        dispatchEvent("prefix-click", { value: inputValue }, evnt);
-      }
-    };
-    const hidePanel = () => {
-      return new Promise((resolve) => {
-        reactData.visiblePanel = false;
-        internalData.hpTimeout = setTimeout(() => {
-          reactData.isAniVisible = false;
-          resolve();
-        }, 350);
+        return disabled;
       });
-    };
-    const dateChange = (date, isReload) => {
-      const { modelValue, multiple } = props;
-      const isTimeOrDateTimeType = computeIsTimeOrDateTimeType.value;
-      const dateValueFormat = computeDateValueFormat.value;
-      const firstDayOfWeek = computeFirstDayOfWeek.value;
-      if (props.type === "week") {
-        const sWeek = import_xe_utils.default.toNumber(props.selectDay);
-        date = import_xe_utils.default.getWhatWeek(date, 0, sWeek, firstDayOfWeek);
-      }
-      const inpVal = import_xe_utils.default.toDateString(date, dateValueFormat, { firstDay: firstDayOfWeek });
-      if (multiple) {
-        const overCount = computeOverCount.value;
-        if (isTimeOrDateTimeType) {
-          const dateListValue = isReload ? [] : [...computeDateListValue.value];
-          const datetimeRest = [];
-          const eqIndex = import_xe_utils.default.findIndexOf(dateListValue, (val) => import_xe_utils.default.isDateSame(date, val, "yyyyMMdd"));
-          if (eqIndex === -1) {
-            if (overCount) {
-              return;
+      const computeIsTimeType = (0, import_vue.computed)(() => {
+        const { type } = props;
+        return type === "time";
+      });
+      const computeIsTimeOrDateTimeType = (0, import_vue.computed)(() => {
+        const { type } = props;
+        const isTimeType = computeIsTimeType.value;
+        return isTimeType || type === "datetime";
+      });
+      const computeIsDatePickerType = (0, import_vue.computed)(() => {
+        const isTimeOrDateTimeType = computeIsTimeOrDateTimeType.value;
+        return isTimeOrDateTimeType || ["date", "week", "month", "quarter", "year"].indexOf(props.type) > -1;
+      });
+      const computeIsClearable = (0, import_vue.computed)(() => {
+        return props.clearable;
+      });
+      const computeIsDatePanelType = (0, import_vue.computed)(() => {
+        const isTimeOrDateTimeType = computeIsTimeOrDateTimeType.value;
+        return isTimeOrDateTimeType || ["date", "week", "month", "quarter", "year"].indexOf(props.type) > -1;
+      });
+      const computeDateListValue = (0, import_vue.computed)(() => {
+        const { modelValue, type, multiple } = props;
+        const isDatePanelType = computeIsDatePanelType.value;
+        const dateValueFormat = computeDateValueFormat.value;
+        if (multiple && modelValue && isDatePanelType) {
+          return import_xe_utils.default.toValueString(modelValue).split(",").map((item) => {
+            const date = (0, import_util.parseDateValue)(item, type, {
+              valueFormat: dateValueFormat
+            });
+            if (import_xe_utils.default.isValidDate(date)) {
+              return date;
             }
-            dateListValue.push(date);
+            return date;
+          });
+        }
+        return [];
+      });
+      const computeCurrStyle = (0, import_vue.computed)(() => {
+        const { width } = props;
+        const stys = {};
+        if (width) {
+          stys.width = (0, import_dom.toCssUnit)(width);
+        }
+        return stys;
+      });
+      const computeDateStartDate = (0, import_vue.computed)(() => {
+        return props.startDate ? import_xe_utils.default.toStringDate(props.startDate) : null;
+      });
+      const computeDateEndDate = (0, import_vue.computed)(() => {
+        return props.endDate ? import_xe_utils.default.toStringDate(props.endDate) : null;
+      });
+      const computeLimitMaxCount = (0, import_vue.computed)(() => {
+        return props.multiple ? import_xe_utils.default.toNumber(props.limitCount) : 0;
+      });
+      const computeDateMultipleValue = (0, import_vue.computed)(() => {
+        const dateListValue = computeDateListValue.value;
+        const dateValueFormat = computeDateValueFormat.value;
+        return dateListValue.map((date) => import_xe_utils.default.toDateString(date, dateValueFormat));
+      });
+      const computeOverCount = (0, import_vue.computed)(() => {
+        const { multiple } = props;
+        const limitMaxCount = computeLimitMaxCount.value;
+        const dateMultipleValue = computeDateMultipleValue.value;
+        if (multiple && limitMaxCount) {
+          return dateMultipleValue.length >= limitMaxCount;
+        }
+        return false;
+      });
+      const computeInputReadonly = (0, import_vue.computed)(() => {
+        const { type, editable, multiple } = props;
+        const formReadonly = computeFormReadonly.value;
+        return formReadonly || multiple || !editable || type === "week" || type === "quarter";
+      });
+      const computeInpPlaceholder = (0, import_vue.computed)(() => {
+        const { placeholder } = props;
+        if (placeholder) {
+          return (0, import_utils.getFuncText)(placeholder);
+        }
+        const globalPlaceholder = getConfig().datePicker.placeholder;
+        if (globalPlaceholder) {
+          return (0, import_utils.getFuncText)(globalPlaceholder);
+        }
+        return getI18n("vxe.base.pleaseSelect");
+      });
+      const computeInpImmediate = (0, import_vue.computed)(() => {
+        const { immediate } = props;
+        return immediate;
+      });
+      const computeTimeOpts = (0, import_vue.computed)(() => {
+        return Object.assign({}, getConfig().datePicker.timeConfig, props.timeConfig);
+      });
+      const computePopupOpts = (0, import_vue.computed)(() => {
+        return Object.assign({}, getConfig().datePicker.popupConfig, props.popupConfig);
+      });
+      const computeShortcutOpts = (0, import_vue.computed)(() => {
+        return Object.assign({}, getConfig().datePicker.shortcutConfig, props.shortcutConfig);
+      });
+      const computeShortcutList = (0, import_vue.computed)(() => {
+        const shortcutOpts = computeShortcutOpts.value;
+        const { options } = shortcutOpts;
+        if (options) {
+          return options.map((option, index) => {
+            return Object.assign(
+              {
+                name: `${option.name || option.code || index}`
+              },
+              option
+            );
+          });
+        }
+        return [];
+      });
+      const computeDateLabelFormat = (0, import_vue.computed)(() => {
+        const { labelFormat } = props;
+        return labelFormat || getI18n(`vxe.input.date.labelFormat.${props.type}`);
+      });
+      const computeDateValueFormat = (0, import_vue.computed)(() => {
+        const { type, valueFormat } = props;
+        return (0, import_util.handleValueFormat)(type, valueFormat);
+      });
+      const computeDateMaskedFormat = (0, import_vue.computed)(() => {
+        const dateLabelFormat = computeDateLabelFormat.value;
+        return dateLabelFormat;
+      });
+      const computeFirstDayOfWeek = (0, import_vue.computed)(() => {
+        const { startDay } = props;
+        return import_xe_utils.default.toNumber(startDay);
+      });
+      const computePanelLabel = (0, import_vue.computed)(() => {
+        const { type, multiple } = props;
+        const { inputValue } = reactData;
+        const dateLabelFormat = computeDateLabelFormat.value;
+        const dateValueFormat = computeDateValueFormat.value;
+        const firstDayOfWeek = computeFirstDayOfWeek.value;
+        const vals = inputValue ? multiple ? inputValue.split(",") : [inputValue] : [];
+        return vals.map((val) => {
+          const dateObj = (0, import_util.parseDateObj)(val, type, {
+            valueFormat: dateValueFormat,
+            labelFormat: dateLabelFormat,
+            firstDay: firstDayOfWeek
+          });
+          return dateObj.label;
+        }).join(", ");
+      });
+      const computeMaskedOpts = (0, import_vue.computed)(() => {
+        return Object.assign({}, getConfig().datePicker.maskedConfig, props.maskedConfig);
+      });
+      const computeMaskChar = (0, import_vue.computed)(() => {
+        const maskedOpts = computeMaskedOpts.value;
+        const { maskPlaceholder } = maskedOpts;
+        return (maskPlaceholder ? ("" + maskPlaceholder)[0] : "") || defaultMaskPlaceholder;
+      });
+      const updateModelValue = () => {
+        const { modelValue } = props;
+        let val = "";
+        if (modelValue) {
+          if (import_xe_utils.default.isNumber(modelValue) && /^[0-9]{11,15}$/.test(`${modelValue}`)) {
+            val = new Date(modelValue);
           } else {
-            dateListValue.splice(eqIndex, 1);
+            val = modelValue;
           }
-          dateListValue.forEach((item) => {
-            if (item) {
-              datetimeRest.push(item);
+        }
+        reactData.inputValue = val;
+      };
+      const handleInputLabel = (text, isUpdate) => {
+        internalData.inputLabel = text;
+        if (isUpdate) {
+          reactData.labelFlag++;
+        }
+      };
+      const triggerEvent = (evnt) => {
+        const { inputValue } = reactData;
+        dispatchEvent(evnt.type, { value: inputValue }, evnt);
+      };
+      const handleChange = (value, evnt) => {
+        const { type, modelValue, valueFormat } = props;
+        const dateValueFormat = computeDateValueFormat.value;
+        reactData.inputValue = value;
+        if ((0, import_util.hasTimestampValueType)(valueFormat)) {
+          const dateVal = (0, import_util.parseDateValue)(value, type, { valueFormat: dateValueFormat });
+          const timeNum = dateVal ? dateVal.getTime() : null;
+          emitModel(timeNum);
+          if (modelValue !== timeNum) {
+            dispatchEvent("change", { value: timeNum }, evnt);
+            if ($xeForm && formItemInfo) {
+              $xeForm.triggerItemEvent(evnt, formItemInfo.itemConfig.field, timeNum);
             }
-          });
-          handleChange(datetimeRest.map((date2) => import_xe_utils.default.toDateString(date2, dateValueFormat)).join(","), { type: "update" });
+          }
+        } else if ((0, import_util.hasDateValueType)(valueFormat)) {
+          const dateVal = (0, import_util.parseDateValue)(value, type, { valueFormat: dateValueFormat });
+          emitModel(dateVal);
+          if (modelValue && dateVal ? import_xe_utils.default.toStringDate(modelValue).getTime() !== dateVal.getTime() : modelValue !== dateVal) {
+            dispatchEvent("change", { value: dateVal }, evnt);
+            if ($xeForm && formItemInfo) {
+              $xeForm.triggerItemEvent(evnt, formItemInfo.itemConfig.field, dateVal);
+            }
+          }
         } else {
-          const dateMultipleValue = isReload ? [] : computeDateMultipleValue.value;
-          if (dateMultipleValue.some((val) => import_xe_utils.default.isEqual(val, inpVal))) {
-            handleChange(dateMultipleValue.filter((val) => !import_xe_utils.default.isEqual(val, inpVal)).join(","), { type: "update" });
-          } else {
-            if (overCount) {
-              return;
+          emitModel(value);
+          if (import_xe_utils.default.toValueString(modelValue) !== value) {
+            dispatchEvent("change", { value }, evnt);
+            if ($xeForm && formItemInfo) {
+              $xeForm.triggerItemEvent(evnt, formItemInfo.itemConfig.field, value);
             }
-            handleChange(dateMultipleValue.concat([inpVal]).join(","), { type: "update" });
           }
         }
-      } else {
-        if (!import_xe_utils.default.isEqual(modelValue, inpVal)) {
-          handleChange(inpVal, { type: "update" });
-        }
-      }
-    };
-    const dateRevert = () => {
-      const panelLabel = computePanelLabel.value;
-      handleInputLabel(panelLabel, true);
-    };
-    const afterCheckValue = (inpVal) => {
-      const { type, editable, multiple, maskedConfig } = props;
-      const { inputLabel } = internalData;
-      const dateLabelFormat = computeDateLabelFormat.value;
-      const maskedOpts = computeMaskedOpts.value;
-      const dateStartDate = computeDateStartDate.value;
-      const dateEndDate = computeDateEndDate.value;
-      const parseInpMethod = props.parseInputMethod || defaultFuncProps.parseInputMethod;
-      if (!inpVal) {
-        handleChange("", { type: "check" });
-        return;
-      }
-      if (editable && !multiple && ((0, import_utils.isEnableConf)(maskedConfig) || maskedOpts.enabled)) {
-        const allMaskedKeys = dateLabelFormat.match(new RegExp(`(${inputMaskedKeys.join("|")})+`, "g"));
-        if (allMaskedKeys) {
-          allMaskedKeys.forEach((formatKey) => {
-            const fkIndex = dateLabelFormat.indexOf(formatKey);
-            if (fkIndex > -1) {
-              const valStr = inpVal.slice(fkIndex, fkIndex + formatKey.length).replace(/\D/g, "");
-              if (!valStr) {
+      };
+      const inputEvent = (evnt) => {
+        const inputElem = evnt.target;
+        const value = inputElem.value;
+        handleInputLabel(value, true);
+        dispatchEvent("input", { value }, evnt);
+      };
+      const changeEvent = (evnt) => {
+        const inpImmediate = computeInpImmediate.value;
+        if (!inpImmediate) {
+          triggerEvent(evnt);
+        }
+      };
+      const clickPrefixEvent = (evnt) => {
+        const isDisabled = computeIsDisabled.value;
+        if (!isDisabled) {
+          const { inputValue } = reactData;
+          dispatchEvent("prefix-click", { value: inputValue }, evnt);
+        }
+      };
+      const hidePanel = () => {
+        return new Promise((resolve) => {
+          reactData.visiblePanel = false;
+          internalData.hpTimeout = setTimeout(() => {
+            reactData.isAniVisible = false;
+            resolve();
+          }, 350);
+        });
+      };
+      const dateChange = (date, isReload) => {
+        const { modelValue, multiple } = props;
+        const isTimeOrDateTimeType = computeIsTimeOrDateTimeType.value;
+        const dateValueFormat = computeDateValueFormat.value;
+        const firstDayOfWeek = computeFirstDayOfWeek.value;
+        if (props.type === "week") {
+          const sWeek = import_xe_utils.default.toNumber(props.selectDay);
+          date = import_xe_utils.default.getWhatWeek(date, 0, sWeek, firstDayOfWeek);
+        }
+        const inpVal = import_xe_utils.default.toDateString(date, dateValueFormat, { firstDay: firstDayOfWeek });
+        if (multiple) {
+          const overCount = computeOverCount.value;
+          if (isTimeOrDateTimeType) {
+            const dateListValue = isReload ? [] : [...computeDateListValue.value];
+            const datetimeRest = [];
+            const eqIndex = import_xe_utils.default.findIndexOf(dateListValue, (val) => import_xe_utils.default.isDateSame(date, val, "yyyyMMdd"));
+            if (eqIndex === -1) {
+              if (overCount) {
                 return;
               }
-              let valNum = import_xe_utils.default.toNumber(valStr);
-              if (!valNum && ["MM", "dd"].includes(formatKey)) {
-                valNum = 1;
+              dateListValue.push(date);
+            } else {
+              dateListValue.splice(eqIndex, 1);
+            }
+            dateListValue.forEach((item) => {
+              if (item) {
+                datetimeRest.push(item);
+              }
+            });
+            handleChange(datetimeRest.map((date2) => import_xe_utils.default.toDateString(date2, dateValueFormat)).join(","), { type: "update" });
+          } else {
+            const dateMultipleValue = isReload ? [] : computeDateMultipleValue.value;
+            if (dateMultipleValue.some((val) => import_xe_utils.default.isEqual(val, inpVal))) {
+              handleChange(dateMultipleValue.filter((val) => !import_xe_utils.default.isEqual(val, inpVal)).join(","), { type: "update" });
+            } else {
+              if (overCount) {
+                return;
               }
-              inpVal = inpVal.slice(0, fkIndex) + import_xe_utils.default.padStart((0, import_util.checkDateInputFormat)(valNum, formatKey), formatKey.length, "0") + inpVal.slice(fkIndex + formatKey.length);
+              handleChange(dateMultipleValue.concat([inpVal]).join(","), { type: "update" });
             }
+          }
+        } else {
+          if (!import_xe_utils.default.isEqual(modelValue, inpVal)) {
+            handleChange(inpVal, { type: "update" });
+          }
+        }
+      };
+      const dateRevert = () => {
+        const panelLabel = computePanelLabel.value;
+        handleInputLabel(panelLabel, true);
+      };
+      const afterCheckValue = (inpVal) => {
+        const { type, editable, multiple, maskedConfig } = props;
+        const { inputLabel } = internalData;
+        const dateLabelFormat = computeDateLabelFormat.value;
+        const maskedOpts = computeMaskedOpts.value;
+        const dateStartDate = computeDateStartDate.value;
+        const dateEndDate = computeDateEndDate.value;
+        const parseInpMethod = props.parseInputMethod || defaultFuncProps.parseInputMethod;
+        if (!inpVal) {
+          handleChange("", { type: "check" });
+          return;
+        }
+        if (editable && !multiple && ((0, import_utils.isEnableConf)(maskedConfig) || maskedOpts.enabled)) {
+          const allMaskedKeys = dateLabelFormat.match(new RegExp(`(${inputMaskedKeys.join("|")})+`, "g"));
+          if (allMaskedKeys) {
+            allMaskedKeys.forEach((formatKey) => {
+              const fkIndex = dateLabelFormat.indexOf(formatKey);
+              if (fkIndex > -1) {
+                const valStr = inpVal.slice(fkIndex, fkIndex + formatKey.length).replace(/\D/g, "");
+                if (!valStr) {
+                  return;
+                }
+                let valNum = import_xe_utils.default.toNumber(valStr);
+                if (!valNum && ["MM", "dd"].includes(formatKey)) {
+                  valNum = 1;
+                }
+                inpVal = inpVal.slice(0, fkIndex) + import_xe_utils.default.padStart((0, import_util.checkDateInputFormat)(valNum, formatKey), formatKey.length, "0") + inpVal.slice(fkIndex + formatKey.length);
+              }
+            });
+          }
+        }
+        let inpDateVal;
+        if (parseInpMethod) {
+          inpDateVal = parseInpMethod({
+            $datePicker: $xeDatePicker,
+            type,
+            inputValue: inpVal,
+            valueFormat: dateLabelFormat
+          }) || null;
+        } else {
+          const $datePanel = refDatePanel.value;
+          if ($datePanel) {
+            return $datePanel.checkValue(inpVal);
+          }
+          inpDateVal = (0, import_util.parseDateValue)(inpVal, type, {
+            valueFormat: dateLabelFormat
           });
         }
-      }
-      let inpDateVal;
-      if (parseInpMethod) {
-        inpDateVal = parseInpMethod({
-          $datePicker: $xeDatePicker,
-          type,
-          inputValue: inpVal,
-          valueFormat: dateLabelFormat
-        }) || null;
-      } else {
-        const $datePanel = refDatePanel.value;
-        if ($datePanel) {
-          return $datePanel.checkValue(inpVal);
+        if (!import_xe_utils.default.isValidDate(inpDateVal)) {
+          dateRevert();
+          return;
         }
-        inpDateVal = (0, import_util.parseDateValue)(inpVal, type, {
-          valueFormat: dateLabelFormat
-        });
-      }
-      if (!import_xe_utils.default.isValidDate(inpDateVal)) {
-        dateRevert();
-        return;
-      }
-      if (type === "time") {
-        const timeVal = import_xe_utils.default.toDateString(inpDateVal, dateLabelFormat);
-        if (inputLabel !== timeVal) {
-          handleChange(inpDateVal, { type: "check" });
-        }
-        handleInputLabel(timeVal, true);
-        return;
-      }
-      if (dateEndDate && inpDateVal > dateEndDate) {
-        inpDateVal = dateEndDate;
-      }
-      if (dateStartDate && inpDateVal < dateStartDate) {
-        inpDateVal = dateStartDate;
-      }
-      let isChange = false;
-      const firstDayOfWeek = computeFirstDayOfWeek.value;
-      if (type === "datetime") {
-        const dateValue = reactData.inputValue;
-        if (inpVal !== import_xe_utils.default.toDateString(dateValue, dateLabelFormat) || inpVal !== import_xe_utils.default.toDateString(inpDateVal, dateLabelFormat)) {
+        if (type === "time") {
+          const timeVal = import_xe_utils.default.toDateString(inpDateVal, dateLabelFormat);
+          if (inputLabel !== timeVal) {
+            handleChange(inpDateVal, { type: "check" });
+          }
+          handleInputLabel(timeVal, true);
+          return;
+        }
+        if (dateEndDate && inpDateVal > dateEndDate) {
+          inpDateVal = dateEndDate;
+        }
+        if (dateStartDate && inpDateVal < dateStartDate) {
+          inpDateVal = dateStartDate;
+        }
+        let isChange = false;
+        const firstDayOfWeek = computeFirstDayOfWeek.value;
+        if (type === "datetime") {
+          const dateValue = reactData.inputValue;
+          if (inpVal !== import_xe_utils.default.toDateString(dateValue, dateLabelFormat) || inpVal !== import_xe_utils.default.toDateString(inpDateVal, dateLabelFormat)) {
+            isChange = true;
+          }
+        } else {
           isChange = true;
         }
-      } else {
-        isChange = true;
-      }
-      const label = import_xe_utils.default.toDateString(inpDateVal, dateLabelFormat, { firstDay: firstDayOfWeek });
-      handleInputLabel(label, true);
-      if (isChange) {
-        dateChange(inpDateVal);
-      }
-    };
-    const clearValueEvent = (evnt, value) => {
-      const isDatePickerType = computeIsDatePickerType.value;
-      if (isDatePickerType) {
-        hidePanel();
-      }
-      handleChange("", evnt);
-      dispatchEvent("clear", { value }, evnt);
-    };
-    const clickSuffixEvent = (evnt) => {
-      const isDisabled = computeIsDisabled.value;
-      if (!isDisabled) {
-        const { inputValue } = reactData;
-        dispatchEvent("suffix-click", { value: inputValue }, evnt);
-      }
-    };
-    const checkMaskedInputValue = (numStr, chunkFormat, isFull) => {
-      const maskedOpts = computeMaskedOpts.value;
-      const { align } = maskedOpts;
-      const maskChar = computeMaskChar.value;
-      const numVal = import_xe_utils.default.toNumber(numStr);
-      let restVal = (0, import_util.checkDateInputFormat)(numVal, chunkFormat);
-      if (isFull) {
-        if (!restVal && ["MM", "dd"].includes(chunkFormat)) {
-          restVal = 1;
-        }
-      }
-      let restStr = "" + restVal;
-      if (numStr.length > restStr.length) {
-        restStr = restStr.padStart(numStr.length, "0");
-      }
-      if (isFull) {
-        return import_xe_utils.default.padStart(restStr, chunkFormat.length, "0");
-      }
-      return import_xe_utils.default[align === "right" ? "padStart" : "padEnd"](restStr, chunkFormat.length, maskChar);
-    };
-    const handleArrowInputDate = (evnt, isUpArrow, isDwArrow, isLtArrow, isRtArrow) => {
-      const { type, multiple } = props;
-      if (multiple) {
-        return;
-      }
-      const targetElem = refInputTarget.value;
-      if (!targetElem) {
-        return;
-      }
-      const inpValue = targetElem.value;
-      if (!inpValue) {
-        return;
-      }
-      const dateMaskedFormat = computeDateMaskedFormat.value;
-      const dateLabelFormat = computeDateLabelFormat.value;
-      const firstDayOfWeek = computeFirstDayOfWeek.value;
-      const maskChar = computeMaskChar.value;
-      const selectionStart = targetElem.selectionStart || 0;
-      let selectKey = dateMaskedFormat[selectionStart];
-      if (!parseInputKayMaps[selectKey]) {
-        selectKey = dateMaskedFormat[selectionStart - 1];
-      }
-      const skRest = dateMaskedFormat.match(new RegExp(selectKey + "+"));
-      if (!skRest) {
-        return;
-      }
-      if (isUpArrow || isDwArrow) {
+        const label = import_xe_utils.default.toDateString(inpDateVal, dateLabelFormat, { firstDay: firstDayOfWeek });
+        handleInputLabel(label, true);
+        if (isChange) {
+          dateChange(inpDateVal);
+        }
+      };
+      const clearValueEvent = (evnt, value) => {
+        const isDatePickerType = computeIsDatePickerType.value;
+        if (isDatePickerType) {
+          hidePanel();
+        }
+        handleChange("", evnt);
+        dispatchEvent("clear", { value }, evnt);
+      };
+      const clickSuffixEvent = (evnt) => {
+        const isDisabled = computeIsDisabled.value;
+        if (!isDisabled) {
+          const { inputValue } = reactData;
+          dispatchEvent("suffix-click", { value: inputValue }, evnt);
+        }
+      };
+      const checkMaskedInputValue = (numStr, chunkFormat, isFull) => {
+        const maskedOpts = computeMaskedOpts.value;
+        const { align } = maskedOpts;
+        const maskChar = computeMaskChar.value;
+        const numVal = import_xe_utils.default.toNumber(numStr);
+        let restVal = (0, import_util.checkDateInputFormat)(numVal, chunkFormat);
+        if (isFull) {
+          if (!restVal && ["MM", "dd"].includes(chunkFormat)) {
+            restVal = 1;
+          }
+        }
+        let restStr = "" + restVal;
+        if (numStr.length > restStr.length) {
+          restStr = restStr.padStart(numStr.length, "0");
+        }
+        if (isFull) {
+          return import_xe_utils.default.padStart(restStr, chunkFormat.length, "0");
+        }
+        return import_xe_utils.default[align === "right" ? "padStart" : "padEnd"](restStr, chunkFormat.length, maskChar);
+      };
+      const handleArrowInputDate = (evnt, isUpArrow, isDwArrow, isLtArrow, isRtArrow) => {
+        const { type, multiple } = props;
+        if (multiple) {
+          return;
+        }
+        const targetElem = refInputTarget.value;
+        if (!targetElem) {
+          return;
+        }
+        const inpValue = targetElem.value;
+        if (!inpValue) {
+          return;
+        }
+        const dateMaskedFormat = computeDateMaskedFormat.value;
+        const dateLabelFormat = computeDateLabelFormat.value;
+        const firstDayOfWeek = computeFirstDayOfWeek.value;
+        const maskChar = computeMaskChar.value;
+        const selectionStart = targetElem.selectionStart || 0;
+        let selectKey = dateMaskedFormat[selectionStart];
+        if (!parseInputKayMaps[selectKey]) {
+          selectKey = dateMaskedFormat[selectionStart - 1];
+        }
+        const skRest = dateMaskedFormat.match(new RegExp(selectKey + "+"));
+        if (!skRest) {
+          return;
+        }
+        if (isUpArrow || isDwArrow) {
+          const chunkFormat = skRest[0] || "";
+          const chunkStartIndex = skRest.index || 0;
+          const chunkEndIndex = chunkStartIndex + chunkFormat.length;
+          const chunkValue = inpValue.slice(chunkStartIndex, chunkEndIndex);
+          if (parseInputKayMaps[selectKey]) {
+            const chunkNum = ((0, import_util.isAllSameChar)(chunkValue, maskChar) ? (0, import_util.getChunkDefaultNum)(selectKey) : import_xe_utils.default.toNumber(chunkValue)) + (isUpArrow ? 1 : -1);
+            const restValue = inpValue.slice(0, chunkStartIndex) + checkMaskedInputValue("" + chunkNum, chunkFormat, true) + inpValue.slice(chunkEndIndex);
+            evnt.preventDefault();
+            if (restValue.indexOf(maskChar) === -1) {
+              const inpDateVal = (0, import_util.parseDateValue)(restValue, type, {
+                valueFormat: dateLabelFormat
+              });
+              if (import_xe_utils.default.isValidDate(inpDateVal)) {
+                const label = import_xe_utils.default.toDateString(inpDateVal, dateLabelFormat, { firstDay: firstDayOfWeek });
+                targetElem.value = label;
+                handleInputLabel(label, false);
+              }
+            } else {
+              targetElem.value = restValue;
+              handleInputLabel(restValue, false);
+            }
+          }
+          targetElem.setSelectionRange(chunkStartIndex, chunkEndIndex);
+        } else if (isLtArrow || isRtArrow) {
+          const currKeyIndex = inputMaskedKeys.indexOf(selectKey);
+          if (currKeyIndex > -1) {
+            const allMaskedKeys = import_xe_utils.default.map(dateMaskedFormat.match(new RegExp(`(${inputMaskedKeys.join("|")})+`, "g")) || [], (fullKey) => fullKey[0]);
+            const currIndex = import_xe_utils.default.findIndexOf(allMaskedKeys, (key) => selectKey === key[0]);
+            const targetFormatKey = isLtArrow ? allMaskedKeys[currIndex - 1] || allMaskedKeys[0] : allMaskedKeys[currIndex + 1] || allMaskedKeys[allMaskedKeys.length - 1];
+            const targetKey = targetFormatKey ? targetFormatKey[0] : "";
+            const sktRest = dateMaskedFormat.match(new RegExp(targetKey + "+"));
+            if (sktRest) {
+              evnt.preventDefault();
+              const mtStartIndex = sktRest.index || 0;
+              const mtEndIndex = mtStartIndex + sktRest[0].length;
+              targetElem.setSelectionRange(mtStartIndex, mtEndIndex);
+            }
+          }
+        }
+        internalData.isTriggerMasked = true;
+      };
+      const handleMaskedInputDate = (evnt) => {
+        const { multiple } = props;
+        if (multiple) {
+          return;
+        }
+        const targetElem = refInputTarget.value;
+        if (!targetElem) {
+          return;
+        }
+        const isControlKey = (0, import_dom.hasControlKey)(evnt);
+        if (isControlKey) {
+          return;
+        }
+        evnt.preventDefault();
+        const eKey = evnt.key;
+        const isDeleleKey = globalEvents.hasKey(evnt, GLOBAL_EVENT_KEYS.DELETE);
+        const isBackspaceKey = globalEvents.hasKey(evnt, GLOBAL_EVENT_KEYS.BACKSPACE);
+        const isNumKey = eKey >= "0" && eKey <= "9";
+        const numKey = isNumKey ? evnt.key : "";
+        if (!(isDeleleKey || isBackspaceKey || isNumKey)) {
+          return;
+        }
+        const { isTriggerMasked } = internalData;
+        const maskedOpts = computeMaskedOpts.value;
+        const { align } = maskedOpts;
+        const dateMaskedFormat = computeDateMaskedFormat.value;
+        const maskChar = computeMaskChar.value;
+        let inpValue = targetElem.value || dateMaskedFormat;
+        const selectionStart = targetElem.selectionStart || 0;
+        const selectionEnd = targetElem.selectionEnd || 0;
+        let selectKey = dateMaskedFormat[selectionStart];
+        if (!parseInputKayMaps[selectKey]) {
+          selectKey = dateMaskedFormat[selectionStart - 1];
+        }
+        const skRest = dateMaskedFormat.match(new RegExp(selectKey + "+"));
+        if (!skRest) {
+          return;
+        }
+        const allMaskedKeys = import_xe_utils.default.map(dateMaskedFormat.match(new RegExp(`(${inputMaskedKeys.join("|")})+`, "g")) || [], (fullKey) => fullKey[0]);
         const chunkFormat = skRest[0] || "";
         const chunkStartIndex = skRest.index || 0;
         const chunkEndIndex = chunkStartIndex + chunkFormat.length;
-        const chunkValue = inpValue.slice(chunkStartIndex, chunkEndIndex);
-        if (parseInputKayMaps[selectKey]) {
-          const chunkNum = ((0, import_util.isAllSameChar)(chunkValue, maskChar) ? (0, import_util.getChunkDefaultNum)(selectKey) : import_xe_utils.default.toNumber(chunkValue)) + (isUpArrow ? 1 : -1);
-          const restValue = inpValue.slice(0, chunkStartIndex) + checkMaskedInputValue("" + chunkNum, chunkFormat, true) + inpValue.slice(chunkEndIndex);
-          evnt.preventDefault();
-          if (restValue.indexOf(maskChar) === -1) {
-            const inpDateVal = (0, import_util.parseDateValue)(restValue, type, {
-              valueFormat: dateLabelFormat
-            });
-            if (import_xe_utils.default.isValidDate(inpDateVal)) {
-              const label = import_xe_utils.default.toDateString(inpDateVal, dateLabelFormat, { firstDay: firstDayOfWeek });
-              targetElem.value = label;
-              handleInputLabel(label, false);
+        const currKeyIndex = allMaskedKeys.indexOf(selectKey);
+        const isAllSelected = !selectionStart && selectionEnd === inpValue.length && allMaskedKeys.length > 1;
+        const isNotMasked = inpValue && inpValue.length !== dateMaskedFormat.length;
+        if (isAllSelected || isNotMasked) {
+          inpValue = dateMaskedFormat;
+        }
+        let chunkValue = isDeleleKey ? "" : inpValue.slice(chunkStartIndex, chunkEndIndex);
+        const chunkNums = chunkValue.match(/\d/g) || [];
+        const chunkNumList = isTriggerMasked && !isBackspaceKey ? [] : chunkNums.slice(0);
+        if (isNumKey) {
+          chunkNumList.push(numKey);
+          chunkValue = checkMaskedInputValue(chunkNumList.join(""), chunkFormat, false);
+        } else if (isBackspaceKey) {
+          chunkNumList.pop();
+          chunkValue = import_xe_utils.default[align === "right" ? "padStart" : "padEnd"](chunkNumList.join(""), chunkFormat.length, maskChar);
+        }
+        let restValue = inpValue.slice(0, chunkStartIndex) + chunkValue + inpValue.slice(chunkEndIndex);
+        restValue = restValue.replace(new RegExp(`(${inputMaskedKeys.join("|")})`, "g"), maskChar);
+        targetElem.value = restValue;
+        handleInputLabel(restValue, false);
+        if (isAllSelected) {
+          if (isBackspaceKey || isDeleleKey) {
+            const firstMaskedKeys = allMaskedKeys[0];
+            const firstSkRest = dateMaskedFormat.match(new RegExp(`${firstMaskedKeys}+`));
+            if (firstSkRest) {
+              const firstChunkFormat = firstSkRest[0];
+              targetElem.setSelectionRange(0, firstChunkFormat.length);
+              internalData.isTriggerMasked = true;
+              return;
             }
-          } else {
-            targetElem.value = restValue;
-            handleInputLabel(restValue, false);
+          }
+        } else {
+          if (isBackspaceKey && !chunkNums.length) {
+            for (let i = currKeyIndex - 1; i >= 0; i--) {
+              const prveChunkKey = allMaskedKeys[i];
+              const prveSkRest = dateMaskedFormat.match(new RegExp(`${prveChunkKey}+`));
+              if (prveSkRest) {
+                const prveChunkFormat = prveSkRest[0];
+                const prveChunkStartIndex = prveSkRest.index || 0;
+                const prveChunkEndIndex = prveChunkStartIndex + prveChunkFormat.length;
+                let prveChunkValue = restValue.slice(prveChunkStartIndex, prveChunkEndIndex);
+                const prveChunkNums = prveChunkValue.match(/\d/g) || [];
+                if (prveChunkNums.length) {
+                  prveChunkNums.pop();
+                  prveChunkValue = import_xe_utils.default[align === "right" ? "padStart" : "padEnd"](prveChunkNums.join(""), prveChunkFormat.length, maskChar);
+                  restValue = restValue.slice(0, prveChunkStartIndex) + prveChunkValue + restValue.slice(prveChunkEndIndex);
+                  targetElem.value = restValue;
+                  handleInputLabel(restValue, false);
+                  targetElem.setSelectionRange(prveChunkStartIndex, prveChunkEndIndex);
+                  return;
+                }
+              }
+            }
+            const firstMaskedKeys = allMaskedKeys[0];
+            const firstSkRest = dateMaskedFormat.match(new RegExp(`${firstMaskedKeys}+`));
+            if (firstSkRest) {
+              const firstChunkFormat = firstSkRest[0];
+              restValue = dateMaskedFormat.replace(new RegExp(`(${inputMaskedKeys.join("|")})`, "g"), maskChar);
+              targetElem.value = restValue;
+              handleInputLabel(restValue, false);
+              targetElem.setSelectionRange(0, firstChunkFormat.length);
+              internalData.isTriggerMasked = true;
+              return;
+            }
+            return;
           }
         }
-        targetElem.setSelectionRange(chunkStartIndex, chunkEndIndex);
-      } else if (isLtArrow || isRtArrow) {
-        const currKeyIndex = inputMaskedKeys.indexOf(selectKey);
-        if (currKeyIndex > -1) {
-          const allMaskedKeys = import_xe_utils.default.map(dateMaskedFormat.match(new RegExp(`(${inputMaskedKeys.join("|")})+`, "g")) || [], (fullKey) => fullKey[0]);
-          const currIndex = import_xe_utils.default.findIndexOf(allMaskedKeys, (key) => selectKey === key[0]);
-          const targetFormatKey = isLtArrow ? allMaskedKeys[currIndex - 1] || allMaskedKeys[0] : allMaskedKeys[currIndex + 1] || allMaskedKeys[allMaskedKeys.length - 1];
-          const targetKey = targetFormatKey ? targetFormatKey[0] : "";
-          const sktRest = dateMaskedFormat.match(new RegExp(targetKey + "+"));
-          if (sktRest) {
-            evnt.preventDefault();
-            const mtStartIndex = sktRest.index || 0;
-            const mtEndIndex = mtStartIndex + sktRest[0].length;
-            targetElem.setSelectionRange(mtStartIndex, mtEndIndex);
+        let maskStartIndex = skRest.index || 0;
+        let maskEndIndex = maskStartIndex + skRest[0].length;
+        if (chunkNumList.length >= chunkValue.length) {
+          const nextKeys = allMaskedKeys.slice(currKeyIndex + 1);
+          if (currKeyIndex > -1) {
+            const nextRest = nextKeys.length ? dateMaskedFormat.match(new RegExp(`(${nextKeys.join("|")})+`)) : null;
+            if (nextRest) {
+              maskStartIndex = nextRest.index || 0;
+              maskEndIndex = maskStartIndex + nextRest[0].length;
+              targetElem.setSelectionRange(maskStartIndex, maskEndIndex);
+            } else {
+              targetElem.setSelectionRange(maskStartIndex, maskEndIndex);
+            }
           }
+          internalData.isTriggerMasked = true;
+          return;
+        }
+        targetElem.setSelectionRange(maskStartIndex, maskEndIndex);
+        internalData.isTriggerMasked = false;
+      };
+      const handleMaskedSelectedDate = (evnt, isFocus) => {
+        internalData.fsTimeout = void 0;
+        const { type, multiple, modelValue } = props;
+        if (multiple) {
+          return;
+        }
+        if (!maskedTypes.includes(type)) {
+          return;
         }
-      }
-      internalData.isTriggerMasked = true;
-    };
-    const handleMaskedInputDate = (evnt) => {
-      const { multiple } = props;
-      if (multiple) {
-        return;
-      }
-      const targetElem = refInputTarget.value;
-      if (!targetElem) {
-        return;
-      }
-      const isControlKey = (0, import_dom.hasControlKey)(evnt);
-      if (isControlKey) {
-        return;
-      }
-      evnt.preventDefault();
-      const eKey = evnt.key;
-      const isDeleleKey = globalEvents.hasKey(evnt, GLOBAL_EVENT_KEYS.DELETE);
-      const isBackspaceKey = globalEvents.hasKey(evnt, GLOBAL_EVENT_KEYS.BACKSPACE);
-      const isNumKey = eKey >= "0" && eKey <= "9";
-      const numKey = isNumKey ? evnt.key : "";
-      if (!(isDeleleKey || isBackspaceKey || isNumKey)) {
-        return;
-      }
-      const { isTriggerMasked } = internalData;
-      const maskedOpts = computeMaskedOpts.value;
-      const { align } = maskedOpts;
-      const dateMaskedFormat = computeDateMaskedFormat.value;
-      const maskChar = computeMaskChar.value;
-      let inpValue = targetElem.value || dateMaskedFormat;
-      const selectionStart = targetElem.selectionStart || 0;
-      const selectionEnd = targetElem.selectionEnd || 0;
-      let selectKey = dateMaskedFormat[selectionStart];
-      if (!parseInputKayMaps[selectKey]) {
-        selectKey = dateMaskedFormat[selectionStart - 1];
-      }
-      const skRest = dateMaskedFormat.match(new RegExp(selectKey + "+"));
-      if (!skRest) {
-        return;
-      }
-      const allMaskedKeys = import_xe_utils.default.map(dateMaskedFormat.match(new RegExp(`(${inputMaskedKeys.join("|")})+`, "g")) || [], (fullKey) => fullKey[0]);
-      const chunkFormat = skRest[0] || "";
-      const chunkStartIndex = skRest.index || 0;
-      const chunkEndIndex = chunkStartIndex + chunkFormat.length;
-      const currKeyIndex = allMaskedKeys.indexOf(selectKey);
-      const isAllSelected = !selectionStart && selectionEnd === inpValue.length && allMaskedKeys.length > 1;
-      const isNotMasked = inpValue && inpValue.length !== dateMaskedFormat.length;
-      if (isAllSelected || isNotMasked) {
-        inpValue = dateMaskedFormat;
-      }
-      let chunkValue = isDeleleKey ? "" : inpValue.slice(chunkStartIndex, chunkEndIndex);
-      const chunkNums = chunkValue.match(/\d/g) || [];
-      const chunkNumList = isTriggerMasked && !isBackspaceKey ? [] : chunkNums.slice(0);
-      if (isNumKey) {
-        chunkNumList.push(numKey);
-        chunkValue = checkMaskedInputValue(chunkNumList.join(""), chunkFormat, false);
-      } else if (isBackspaceKey) {
-        chunkNumList.pop();
-        chunkValue = import_xe_utils.default[align === "right" ? "padStart" : "padEnd"](chunkNumList.join(""), chunkFormat.length, maskChar);
-      }
-      let restValue = inpValue.slice(0, chunkStartIndex) + chunkValue + inpValue.slice(chunkEndIndex);
-      restValue = restValue.replace(new RegExp(`(${inputMaskedKeys.join("|")})`, "g"), maskChar);
-      targetElem.value = restValue;
-      handleInputLabel(restValue, false);
-      if (isAllSelected) {
-        if (isBackspaceKey || isDeleleKey) {
+        const targetElem = refInputTarget.value;
+        if (!targetElem) {
+          return;
+        }
+        const { laseFocusMasked } = internalData;
+        if (laseFocusMasked && Date.now() - laseFocusMasked < 100) {
+          return;
+        }
+        const dateMaskedFormat = computeDateMaskedFormat.value;
+        const maskChar = computeMaskChar.value;
+        const selectionStart = targetElem.selectionStart || 0;
+        const selectionEnd = targetElem.selectionEnd || 0;
+        const inpValue = targetElem.value;
+        const allMaskedKeys = import_xe_utils.default.map(dateMaskedFormat.match(new RegExp(`(${inputMaskedKeys.join("|")})+`, "g")) || [], (fullKey) => fullKey[0]);
+        if (!inpValue) {
+          let restValue = dateMaskedFormat.replace(new RegExp(`(${inputMaskedKeys.join("|")})`, "g"), maskChar);
+          if (isFocus && modelValue) {
+            const chunkNums = ("" + import_xe_utils.default.toNumber(modelValue)).match(/\d/g) || [];
+            let useNumIndex = 0;
+            restValue = dateMaskedFormat.replace(new RegExp(`(${inputMaskedKeys.join("|")})`, "g"), (txt) => chunkNums[useNumIndex++] || txt);
+          }
           const firstMaskedKeys = allMaskedKeys[0];
           const firstSkRest = dateMaskedFormat.match(new RegExp(`${firstMaskedKeys}+`));
           if (firstSkRest) {
+            evnt.preventDefault();
             const firstChunkFormat = firstSkRest[0];
+            targetElem.value = restValue;
+            handleInputLabel(restValue, false);
             targetElem.setSelectionRange(0, firstChunkFormat.length);
-            internalData.isTriggerMasked = true;
+            internalData.laseFocusMasked = Date.now();
             return;
           }
         }
-      } else {
-        if (isBackspaceKey && !chunkNums.length) {
-          for (let i = currKeyIndex - 1; i >= 0; i--) {
-            const prveChunkKey = allMaskedKeys[i];
-            const prveSkRest = dateMaskedFormat.match(new RegExp(`${prveChunkKey}+`));
-            if (prveSkRest) {
-              const prveChunkFormat = prveSkRest[0];
-              const prveChunkStartIndex = prveSkRest.index || 0;
-              const prveChunkEndIndex = prveChunkStartIndex + prveChunkFormat.length;
-              let prveChunkValue = restValue.slice(prveChunkStartIndex, prveChunkEndIndex);
-              const prveChunkNums = prveChunkValue.match(/\d/g) || [];
-              if (prveChunkNums.length) {
-                prveChunkNums.pop();
-                prveChunkValue = import_xe_utils.default[align === "right" ? "padStart" : "padEnd"](prveChunkNums.join(""), prveChunkFormat.length, maskChar);
-                restValue = restValue.slice(0, prveChunkStartIndex) + prveChunkValue + restValue.slice(prveChunkEndIndex);
-                targetElem.value = restValue;
-                handleInputLabel(restValue, false);
-                targetElem.setSelectionRange(prveChunkStartIndex, prveChunkEndIndex);
-                return;
-              }
-            }
+        const isAllSelected = !selectionStart && selectionEnd === inpValue.length && allMaskedKeys.length > 1;
+        const isNotMasked = inpValue && inpValue.length !== dateMaskedFormat.length;
+        if (isAllSelected || isNotMasked) {
+          let restValue = "";
+          if (isNotMasked && inpValue) {
+            const chunkNums = inpValue.match(/\d/g) || [];
+            let useNumIndex = 0;
+            restValue = dateMaskedFormat.replace(new RegExp(`(${inputMaskedKeys.join("|")})`, "g"), () => chunkNums[useNumIndex++] || maskChar);
+          } else {
+            dateMaskedFormat.replace(new RegExp(`(${inputMaskedKeys.join("|")})`, "g"), maskChar);
           }
           const firstMaskedKeys = allMaskedKeys[0];
           const firstSkRest = dateMaskedFormat.match(new RegExp(`${firstMaskedKeys}+`));
           if (firstSkRest) {
+            evnt.preventDefault();
             const firstChunkFormat = firstSkRest[0];
-            restValue = dateMaskedFormat.replace(new RegExp(`(${inputMaskedKeys.join("|")})`, "g"), maskChar);
             targetElem.value = restValue;
             handleInputLabel(restValue, false);
             targetElem.setSelectionRange(0, firstChunkFormat.length);
-            internalData.isTriggerMasked = true;
+            internalData.laseFocusMasked = Date.now();
             return;
           }
-          return;
         }
-      }
-      let maskStartIndex = skRest.index || 0;
-      let maskEndIndex = maskStartIndex + skRest[0].length;
-      if (chunkNumList.length >= chunkValue.length) {
-        const nextKeys = allMaskedKeys.slice(currKeyIndex + 1);
-        if (currKeyIndex > -1) {
-          const nextRest = nextKeys.length ? dateMaskedFormat.match(new RegExp(`(${nextKeys.join("|")})+`)) : null;
-          if (nextRest) {
-            maskStartIndex = nextRest.index || 0;
-            maskEndIndex = maskStartIndex + nextRest[0].length;
-            targetElem.setSelectionRange(maskStartIndex, maskEndIndex);
-          } else {
-            targetElem.setSelectionRange(maskStartIndex, maskEndIndex);
+        let selectKey = dateMaskedFormat[selectionStart];
+        if (!parseInputKayMaps[selectKey]) {
+          selectKey = dateMaskedFormat[selectionStart - 1];
+        }
+        if (selectKey) {
+          evnt.stopPropagation();
+          const skRest = dateMaskedFormat.match(new RegExp(selectKey + "+"));
+          if (skRest) {
+            const chunkFormat = skRest[0] || "";
+            const chunkStartIndex = skRest.index || 0;
+            const chunkEndIndex = chunkStartIndex + chunkFormat.length;
+            targetElem.setSelectionRange(chunkStartIndex, chunkEndIndex);
+            internalData.isTriggerMasked = true;
+            internalData.laseFocusMasked = Date.now();
           }
         }
-        internalData.isTriggerMasked = true;
-        return;
-      }
-      targetElem.setSelectionRange(maskStartIndex, maskEndIndex);
-      internalData.isTriggerMasked = false;
-    };
-    const handleMaskedSelectedDate = (evnt, isFocus) => {
-      internalData.fsTimeout = void 0;
-      const { type, multiple, modelValue } = props;
-      if (multiple) {
-        return;
-      }
-      if (!maskedTypes.includes(type)) {
-        return;
-      }
-      const targetElem = refInputTarget.value;
-      if (!targetElem) {
-        return;
-      }
-      const { laseFocusMasked } = internalData;
-      if (laseFocusMasked && Date.now() - laseFocusMasked < 100) {
-        return;
-      }
-      const dateMaskedFormat = computeDateMaskedFormat.value;
-      const maskChar = computeMaskChar.value;
-      const selectionStart = targetElem.selectionStart || 0;
-      const selectionEnd = targetElem.selectionEnd || 0;
-      const inpValue = targetElem.value;
-      const allMaskedKeys = import_xe_utils.default.map(dateMaskedFormat.match(new RegExp(`(${inputMaskedKeys.join("|")})+`, "g")) || [], (fullKey) => fullKey[0]);
-      if (!inpValue) {
-        let restValue = dateMaskedFormat.replace(new RegExp(`(${inputMaskedKeys.join("|")})`, "g"), maskChar);
-        if (isFocus && modelValue) {
-          const chunkNums = ("" + import_xe_utils.default.toNumber(modelValue)).match(/\d/g) || [];
-          let useNumIndex = 0;
-          restValue = dateMaskedFormat.replace(new RegExp(`(${inputMaskedKeys.join("|")})`, "g"), (txt) => chunkNums[useNumIndex++] || txt);
-        }
-        const firstMaskedKeys = allMaskedKeys[0];
-        const firstSkRest = dateMaskedFormat.match(new RegExp(`${firstMaskedKeys}+`));
-        if (firstSkRest) {
-          evnt.preventDefault();
-          const firstChunkFormat = firstSkRest[0];
-          targetElem.value = restValue;
-          handleInputLabel(restValue, false);
-          targetElem.setSelectionRange(0, firstChunkFormat.length);
-          internalData.laseFocusMasked = Date.now();
-          return;
+      };
+      const blurEvent = (evnt) => {
+        const { inputValue } = reactData;
+        const inpImmediate = computeInpImmediate.value;
+        const value = inputValue;
+        if (!inpImmediate) {
+          handleChange(value, evnt);
         }
-      }
-      const isAllSelected = !selectionStart && selectionEnd === inpValue.length && allMaskedKeys.length > 1;
-      const isNotMasked = inpValue && inpValue.length !== dateMaskedFormat.length;
-      if (isAllSelected || isNotMasked) {
-        let restValue = "";
-        if (isNotMasked && inpValue) {
-          const chunkNums = inpValue.match(/\d/g) || [];
-          let useNumIndex = 0;
-          restValue = dateMaskedFormat.replace(new RegExp(`(${inputMaskedKeys.join("|")})`, "g"), () => chunkNums[useNumIndex++] || maskChar);
-        } else {
-          dateMaskedFormat.replace(new RegExp(`(${inputMaskedKeys.join("|")})`, "g"), maskChar);
+        if (!reactData.visiblePanel) {
+          const { inputLabel } = internalData;
+          reactData.isActivated = false;
+          afterCheckValue(inputLabel);
         }
-        const firstMaskedKeys = allMaskedKeys[0];
-        const firstSkRest = dateMaskedFormat.match(new RegExp(`${firstMaskedKeys}+`));
-        if (firstSkRest) {
-          evnt.preventDefault();
-          const firstChunkFormat = firstSkRest[0];
-          targetElem.value = restValue;
-          handleInputLabel(restValue, false);
-          targetElem.setSelectionRange(0, firstChunkFormat.length);
-          internalData.laseFocusMasked = Date.now();
-          return;
+        dispatchEvent("blur", { value }, evnt);
+        if ($xeForm && formItemInfo) {
+          $xeForm.triggerItemEvent(evnt, formItemInfo.itemConfig.field, value);
+        }
+      };
+      const focusEvent = (evnt) => {
+        const { multiple, editable, maskedConfig } = props;
+        const { fsTimeout } = internalData;
+        const maskedOpts = computeMaskedOpts.value;
+        const popupOpts = computePopupOpts.value;
+        const { trigger } = popupOpts;
+        reactData.isActivated = true;
+        if (fsTimeout) {
+          clearTimeout(fsTimeout);
+        }
+        if (!trigger || trigger === "default") {
+          datePickerOpenEvent(evnt);
+        } else if (trigger === "icon") {
+          hidePanel();
+        }
+        if (editable && !multiple && ((0, import_utils.isEnableConf)(maskedConfig) || maskedOpts.enabled)) {
+          internalData.fsTimeout = setTimeout(() => {
+            handleMaskedSelectedDate(evnt, true);
+          }, 20);
+        }
+        triggerEvent(evnt);
+      };
+      const clickEvent = (evnt) => {
+        const { multiple, editable, maskedConfig } = props;
+        const { fsTimeout } = internalData;
+        const maskedOpts = computeMaskedOpts.value;
+        if (fsTimeout) {
+          clearTimeout(fsTimeout);
+        }
+        if (editable && !multiple && ((0, import_utils.isEnableConf)(maskedConfig) || maskedOpts.enabled)) {
+          internalData.fsTimeout = setTimeout(() => {
+            handleMaskedSelectedDate(evnt);
+          }, 10);
+        }
+        triggerEvent(evnt);
+      };
+      const keydownEvent = (evnt) => {
+        const { type, editable, maskedConfig } = props;
+        const { visiblePanel } = reactData;
+        const maskedOpts = computeMaskedOpts.value;
+        const isUpArrow = globalEvents.hasKey(evnt, GLOBAL_EVENT_KEYS.ARROW_UP);
+        const isDwArrow = globalEvents.hasKey(evnt, GLOBAL_EVENT_KEYS.ARROW_DOWN);
+        const isLtArrow = globalEvents.hasKey(evnt, GLOBAL_EVENT_KEYS.ARROW_LEFT);
+        const isRtArrow = globalEvents.hasKey(evnt, GLOBAL_EVENT_KEYS.ARROW_RIGHT);
+        const isEnter = globalEvents.hasKey(evnt, GLOBAL_EVENT_KEYS.ENTER);
+        if (editable) {
+          if (isEnter) {
+            const { inputLabel } = internalData;
+            if (visiblePanel) {
+              hidePanel();
+            }
+            afterCheckValue(inputLabel);
+          } else if (maskedTypes.includes(type)) {
+            if ((0, import_utils.isEnableConf)(maskedConfig) || maskedOpts.enabled) {
+              if (maskedOpts.isArrow && (isUpArrow || isDwArrow || isLtArrow || isRtArrow)) {
+                handleArrowInputDate(evnt, isUpArrow, isDwArrow, isLtArrow, isRtArrow);
+              } else if (maskedOpts.isMasked) {
+                handleMaskedInputDate(evnt);
+              }
+            }
+          }
+        }
+        triggerEvent(evnt);
+      };
+      const keyupEvent = (evnt) => {
+        triggerEvent(evnt);
+      };
+      const confirmEvent = (evnt) => {
+        const $datePanel = refDatePanel.value;
+        if ($datePanel) {
+          $datePanel.confirmByEvent(evnt);
         }
-      }
-      let selectKey = dateMaskedFormat[selectionStart];
-      if (!parseInputKayMaps[selectKey]) {
-        selectKey = dateMaskedFormat[selectionStart - 1];
-      }
-      if (selectKey) {
-        evnt.stopPropagation();
-        const skRest = dateMaskedFormat.match(new RegExp(selectKey + "+"));
-        if (skRest) {
-          const chunkFormat = skRest[0] || "";
-          const chunkStartIndex = skRest.index || 0;
-          const chunkEndIndex = chunkStartIndex + chunkFormat.length;
-          targetElem.setSelectionRange(chunkStartIndex, chunkEndIndex);
-          internalData.isTriggerMasked = true;
-          internalData.laseFocusMasked = Date.now();
-        }
-      }
-    };
-    const blurEvent = (evnt) => {
-      const { inputValue } = reactData;
-      const inpImmediate = computeInpImmediate.value;
-      const value = inputValue;
-      if (!inpImmediate) {
-        handleChange(value, evnt);
-      }
-      if (!reactData.visiblePanel) {
-        const { inputLabel } = internalData;
-        reactData.isActivated = false;
-        afterCheckValue(inputLabel);
-      }
-      dispatchEvent("blur", { value }, evnt);
-      if ($xeForm && formItemInfo) {
-        $xeForm.triggerItemEvent(evnt, formItemInfo.itemConfig.field, value);
-      }
-    };
-    const focusEvent = (evnt) => {
-      const { multiple, editable, maskedConfig } = props;
-      const { fsTimeout } = internalData;
-      const maskedOpts = computeMaskedOpts.value;
-      const popupOpts = computePopupOpts.value;
-      const { trigger } = popupOpts;
-      reactData.isActivated = true;
-      if (fsTimeout) {
-        clearTimeout(fsTimeout);
-      }
-      if (!trigger || trigger === "default") {
-        datePickerOpenEvent(evnt);
-      } else if (trigger === "icon") {
         hidePanel();
-      }
-      if (editable && !multiple && ((0, import_utils.isEnableConf)(maskedConfig) || maskedOpts.enabled)) {
-        internalData.fsTimeout = setTimeout(() => {
-          handleMaskedSelectedDate(evnt, true);
-        }, 20);
-      }
-      triggerEvent(evnt);
-    };
-    const clickEvent = (evnt) => {
-      const { multiple, editable, maskedConfig } = props;
-      const { fsTimeout } = internalData;
-      const maskedOpts = computeMaskedOpts.value;
-      if (fsTimeout) {
-        clearTimeout(fsTimeout);
-      }
-      if (editable && !multiple && ((0, import_utils.isEnableConf)(maskedConfig) || maskedOpts.enabled)) {
-        internalData.fsTimeout = setTimeout(() => {
-          handleMaskedSelectedDate(evnt);
-        }, 10);
-      }
-      triggerEvent(evnt);
-    };
-    const keydownEvent = (evnt) => {
-      const { type, editable, maskedConfig } = props;
-      const { visiblePanel } = reactData;
-      const maskedOpts = computeMaskedOpts.value;
-      const isUpArrow = globalEvents.hasKey(evnt, GLOBAL_EVENT_KEYS.ARROW_UP);
-      const isDwArrow = globalEvents.hasKey(evnt, GLOBAL_EVENT_KEYS.ARROW_DOWN);
-      const isLtArrow = globalEvents.hasKey(evnt, GLOBAL_EVENT_KEYS.ARROW_LEFT);
-      const isRtArrow = globalEvents.hasKey(evnt, GLOBAL_EVENT_KEYS.ARROW_RIGHT);
-      const isEnter = globalEvents.hasKey(evnt, GLOBAL_EVENT_KEYS.ENTER);
-      if (editable) {
-        if (isEnter) {
-          const { inputLabel } = internalData;
-          if (visiblePanel) {
+      };
+      const panelChangeEvent = (params) => {
+        const { multiple, autoClose } = props;
+        const { value, $event } = params;
+        const isTimeOrDateTimeType = computeIsTimeOrDateTimeType.value;
+        handleChange(value, $event);
+        if (!multiple && !isTimeOrDateTimeType) {
+          if (autoClose) {
             hidePanel();
           }
-          afterCheckValue(inputLabel);
-        } else if (maskedTypes.includes(type)) {
-          if ((0, import_utils.isEnableConf)(maskedConfig) || maskedOpts.enabled) {
-            if (maskedOpts.isArrow && (isUpArrow || isDwArrow || isLtArrow || isRtArrow)) {
-              handleArrowInputDate(evnt, isUpArrow, isDwArrow, isLtArrow, isRtArrow);
-            } else if (maskedOpts.isMasked) {
-              handleMaskedInputDate(evnt);
+        }
+      };
+      const panelConfirmEvent = (params) => {
+        dispatchEvent("confirm", params, params.$event);
+      };
+      const panelRevertEvent = (params) => {
+        handleInputLabel(params.label, true);
+      };
+      const handleGlobalMousedownEvent = (evnt) => {
+        const { visiblePanel, isActivated } = reactData;
+        const el = refElem.value;
+        const panelWrapperElem = refPanelWrapper.value;
+        const isDisabled = computeIsDisabled.value;
+        if (!isDisabled && isActivated) {
+          const currActivated = (0, import_dom.getEventTargetNode)(evnt, el).flag || (0, import_dom.getEventTargetNode)(evnt, panelWrapperElem).flag;
+          if (currActivated !== isActivated) {
+            reactData.isActivated = currActivated;
+          }
+          if (!currActivated) {
+            if (visiblePanel) {
+              hidePanel();
+              const { inputLabel } = internalData;
+              afterCheckValue(inputLabel);
             }
           }
         }
-      }
-      triggerEvent(evnt);
-    };
-    const keyupEvent = (evnt) => {
-      triggerEvent(evnt);
-    };
-    const confirmEvent = (evnt) => {
-      const $datePanel = refDatePanel.value;
-      if ($datePanel) {
-        $datePanel.confirmByEvent(evnt);
-      }
-      hidePanel();
-    };
-    const panelChangeEvent = (params) => {
-      const { multiple, autoClose } = props;
-      const { value, $event } = params;
-      const isTimeOrDateTimeType = computeIsTimeOrDateTimeType.value;
-      handleChange(value, $event);
-      if (!multiple && !isTimeOrDateTimeType) {
-        if (autoClose) {
-          hidePanel();
-        }
-      }
-    };
-    const panelConfirmEvent = (params) => {
-      dispatchEvent("confirm", params, params.$event);
-    };
-    const panelRevertEvent = (params) => {
-      handleInputLabel(params.label, true);
-    };
-    const handleGlobalMousedownEvent = (evnt) => {
-      const { visiblePanel, isActivated } = reactData;
-      const el = refElem.value;
-      const panelWrapperElem = refPanelWrapper.value;
-      const isDisabled = computeIsDisabled.value;
-      if (!isDisabled && isActivated) {
-        const currActivated = (0, import_dom.getEventTargetNode)(evnt, el).flag || (0, import_dom.getEventTargetNode)(evnt, panelWrapperElem).flag;
-        if (currActivated !== isActivated) {
-          reactData.isActivated = currActivated;
-        }
-        if (!currActivated) {
+      };
+      const handleGlobalKeydownEvent = (evnt) => {
+        const { isActivated, visiblePanel } = reactData;
+        const isDisabled = computeIsDisabled.value;
+        if (!isDisabled) {
+          const isTab = globalEvents.hasKey(evnt, GLOBAL_EVENT_KEYS.TAB);
+          const isEsc = globalEvents.hasKey(evnt, GLOBAL_EVENT_KEYS.ESCAPE);
+          if (isTab) {
+            if (isActivated) {
+              reactData.isActivated = false;
+            }
+          }
           if (visiblePanel) {
-            hidePanel();
-            const { inputLabel } = internalData;
-            afterCheckValue(inputLabel);
+            if (isEsc || isTab) {
+              hidePanel();
+            }
           }
         }
-      }
-    };
-    const handleGlobalKeydownEvent = (evnt) => {
-      const { isActivated, visiblePanel } = reactData;
-      const isDisabled = computeIsDisabled.value;
-      if (!isDisabled) {
-        const isTab = globalEvents.hasKey(evnt, GLOBAL_EVENT_KEYS.TAB);
-        const isEsc = globalEvents.hasKey(evnt, GLOBAL_EVENT_KEYS.ESCAPE);
-        if (isTab) {
-          if (isActivated) {
-            reactData.isActivated = false;
+      };
+      const handleGlobalBlurEvent = () => {
+        const { isActivated, visiblePanel } = reactData;
+        if (visiblePanel) {
+          hidePanel();
+        }
+        if (isActivated) {
+          reactData.isActivated = false;
+        }
+        if (visiblePanel || isActivated) {
+          afterCheckValue(internalData.inputLabel);
+          const targetElem = refInputTarget.value;
+          if (targetElem) {
+            targetElem.blur();
           }
         }
+      };
+      const handleGlobalResizeEvent = () => {
+        const { visiblePanel } = reactData;
         if (visiblePanel) {
-          if (isEsc || isTab) {
-            hidePanel();
-          }
+          updatePlacement();
         }
-      }
-    };
-    const handleGlobalBlurEvent = () => {
-      const { isActivated, visiblePanel } = reactData;
-      if (visiblePanel) {
-        hidePanel();
-      }
-      if (isActivated) {
-        reactData.isActivated = false;
-      }
-      if (visiblePanel || isActivated) {
-        afterCheckValue(internalData.inputLabel);
+      };
+      const handleGlobalScrollEvent = () => {
+        const { visiblePanel } = reactData;
+        if (visiblePanel) {
+          updatePlacement();
+        }
+      };
+      const updateZindex = () => {
+        const popupOpts = computePopupOpts.value;
+        const customZIndex = popupOpts.zIndex || props.zIndex;
+        if (customZIndex) {
+          reactData.panelIndex = import_xe_utils.default.toNumber(customZIndex);
+        } else if (reactData.panelIndex < (0, import_utils.getLastZIndex)()) {
+          reactData.panelIndex = (0, import_utils.nextZIndex)();
+        }
+      };
+      const updatePlacement = () => {
+        const { placement } = props;
+        const { panelIndex } = reactData;
         const targetElem = refInputTarget.value;
-        if (targetElem) {
-          targetElem.blur();
-        }
-      }
-    };
-    const handleGlobalResizeEvent = () => {
-      const { visiblePanel } = reactData;
-      if (visiblePanel) {
-        updatePlacement();
-      }
-    };
-    const handleGlobalScrollEvent = () => {
-      const { visiblePanel } = reactData;
-      if (visiblePanel) {
-        updatePlacement();
-      }
-    };
-    const updateZindex = () => {
-      const popupOpts = computePopupOpts.value;
-      const customZIndex = popupOpts.zIndex || props.zIndex;
-      if (customZIndex) {
-        reactData.panelIndex = import_xe_utils.default.toNumber(customZIndex);
-      } else if (reactData.panelIndex < (0, import_utils.getLastZIndex)()) {
-        reactData.panelIndex = (0, import_utils.nextZIndex)();
-      }
-    };
-    const updatePlacement = () => {
-      const { placement } = props;
-      const { panelIndex } = reactData;
-      const targetElem = refInputTarget.value;
-      const panelElem = refInputPanel.value;
-      if (!panelElem) {
+        const panelElem = refInputPanel.value;
+        if (!panelElem) {
+          return (0, import_vue.nextTick)();
+        }
+        const btnTransfer = computeBtnTransfer.value;
+        const popupOpts = computePopupOpts.value;
+        const handleStyle = () => {
+          const ppObj = (0, import_dom.updatePanelPlacement)(targetElem, panelElem, {
+            placement: popupOpts.placement || placement,
+            defaultPlacement: popupOpts.defaultPlacement,
+            appendTo: popupOpts.appendTo,
+            teleportTo: btnTransfer
+          });
+          const panelStyle = Object.assign(ppObj.style, {
+            zIndex: panelIndex
+          });
+          reactData.panelStyle = panelStyle;
+          reactData.panelPlacement = ppObj.placement;
+        };
+        handleStyle();
+        return (0, import_vue.nextTick)().then(handleStyle);
+      };
+      const showPanel = () => {
+        const { visiblePanel } = reactData;
+        const isDisabled = computeIsDisabled.value;
+        if (!isDisabled && !visiblePanel) {
+          if (!reactData.initialized) {
+            reactData.initialized = true;
+          }
+          if (internalData.hpTimeout) {
+            clearTimeout(internalData.hpTimeout);
+            internalData.hpTimeout = void 0;
+          }
+          reactData.isActivated = true;
+          reactData.isAniVisible = true;
+          setTimeout(() => {
+            reactData.visiblePanel = true;
+            updatePlacement();
+          }, 10);
+          updateZindex();
+          return updatePlacement();
+        }
         return (0, import_vue.nextTick)();
-      }
-      const btnTransfer = computeBtnTransfer.value;
-      const popupOpts = computePopupOpts.value;
-      const handleStyle = () => {
-        const ppObj = (0, import_dom.updatePanelPlacement)(targetElem, panelElem, {
-          placement: popupOpts.placement || placement,
-          defaultPlacement: popupOpts.defaultPlacement,
-          appendTo: popupOpts.appendTo,
-          teleportTo: btnTransfer
-        });
-        const panelStyle = Object.assign(ppObj.style, {
-          zIndex: panelIndex
-        });
-        reactData.panelStyle = panelStyle;
-        reactData.panelPlacement = ppObj.placement;
       };
-      handleStyle();
-      return (0, import_vue.nextTick)().then(handleStyle);
-    };
-    const showPanel = () => {
-      const { visiblePanel } = reactData;
-      const isDisabled = computeIsDisabled.value;
-      if (!isDisabled && !visiblePanel) {
-        if (!reactData.initialized) {
-          reactData.initialized = true;
-        }
-        if (internalData.hpTimeout) {
-          clearTimeout(internalData.hpTimeout);
-          internalData.hpTimeout = void 0;
+      const datePickerOpenEvent = (evnt) => {
+        const formReadonly = computeFormReadonly.value;
+        if (!formReadonly) {
+          evnt.preventDefault();
+          showPanel();
         }
-        reactData.isActivated = true;
-        reactData.isAniVisible = true;
-        setTimeout(() => {
-          reactData.visiblePanel = true;
-          updatePlacement();
-        }, 10);
-        updateZindex();
-        return updatePlacement();
-      }
-      return (0, import_vue.nextTick)();
-    };
-    const datePickerOpenEvent = (evnt) => {
-      const formReadonly = computeFormReadonly.value;
-      if (!formReadonly) {
-        evnt.preventDefault();
-        showPanel();
-      }
-    };
-    const clickIconEvent = (evnt) => {
-      const { visiblePanel } = reactData;
-      const popupOpts = computePopupOpts.value;
-      const { trigger } = popupOpts;
-      if (!trigger || trigger === "default" || trigger === "icon") {
-        if (visiblePanel) {
-          hidePanel();
-        } else {
-          datePickerOpenEvent(evnt);
+      };
+      const clickIconEvent = (evnt) => {
+        const { visiblePanel } = reactData;
+        const popupOpts = computePopupOpts.value;
+        const { trigger } = popupOpts;
+        if (!trigger || trigger === "default" || trigger === "icon") {
+          if (visiblePanel) {
+            hidePanel();
+          } else {
+            datePickerOpenEvent(evnt);
+          }
         }
-      }
-    };
-    const handleShortcutEvent = ({ option, $event }) => {
-      const { type } = props;
-      const { inputValue } = reactData;
-      const shortcutOpts = computeShortcutOpts.value;
-      const { autoClose } = shortcutOpts;
-      const { code, clickMethod } = option;
-      let value = inputValue;
-      const shortcutParams = {
-        $datePicker: $xeDatePicker,
-        option,
-        value,
-        code
       };
-      if (!clickMethod && code) {
-        const gCommandOpts = commands.get(code);
-        const dpCommandMethod = gCommandOpts ? gCommandOpts.datePickerCommandMethod : null;
-        if (dpCommandMethod) {
-          dpCommandMethod(shortcutParams);
-        } else {
-          const dateValueFormat = computeDateValueFormat.value;
-          const firstDayOfWeek = computeFirstDayOfWeek.value;
-          switch (code) {
-            case "now":
-            case "prev":
-            case "next":
-            case "minus":
-            case "plus": {
-              const restObj = (0, import_util.getDateByCode)(code, value, type, {
-                valueFormat: dateValueFormat,
-                firstDay: firstDayOfWeek
-              });
-              value = restObj.value;
-              shortcutParams.value = value;
-              handleChange(value, $event);
-              break;
+      const handleShortcutEvent = ({ option, $event }) => {
+        const { type } = props;
+        const { inputValue } = reactData;
+        const shortcutOpts = computeShortcutOpts.value;
+        const { autoClose } = shortcutOpts;
+        const { code, clickMethod } = option;
+        let value = inputValue;
+        const shortcutParams = {
+          $datePicker: $xeDatePicker,
+          option,
+          value,
+          code
+        };
+        if (!clickMethod && code) {
+          const gCommandOpts = commands.get(code);
+          const dpCommandMethod = gCommandOpts ? gCommandOpts.datePickerCommandMethod : null;
+          if (dpCommandMethod) {
+            dpCommandMethod(shortcutParams);
+          } else {
+            const dateValueFormat = computeDateValueFormat.value;
+            const firstDayOfWeek = computeFirstDayOfWeek.value;
+            switch (code) {
+              case "now":
+              case "prev":
+              case "next":
+              case "minus":
+              case "plus": {
+                const restObj = (0, import_util.getDateByCode)(code, value, type, {
+                  valueFormat: dateValueFormat,
+                  firstDay: firstDayOfWeek
+                });
+                value = restObj.value;
+                shortcutParams.value = value;
+                handleChange(value, $event);
+                break;
+              }
+              default:
+                errLog("vxe.error.notCommands", [code]);
+                break;
             }
-            default:
-              errLog("vxe.error.notCommands", [code]);
-              break;
+          }
+        } else {
+          const optClickMethod = clickMethod || shortcutOpts.clickMethod;
+          if (optClickMethod) {
+            optClickMethod(shortcutParams);
           }
         }
-      } else {
-        const optClickMethod = clickMethod || shortcutOpts.clickMethod;
-        if (optClickMethod) {
-          optClickMethod(shortcutParams);
+        if (autoClose) {
+          hidePanel();
         }
-      }
-      if (autoClose) {
-        hidePanel();
-      }
-      dispatchEvent("shortcut-click", shortcutParams, $event);
-    };
-    const dispatchEvent = (type, params, evnt) => {
-      emit(type, createEvent(evnt, { $datePicker: $xeDatePicker }, params));
-    };
-    const emitModel = (value) => {
-      emit("update:modelValue", value);
-    };
-    const datePickerMethods = {
-      dispatchEvent,
-      setModelValue(value) {
-        reactData.inputValue = value;
-        emitModel(value);
-      },
-      setModelValueByEvent(evnt, value) {
-        handleChange(value || "", evnt);
-      },
-      focus() {
-        const inputElem = refInputTarget.value;
-        reactData.isActivated = true;
-        inputElem.focus();
-        return (0, import_vue.nextTick)();
-      },
-      blur() {
-        const inputElem = refInputTarget.value;
-        inputElem.blur();
-        reactData.isActivated = false;
-        return (0, import_vue.nextTick)();
-      },
-      select() {
-        const inputElem = refInputTarget.value;
-        inputElem.select();
-        reactData.isActivated = false;
-        return (0, import_vue.nextTick)();
-      },
-      showPanel,
-      hidePanel,
-      updatePlacement
-    };
-    Object.assign($xeDatePicker, datePickerMethods);
-    const renderShortcutBtn = (pos, isVertical) => {
-      const shortcutOpts = computeShortcutOpts.value;
-      const { position, align, mode } = shortcutOpts;
-      const shortcutList = computeShortcutList.value;
-      if ((0, import_utils.isEnableConf)(shortcutOpts) && shortcutList.length && (position || "left") === pos) {
-        return (0, import_vue.h)(
-          "div",
-          {
-            class: `vxe-date-picker--layout-${pos}-wrapper`
-          },
-          [
-            (0, import_vue.h)(import_button_group.default, {
-              options: shortcutList,
-              mode,
-              align,
-              vertical: isVertical,
-              onClick: handleShortcutEvent
-            })
-          ]
-        );
-      }
-      return renderEmptyElement($xeDatePicker);
-    };
-    const renderPanel = () => {
-      const popupOpts = computePopupOpts.value;
-      if (popupOpts.enabled === false) {
-        return renderEmptyElement($xeDatePicker);
-      }
-      const { type, multiple, showClearButton, showConfirmButton } = props;
-      const { initialized, isAniVisible, visiblePanel, panelPlacement, panelStyle, inputValue } = reactData;
-      const vSize = computeSize.value;
-      const btnTransfer = computeBtnTransfer.value;
-      const shortcutOpts = computeShortcutOpts.value;
-      const isClearable = computeIsClearable.value;
-      const isTimeOrDateTimeType = computeIsTimeOrDateTimeType.value;
-      const shortcutList = computeShortcutList.value;
-      const timeOpts = computeTimeOpts.value;
-      const dateStartDate = computeDateStartDate.value;
-      const dateEndDate = computeDateEndDate.value;
-      const { appendTo } = popupOpts;
-      const { position } = shortcutOpts;
-      const headerSlot = slots.header;
-      const footerSlot = slots.footer;
-      const topSlot = slots.top;
-      const bottomSlot = slots.bottom;
-      const leftSlot = slots.left;
-      const rightSlot = slots.right;
-      const ppClassName = popupOpts.className;
-      const hasShortcutBtn = shortcutList.length > 0;
-      const showConfirmBtn = showConfirmButton === null ? isTimeOrDateTimeType || multiple : showConfirmButton;
-      const showClearBtn = showClearButton === null ? isClearable && showConfirmBtn && type !== "time" : showClearButton;
-      return (0, import_vue.h)(
-        import_vue.Teleport,
-        {
-          to: (0, import_dom.getPopupContainer)(appendTo),
-          disabled: btnTransfer ? !initialized : true
+        dispatchEvent("shortcut-click", shortcutParams, $event);
+      };
+      const dispatchEvent = (type, params, evnt) => {
+        emit(type, createEvent(evnt, { $datePicker: $xeDatePicker }, params));
+      };
+      const emitModel = (value) => {
+        emit("update:modelValue", value);
+      };
+      const datePickerMethods = {
+        dispatchEvent,
+        setModelValue(value) {
+          reactData.inputValue = value;
+          emitModel(value);
         },
-        [
-          (0, import_vue.h)(
-            "div",
-            {
-              ref: refInputPanel,
-              class: [
-                "vxe-table--ignore-clear vxe-date-picker--panel",
-                `type--${type}`,
-                ppClassName ? import_xe_utils.default.isFunction(ppClassName) ? ppClassName({ $datePicker: $xeDatePicker }) : ppClassName : "",
-                {
-                  [`size--${vSize}`]: vSize,
-                  "is--transfer": btnTransfer,
-                  "ani--leave": isAniVisible,
-                  "ani--enter": visiblePanel,
-                  "show--top": !!(topSlot || headerSlot || hasShortcutBtn && (position === "top" || position === "header")),
-                  "show--bottom": !!(bottomSlot || footerSlot || hasShortcutBtn && (position === "bottom" || position === "footer")),
-                  "show--left": !!(leftSlot || hasShortcutBtn && position === "left"),
-                  "show--right": !!(rightSlot || hasShortcutBtn && position === "right")
-                }
-              ],
-              placement: panelPlacement,
-              style: panelStyle
-            },
-            initialized && (visiblePanel || isAniVisible) ? [
-              (0, import_vue.h)(
-                "div",
-                {
-                  ref: refPanelWrapper,
-                  class: [
-                    "vxe-date-picker--layout-all-wrapper",
-                    `type--${type}`,
-                    {
-                      [`size--${vSize}`]: vSize
-                    }
-                  ]
-                },
-                [
-                  topSlot ? (0, import_vue.h)(
-                    "div",
-                    {
-                      class: "vxe-date-picker--layout-top-wrapper"
-                    },
-                    topSlot({})
-                  ) : renderShortcutBtn("top"),
-                  (0, import_vue.h)(
-                    "div",
-                    {
-                      class: "vxe-date-picker--layout-body-layout-wrapper"
-                    },
-                    [
-                      leftSlot ? (0, import_vue.h)(
-                        "div",
-                        {
-                          class: "vxe-date-picker--layout-left-wrapper"
-                        },
-                        leftSlot({})
-                      ) : renderShortcutBtn("left", true),
-                      (0, import_vue.h)(
-                        "div",
-                        {
-                          class: "vxe-date-picker--layout-body-content-wrapper"
-                        },
-                        [
-                          headerSlot ? (0, import_vue.h)(
-                            "div",
-                            {
-                              class: "vxe-date-picker--layout-header-wrapper"
-                            },
-                            headerSlot({})
-                          ) : renderShortcutBtn("header"),
-                          (0, import_vue.h)(
-                            "div",
-                            {
-                              class: "vxe-date-picker--layout-body-wrapper"
-                            },
-                            [
-                              (0, import_vue.h)(import_date_panel.default, {
-                                ref: refDatePanel,
-                                modelValue: reactData.inputValue,
-                                type: props.type,
-                                className: props.className,
-                                multiple: props.multiple,
-                                limitCount: props.limitCount,
-                                startDate: dateStartDate,
-                                endDate: dateEndDate,
-                                defaultDate: props.defaultDate,
-                                defaultTime: props.defaultTime,
-                                minDate: props.minDate,
-                                maxDate: props.maxDate,
-                                startDay: props.startDay,
-                                labelFormat: props.labelFormat,
-                                valueFormat: props.valueFormat,
-                                timeFormat: props.timeFormat,
-                                timeConfig: timeOpts,
-                                festivalMethod: props.festivalMethod || defaultFuncProps.festivalMethod,
-                                disabledMethod: props.disabledMethod || defaultFuncProps.disabledMethod,
-                                selectDay: props.selectDay,
-                                onChange: panelChangeEvent,
-                                onConfirm: panelConfirmEvent,
-                                onRevert: panelRevertEvent
-                              })
-                            ]
-                          ),
-                          (0, import_vue.h)(
-                            "div",
-                            {
-                              class: "vxe-date-picker--layout-footer-wrapper"
-                            },
-                            [
-                              (0, import_vue.h)(
-                                "div",
-                                {
-                                  class: "vxe-date-picker--layout-footer-custom"
-                                },
-                                footerSlot ? footerSlot({}) : [renderShortcutBtn("footer")]
-                              ),
-                              showClearBtn || showConfirmBtn ? (0, import_vue.h)(
-                                "div",
-                                {
-                                  class: "vxe-date-picker--layout-footer-btns"
-                                },
-                                [
-                                  showClearBtn ? (0, import_vue.h)(import_button.default, {
-                                    size: "mini",
-                                    disabled: inputValue === "" || import_xe_utils.default.eqNull(inputValue),
-                                    content: getI18n("vxe.button.clear"),
-                                    onClick: clearValueEvent
-                                  }) : renderEmptyElement($xeDatePicker),
-                                  showConfirmBtn ? (0, import_vue.h)(import_button.default, {
-                                    size: "mini",
-                                    status: "primary",
-                                    content: getI18n("vxe.button.confirm"),
-                                    onClick: confirmEvent
-                                  }) : renderEmptyElement($xeDatePicker)
-                                ]
-                              ) : renderEmptyElement($xeDatePicker)
-                            ]
-                          )
-                        ]
-                      ),
-                      rightSlot ? (0, import_vue.h)(
-                        "div",
-                        {
-                          class: "vxe-date-picker--layout-right-wrapper"
-                        },
-                        rightSlot({})
-                      ) : renderShortcutBtn("right", true)
-                    ]
-                  ),
-                  bottomSlot ? (0, import_vue.h)(
-                    "div",
-                    {
-                      class: "vxe-date-picker--layout-bottom-wrapper"
-                    },
-                    bottomSlot({})
-                  ) : renderShortcutBtn("bottom")
-                ]
-              )
-            ] : []
-          )
-        ]
-      );
-    };
-    const renderPrefixIcon = () => {
-      const { prefixIcon } = props;
-      const prefixSlot = slots.prefix;
-      return prefixSlot || prefixIcon ? (0, import_vue.h)(
-        "div",
-        {
-          class: "vxe-date-picker--prefix",
-          onClick: clickPrefixEvent
+        setModelValueByEvent(evnt, value) {
+          handleChange(value || "", evnt);
         },
-        [
-          (0, import_vue.h)(
-            "div",
-            {
-              class: "vxe-date-picker--prefix-icon"
-            },
-            prefixSlot ? (0, import_vn.getSlotVNs)(prefixSlot({})) : [
-              (0, import_vue.h)("i", {
-                class: prefixIcon
-              })
-            ]
-          )
-        ]
-      ) : null;
-    };
-    const renderSuffixIcon = () => {
-      const { suffixIcon } = props;
-      const { inputValue } = reactData;
-      const suffixSlot = slots.suffix;
-      const isDisabled = computeIsDisabled.value;
-      const isClearable = computeIsClearable.value;
-      return (0, import_vue.h)(
-        "div",
-        {
-          class: [
-            "vxe-date-picker--suffix",
-            {
-              "is--clear": isClearable && !isDisabled && !(inputValue === "" || import_xe_utils.default.eqNull(inputValue))
-            }
-          ]
+        focus() {
+          const inputElem = refInputTarget.value;
+          reactData.isActivated = true;
+          inputElem.focus();
+          return (0, import_vue.nextTick)();
+        },
+        blur() {
+          const inputElem = refInputTarget.value;
+          inputElem.blur();
+          reactData.isActivated = false;
+          return (0, import_vue.nextTick)();
+        },
+        select() {
+          const inputElem = refInputTarget.value;
+          inputElem.select();
+          reactData.isActivated = false;
+          return (0, import_vue.nextTick)();
         },
-        [
-          isClearable ? (0, import_vue.h)(
+        showPanel,
+        hidePanel,
+        updatePlacement
+      };
+      Object.assign($xeDatePicker, datePickerMethods);
+      const renderShortcutBtn = (pos, isVertical) => {
+        const shortcutOpts = computeShortcutOpts.value;
+        const { position, align, mode } = shortcutOpts;
+        const shortcutList = computeShortcutList.value;
+        if ((0, import_utils.isEnableConf)(shortcutOpts) && shortcutList.length && (position || "left") === pos) {
+          return (0, import_vue.h)(
             "div",
             {
-              class: "vxe-date-picker--clear-icon",
-              onClick: clearValueEvent
+              class: `vxe-date-picker--layout-${pos}-wrapper`
             },
             [
-              (0, import_vue.h)("i", {
-                class: getIcon().INPUT_CLEAR
+              (0, import_vue.h)(import_button_group.default, {
+                options: shortcutList,
+                mode,
+                align,
+                vertical: isVertical,
+                onClick: handleShortcutEvent
               })
             ]
-          ) : renderEmptyElement($xeDatePicker),
-          renderExtraSuffixIcon(),
-          suffixSlot || suffixIcon ? (0, import_vue.h)(
-            "div",
-            {
-              class: "vxe-date-picker--suffix-icon",
-              onClick: clickSuffixEvent
-            },
-            suffixSlot ? (0, import_vn.getSlotVNs)(suffixSlot({})) : [
-              (0, import_vue.h)("i", {
-                class: suffixIcon
-              })
+          );
+        }
+        return renderEmptyElement($xeDatePicker);
+      };
+      const renderPanel = () => {
+        const popupOpts = computePopupOpts.value;
+        if (popupOpts.enabled === false) {
+          return renderEmptyElement($xeDatePicker);
+        }
+        const { type, multiple, showClearButton, showConfirmButton } = props;
+        const { initialized, isAniVisible, visiblePanel, panelPlacement, panelStyle, inputValue } = reactData;
+        const vSize = computeSize.value;
+        const btnTransfer = computeBtnTransfer.value;
+        const shortcutOpts = computeShortcutOpts.value;
+        const isClearable = computeIsClearable.value;
+        const isTimeOrDateTimeType = computeIsTimeOrDateTimeType.value;
+        const shortcutList = computeShortcutList.value;
+        const timeOpts = computeTimeOpts.value;
+        const dateStartDate = computeDateStartDate.value;
+        const dateEndDate = computeDateEndDate.value;
+        const { appendTo } = popupOpts;
+        const { position } = shortcutOpts;
+        const headerSlot = slots.header;
+        const footerSlot = slots.footer;
+        const topSlot = slots.top;
+        const bottomSlot = slots.bottom;
+        const leftSlot = slots.left;
+        const rightSlot = slots.right;
+        const ppClassName = popupOpts.className;
+        const hasShortcutBtn = shortcutList.length > 0;
+        const showConfirmBtn = showConfirmButton === null ? isTimeOrDateTimeType || multiple : showConfirmButton;
+        const showClearBtn = showClearButton === null ? isClearable && showConfirmBtn && type !== "time" : showClearButton;
+        return (0, import_vue.h)(
+          import_vue.Teleport,
+          {
+            to: (0, import_dom.getPopupContainer)(appendTo),
+            disabled: btnTransfer ? !initialized : true
+          },
+          [
+            (0, import_vue.h)(
+              "div",
+              {
+                ref: refInputPanel,
+                class: [
+                  "vxe-table--ignore-clear vxe-date-picker--panel",
+                  `type--${type}`,
+                  ppClassName ? import_xe_utils.default.isFunction(ppClassName) ? ppClassName({ $datePicker: $xeDatePicker }) : ppClassName : "",
+                  {
+                    [`size--${vSize}`]: vSize,
+                    "is--transfer": btnTransfer,
+                    "ani--leave": isAniVisible,
+                    "ani--enter": visiblePanel,
+                    "show--top": !!(topSlot || headerSlot || hasShortcutBtn && (position === "top" || position === "header")),
+                    "show--bottom": !!(bottomSlot || footerSlot || hasShortcutBtn && (position === "bottom" || position === "footer")),
+                    "show--left": !!(leftSlot || hasShortcutBtn && position === "left"),
+                    "show--right": !!(rightSlot || hasShortcutBtn && position === "right")
+                  }
+                ],
+                placement: panelPlacement,
+                style: panelStyle
+              },
+              initialized && (visiblePanel || isAniVisible) ? [
+                (0, import_vue.h)(
+                  "div",
+                  {
+                    ref: refPanelWrapper,
+                    class: [
+                      "vxe-date-picker--layout-all-wrapper",
+                      `type--${type}`,
+                      {
+                        [`size--${vSize}`]: vSize
+                      }
+                    ]
+                  },
+                  [
+                    topSlot ? (0, import_vue.h)(
+                      "div",
+                      {
+                        class: "vxe-date-picker--layout-top-wrapper"
+                      },
+                      topSlot({})
+                    ) : renderShortcutBtn("top"),
+                    (0, import_vue.h)(
+                      "div",
+                      {
+                        class: "vxe-date-picker--layout-body-layout-wrapper"
+                      },
+                      [
+                        leftSlot ? (0, import_vue.h)(
+                          "div",
+                          {
+                            class: "vxe-date-picker--layout-left-wrapper"
+                          },
+                          leftSlot({})
+                        ) : renderShortcutBtn("left", true),
+                        (0, import_vue.h)(
+                          "div",
+                          {
+                            class: "vxe-date-picker--layout-body-content-wrapper"
+                          },
+                          [
+                            headerSlot ? (0, import_vue.h)(
+                              "div",
+                              {
+                                class: "vxe-date-picker--layout-header-wrapper"
+                              },
+                              headerSlot({})
+                            ) : renderShortcutBtn("header"),
+                            (0, import_vue.h)(
+                              "div",
+                              {
+                                class: "vxe-date-picker--layout-body-wrapper"
+                              },
+                              [
+                                (0, import_vue.h)(import_date_panel.default, {
+                                  ref: refDatePanel,
+                                  modelValue: reactData.inputValue,
+                                  type: props.type,
+                                  className: props.className,
+                                  multiple: props.multiple,
+                                  limitCount: props.limitCount,
+                                  startDate: dateStartDate,
+                                  endDate: dateEndDate,
+                                  defaultDate: props.defaultDate,
+                                  defaultTime: props.defaultTime,
+                                  minDate: props.minDate,
+                                  maxDate: props.maxDate,
+                                  startDay: props.startDay,
+                                  labelFormat: props.labelFormat,
+                                  valueFormat: props.valueFormat,
+                                  timeFormat: props.timeFormat,
+                                  timeConfig: timeOpts,
+                                  festivalMethod: props.festivalMethod || defaultFuncProps.festivalMethod,
+                                  disabledMethod: props.disabledMethod || defaultFuncProps.disabledMethod,
+                                  selectDay: props.selectDay,
+                                  onChange: panelChangeEvent,
+                                  onConfirm: panelConfirmEvent,
+                                  onRevert: panelRevertEvent
+                                })
+                              ]
+                            ),
+                            (0, import_vue.h)(
+                              "div",
+                              {
+                                class: "vxe-date-picker--layout-footer-wrapper"
+                              },
+                              [
+                                (0, import_vue.h)(
+                                  "div",
+                                  {
+                                    class: "vxe-date-picker--layout-footer-custom"
+                                  },
+                                  footerSlot ? footerSlot({}) : [renderShortcutBtn("footer")]
+                                ),
+                                showClearBtn || showConfirmBtn ? (0, import_vue.h)(
+                                  "div",
+                                  {
+                                    class: "vxe-date-picker--layout-footer-btns"
+                                  },
+                                  [
+                                    showClearBtn ? (0, import_vue.h)(import_button.default, {
+                                      size: "mini",
+                                      disabled: inputValue === "" || import_xe_utils.default.eqNull(inputValue),
+                                      content: getI18n("vxe.button.clear"),
+                                      onClick: clearValueEvent
+                                    }) : renderEmptyElement($xeDatePicker),
+                                    showConfirmBtn ? (0, import_vue.h)(import_button.default, {
+                                      size: "mini",
+                                      status: "primary",
+                                      content: getI18n("vxe.button.confirm"),
+                                      onClick: confirmEvent
+                                    }) : renderEmptyElement($xeDatePicker)
+                                  ]
+                                ) : renderEmptyElement($xeDatePicker)
+                              ]
+                            )
+                          ]
+                        ),
+                        rightSlot ? (0, import_vue.h)(
+                          "div",
+                          {
+                            class: "vxe-date-picker--layout-right-wrapper"
+                          },
+                          rightSlot({})
+                        ) : renderShortcutBtn("right", true)
+                      ]
+                    ),
+                    bottomSlot ? (0, import_vue.h)(
+                      "div",
+                      {
+                        class: "vxe-date-picker--layout-bottom-wrapper"
+                      },
+                      bottomSlot({})
+                    ) : renderShortcutBtn("bottom")
+                  ]
+                )
+              ] : []
+            )
+          ]
+        );
+      };
+      const renderPrefixIcon = () => {
+        const { prefixIcon } = props;
+        const prefixSlot = slots.prefix;
+        return prefixSlot || prefixIcon ? (0, import_vue.h)(
+          "div",
+          {
+            class: "vxe-date-picker--prefix",
+            onClick: clickPrefixEvent
+          },
+          [
+            (0, import_vue.h)(
+              "div",
+              {
+                class: "vxe-date-picker--prefix-icon"
+              },
+              prefixSlot ? (0, import_vn.getSlotVNs)(prefixSlot({})) : [
+                (0, import_vue.h)("i", {
+                  class: prefixIcon
+                })
+              ]
+            )
+          ]
+        ) : null;
+      };
+      const renderSuffixIcon = () => {
+        const { suffixIcon } = props;
+        const { inputValue } = reactData;
+        const suffixSlot = slots.suffix;
+        const isDisabled = computeIsDisabled.value;
+        const isClearable = computeIsClearable.value;
+        return (0, import_vue.h)(
+          "div",
+          {
+            class: [
+              "vxe-date-picker--suffix",
+              {
+                "is--clear": isClearable && !isDisabled && !(inputValue === "" || import_xe_utils.default.eqNull(inputValue))
+              }
             ]
-          ) : renderEmptyElement($xeDatePicker)
-        ]
-      );
-    };
-    const renderExtraSuffixIcon = () => {
-      return (0, import_vue.h)(
-        "div",
-        {
-          class: "vxe-date-picker--control-icon",
-          onClick: clickIconEvent
-        },
-        [
-          (0, import_vue.h)("i", {
-            class: ["vxe-date-picker--date-picker-icon", getIcon().DATE_PICKER_DATE]
-          })
-        ]
-      );
-    };
-    const renderVN = () => {
-      const { className, inputClassName, type, name, autoComplete } = props;
-      const { inputValue, visiblePanel, isActivated, labelFlag } = reactData;
-      const { inputLabel } = internalData;
-      const vSize = computeSize.value;
-      const isDisabled = computeIsDisabled.value;
-      const formReadonly = computeFormReadonly.value;
-      const panelLabel = computePanelLabel.value;
-      if (formReadonly) {
+          },
+          [
+            isClearable ? (0, import_vue.h)(
+              "div",
+              {
+                class: "vxe-date-picker--clear-icon",
+                onClick: clearValueEvent
+              },
+              [
+                (0, import_vue.h)("i", {
+                  class: getIcon().INPUT_CLEAR
+                })
+              ]
+            ) : renderEmptyElement($xeDatePicker),
+            renderExtraSuffixIcon(),
+            suffixSlot || suffixIcon ? (0, import_vue.h)(
+              "div",
+              {
+                class: "vxe-date-picker--suffix-icon",
+                onClick: clickSuffixEvent
+              },
+              suffixSlot ? (0, import_vn.getSlotVNs)(suffixSlot({})) : [
+                (0, import_vue.h)("i", {
+                  class: suffixIcon
+                })
+              ]
+            ) : renderEmptyElement($xeDatePicker)
+          ]
+        );
+      };
+      const renderExtraSuffixIcon = () => {
         return (0, import_vue.h)(
           "div",
           {
-            ref: refElem,
-            class: ["vxe-date-picker--readonly", `type--${type}`, className]
+            class: "vxe-date-picker--control-icon",
+            onClick: clickIconEvent
           },
-          panelLabel
+          [
+            (0, import_vue.h)("i", {
+              class: ["vxe-date-picker--date-picker-icon", getIcon().DATE_PICKER_DATE]
+            })
+          ]
         );
-      }
-      const currStyle = computeCurrStyle.value;
-      const inputReadonly = computeInputReadonly.value;
-      const inpPlaceholder = computeInpPlaceholder.value;
-      const isClearable = computeIsClearable.value;
-      const prefix = renderPrefixIcon();
-      const suffix = renderSuffixIcon();
-      return (0, import_vue.h)(
-        "div",
-        {
-          ref: refElem,
-          class: [
-            "vxe-date-picker",
-            `type--${type}`,
-            className,
-            {
-              [`size--${vSize}`]: vSize,
-              "is--prefix": !!prefix,
-              "is--suffix": !!suffix,
-              "is--visible": visiblePanel,
-              "is--disabled": isDisabled,
-              "is--active": isActivated,
-              "show--clear": isClearable && !isDisabled && !(inputValue === "" || import_xe_utils.default.eqNull(inputValue))
-            }
-          ],
-          style: currStyle,
-          spellcheck: false
-        },
-        [
-          prefix || renderEmptyElement($xeDatePicker),
-          (0, import_vue.h)(
+      };
+      const renderVN = () => {
+        const { className, inputClassName, type, name, autoComplete } = props;
+        const { inputValue, visiblePanel, isActivated, labelFlag } = reactData;
+        const { inputLabel } = internalData;
+        const vSize = computeSize.value;
+        const isDisabled = computeIsDisabled.value;
+        const formReadonly = computeFormReadonly.value;
+        const panelLabel = computePanelLabel.value;
+        if (formReadonly) {
+          return (0, import_vue.h)(
             "div",
             {
-              class: "vxe-date-picker--wrapper"
+              ref: refElem,
+              class: ["vxe-date-picker--readonly", `type--${type}`, className]
             },
-            [
-              (0, import_vue.h)("input", {
-                ref: refInputTarget,
-                class: "vxe-date-picker--inner" + (inputClassName ? " " + inputClassName : ""),
-                value: labelFlag ? inputLabel : "",
-                name,
-                type: "text",
-                placeholder: inpPlaceholder,
-                readonly: inputReadonly,
-                disabled: isDisabled,
-                autocomplete: autoComplete,
-                onKeydown: keydownEvent,
-                onKeyup: keyupEvent,
-                onClick: clickEvent,
-                onInput: inputEvent,
-                onChange: changeEvent,
-                onFocus: focusEvent,
-                onBlur: blurEvent
-              })
-            ]
-          ),
-          suffix || renderEmptyElement($xeDatePicker),
-          // 下拉面板
-          renderPanel()
-        ]
+            panelLabel
+          );
+        }
+        const currStyle = computeCurrStyle.value;
+        const inputReadonly = computeInputReadonly.value;
+        const inpPlaceholder = computeInpPlaceholder.value;
+        const isClearable = computeIsClearable.value;
+        const prefix = renderPrefixIcon();
+        const suffix = renderSuffixIcon();
+        return (0, import_vue.h)(
+          "div",
+          {
+            ref: refElem,
+            class: [
+              "vxe-date-picker",
+              `type--${type}`,
+              className,
+              {
+                [`size--${vSize}`]: vSize,
+                "is--prefix": !!prefix,
+                "is--suffix": !!suffix,
+                "is--visible": visiblePanel,
+                "is--disabled": isDisabled,
+                "is--active": isActivated,
+                "show--clear": isClearable && !isDisabled && !(inputValue === "" || import_xe_utils.default.eqNull(inputValue))
+              }
+            ],
+            style: currStyle,
+            spellcheck: false
+          },
+          [
+            prefix || renderEmptyElement($xeDatePicker),
+            (0, import_vue.h)(
+              "div",
+              {
+                class: "vxe-date-picker--wrapper"
+              },
+              [
+                (0, import_vue.h)("input", {
+                  ref: refInputTarget,
+                  class: "vxe-date-picker--inner" + (inputClassName ? " " + inputClassName : ""),
+                  value: labelFlag ? inputLabel : "",
+                  name,
+                  type: "text",
+                  placeholder: inpPlaceholder,
+                  readonly: inputReadonly,
+                  disabled: isDisabled,
+                  autocomplete: autoComplete,
+                  onKeydown: keydownEvent,
+                  onKeyup: keyupEvent,
+                  onClick: clickEvent,
+                  onInput: inputEvent,
+                  onChange: changeEvent,
+                  onFocus: focusEvent,
+                  onBlur: blurEvent
+                })
+              ]
+            ),
+            suffix || renderEmptyElement($xeDatePicker),
+            // 下拉面板
+            renderPanel()
+          ]
+        );
+      };
+      (0, import_vue.watch)(computePanelLabel, (val) => {
+        handleInputLabel(val, true);
+      });
+      (0, import_vue.watch)(
+        () => props.modelValue,
+        () => {
+          updateModelValue();
+        }
       );
-    };
-    (0, import_vue.watch)(computePanelLabel, (val) => {
-      handleInputLabel(val, true);
-    });
-    (0, import_vue.watch)(
-      () => props.modelValue,
-      () => {
-        updateModelValue();
-      }
-    );
-    updateModelValue();
-    (0, import_vue.nextTick)(() => {
-      globalEvents.on($xeDatePicker, "mousedown", handleGlobalMousedownEvent);
-      globalEvents.on($xeDatePicker, "keydown", handleGlobalKeydownEvent);
-      globalEvents.on($xeDatePicker, "blur", handleGlobalBlurEvent);
-      globalEvents.on($xeDatePicker, "resize", handleGlobalResizeEvent);
-      globalEvents.on($xeDatePicker, "scroll", handleGlobalScrollEvent);
-    });
-    (0, import_vue.onMounted)(() => {
-      const { type, multiple, maskedConfig } = props;
-      if ((0, import_utils.isEnableConf)(maskedConfig)) {
-        if (multiple) {
-          errLog("vxe.error.notSupportProp", ["multiple", "masked-config.enabled=true", "masked-config.enabled=false"]);
+      updateModelValue();
+      (0, import_vue.nextTick)(() => {
+        globalEvents.on($xeDatePicker, "mousedown", handleGlobalMousedownEvent);
+        globalEvents.on($xeDatePicker, "keydown", handleGlobalKeydownEvent);
+        globalEvents.on($xeDatePicker, "blur", handleGlobalBlurEvent);
+        globalEvents.on($xeDatePicker, "resize", handleGlobalResizeEvent);
+        globalEvents.on($xeDatePicker, "scroll", handleGlobalScrollEvent);
+      });
+      (0, import_vue.onMounted)(() => {
+        const { type, multiple, maskedConfig } = props;
+        if ((0, import_utils.isEnableConf)(maskedConfig)) {
+          if (multiple) {
+            errLog("vxe.error.notSupportProp", ["multiple", "masked-config.enabled=true", "masked-config.enabled=false"]);
+          }
+          if (!maskedTypes.includes(type)) {
+            warnLog("vxe.error.notSupportProp", ["masked-config.enabled=true", `type=${type}`, `type=${maskedTypes.join("|")}`]);
+          }
         }
-        if (!maskedTypes.includes(type)) {
-          warnLog("vxe.error.notSupportProp", ["masked-config.enabled=true", `type=${type}`, `type=${maskedTypes.join("|")}`]);
-        }
-      }
-    });
-    (0, import_vue.onUnmounted)(() => {
-      globalEvents.off($xeDatePicker, "mousedown");
-      globalEvents.off($xeDatePicker, "keydown");
-      globalEvents.off($xeDatePicker, "blur");
-      globalEvents.off($xeDatePicker, "resize");
-      globalEvents.off($xeDatePicker, "scroll");
-      import_xe_utils.default.assign(reactData, createReactData());
-      import_xe_utils.default.assign(internalData, createInternalData());
-    });
-    (0, import_vue.provide)("$xeDatePicker", $xeDatePicker);
-    $xeDatePicker.renderVN = renderVN;
-    return $xeDatePicker;
-  },
-  render() {
-    return this.renderVN();
-  }
-});
+      });
+      (0, import_vue.onUnmounted)(() => {
+        globalEvents.off($xeDatePicker, "mousedown");
+        globalEvents.off($xeDatePicker, "keydown");
+        globalEvents.off($xeDatePicker, "blur");
+        globalEvents.off($xeDatePicker, "resize");
+        globalEvents.off($xeDatePicker, "scroll");
+        import_xe_utils.default.assign(reactData, createReactData());
+        import_xe_utils.default.assign(internalData, createInternalData());
+      });
+      (0, import_vue.provide)("$xeDatePicker", $xeDatePicker);
+      $xeDatePicker.renderVN = renderVN;
+      return $xeDatePicker;
+    },
+    render() {
+      return this.renderVN();
+    }
+  })
+);