tanxin-ui 0.2.0

package/es/date-picker/src/date-picker-week.js

@@ -0,0 +1,546 @@
+import { defineComponent, ref, computed, onBeforeMount, watch, createVNode, createTextVNode, Fragment, mergeProps, resolveComponent } from "vue";
+import { PropTypes } from "../../utils/type.js";
+import { useConfig } from "../../utils/hooks/useConfig.js";
+import { injectDatePicker } from "./context.js";
+import "../../utils/components/icons/Checkmark.js";
+import "../../utils/components/icons/CheckmarkCircle.js";
+import "../../utils/components/icons/CheckmarkSharp.js";
+import "../../utils/components/icons/CheckmarkCircleOutline.js";
+import "../../utils/components/icons/AlertCircle.js";
+import "../../utils/components/icons/AlertCircleOutline.js";
+import "../../utils/components/icons/InformationCircle.js";
+import "../../utils/components/icons/InformationCircleOutline.js";
+import "../../utils/components/icons/CloseCircle.js";
+import "../../utils/components/icons/CloseCircleOutline.js";
+import "../../utils/components/icons/HelpCircleSharp.js";
+import "../../utils/components/icons/EyeOffOutline.js";
+import "../../utils/components/icons/EyeOutline.js";
+import "../../utils/components/icons/LoadingOutlined.js";
+import "../../utils/components/icons/Close.js";
+import "../../utils/components/icons/CloseOutline.js";
+import "../../utils/components/icons/ArrowsMaximize.js";
+import "../../utils/components/icons/ArrowsMinimize.js";
+import "../../utils/components/icons/AddOutline.js";
+import "../../utils/components/icons/RemoveOutline.js";
+import "../../utils/components/icons/ChevronUp.js";
+import "../../utils/components/icons/ChevronDown.js";
+import "../../utils/components/icons/ChevronForward.js";
+import "../../utils/components/icons/ChevronLeft24Filled.js";
+import "../../utils/components/icons/ChevronRight24Filled.js";
+import "../../utils/components/icons/ChevronDoubleLeft16Filled.js";
+import "../../utils/components/icons/ChevronDoubleRight16Filled.js";
+import "../../utils/components/icons/CheckmarkOutline.js";
+import "../../utils/components/icons/IosCheckmark.js";
+import "../../utils/components/icons/Empty.js";
+import "../../utils/components/icons/Bars.js";
+import "../../utils/components/icons/ArrowUpCircle.js";
+import "../../utils/components/icons/ArrowUp.js";
+import "../../utils/components/icons/ArrowForward.js";
+import "../../utils/components/icons/TimeOutline.js";
+import "../../utils/components/icons/CalendarClearOutline.js";
+import KeyboardArrowLeftRound from "../../utils/components/icons/KeyboardArrowLeftRound.js";
+import KeyboardArrowRightRound from "../../utils/components/icons/KeyboardArrowRightRound.js";
+import KeyboardDoubleArrowLeftRound from "../../utils/components/icons/KeyboardDoubleArrowLeftRound.js";
+import KeyboardDoubleArrowRightRound from "../../utils/components/icons/KeyboardDoubleArrowRightRound.js";
+import "../../utils/components/icons/MenuFoldOutlined.js";
+import "../../utils/components/icons/IosArrowDown.js";
+import "../../utils/components/icons/IosArrowBack.js";
+import "../../utils/components/icons/IosArrowForward.js";
+import "../../utils/components/icons/ImageSharp.js";
+import "../../utils/components/icons/Pause.js";
+import "../../utils/components/icons/Refresh.js";
+import "../../utils/components/icons/QuestionCircle24Regular.js";
+import "../../utils/components/icons/CloudUploadOutline.js";
+import "../../utils/components/icons/UploadFileFilled.js";
+import "../../utils/components/icons/EllipsisHorizontal.js";
+import "../../utils/components/icons/ArrowNext24Filled.js";
+import "../../utils/components/icons/ArrowPrevious24Filled.js";
+import "../../utils/components/icons/ArrowDropDownSharp.js";
+import "../../utils/components/icons/ArrowDropUpSharp.js";
+import "../../utils/components/icons/ArrowForwardIosFilled.js";
+import dayjs from "dayjs";
+import { isSameDate, isSameWeek } from "../../utils/common.js";
+import cloneDeep from "lodash-es/cloneDeep";
+import weekOfYear from "dayjs/plugin/weekOfYear";
+import advancedFormat from "dayjs/plugin/advancedFormat";
+import DatePickerYear from "./date-picker-year.js";
+dayjs.extend(advancedFormat);
+dayjs.extend(weekOfYear);
+const datePickerWeekProps = {
+  index: PropTypes.number.def(0),
+  innerIndex: PropTypes.number.def(0),
+  range: PropTypes.bool.def(false),
+  format: PropTypes.string.def("HH:mm:ss"),
+  readonly: PropTypes.bool.def(false),
+  disabled: PropTypes.bool.def(false),
+  unbound: PropTypes.bool.def(false),
+  week: PropTypes.bool.def(false),
+  type: String,
+  disabledDates: {
+    type: Function
+  },
+  disabledHours: {
+    type: Array,
+    default: () => []
+  },
+  disabledMinutes: {
+    type: Array,
+    default: () => []
+  },
+  disabledSeconds: {
+    type: Array,
+    default: () => []
+  },
+  hourStep: PropTypes.number.def(1),
+  minuteStep: PropTypes.number.def(1),
+  secondStep: PropTypes.number.def(1)
+};
+var DatePickerWeek = defineComponent({
+  name: "TDatePickerDate",
+  components: {
+    KeyboardArrowLeftRound,
+    KeyboardArrowRightRound,
+    KeyboardDoubleArrowLeftRound,
+    KeyboardDoubleArrowRightRound,
+    TDatePickerYear: DatePickerYear
+  },
+  inheritAttrs: false,
+  props: datePickerWeekProps,
+  setup(props) {
+    const {
+      prefixCls
+    } = useConfig("date-picker", props);
+    const pickerContext = injectDatePicker();
+    const loaded = ref(false);
+    const refPopper = ref();
+    const refPickerYear = ref();
+    const setBindPanelDate = () => {
+      if (props.index == 0)
+        pickerContext.setPanelDate(pickerContext.panelDate.value[0].add(1, "month"), 1);
+      else
+        pickerContext.setPanelDate(pickerContext.panelDate.value[1].subtract(1, "month"), 0);
+    };
+    const setUnboundPanelDate = () => {
+      if (isSameDate(pickerContext.panelDate.value[0], pickerContext.panelDate.value[1]) || pickerContext.panelDate.value[0].isAfter(pickerContext.panelDate.value[1])) {
+        if (props.index == 0)
+          pickerContext.setPanelDate(pickerContext.panelDate.value[0].add(1, "month"), 1);
+        else
+          pickerContext.setPanelDate(pickerContext.panelDate.value[1].subtract(1, "month"), 0);
+      }
+    };
+    const panelDateKids = () => {
+      if (props.range) {
+        if (props.unbound)
+          setUnboundPanelDate();
+        else
+          setBindPanelDate();
+      }
+    };
+    const toPrevMonth = () => {
+      const value = pickerContext.panelDate.value[props.index];
+      pickerContext.setPanelDate(value.subtract(1, "month"), props.index);
+      panelDateKids();
+    };
+    const toNextMonth = () => {
+      const value = pickerContext.panelDate.value[props.index];
+      pickerContext.setPanelDate(value.add(1, "month"), props.index);
+      panelDateKids();
+    };
+    const toPrevYear = () => {
+      const value = pickerContext.panelDate.value[props.index];
+      pickerContext.setPanelDate(value.subtract(1, "year"), props.index);
+      panelDateKids();
+    };
+    const toNextYear = () => {
+      const value = pickerContext.panelDate.value[props.index];
+      pickerContext.setPanelDate(value.add(1, "year"), props.index);
+      panelDateKids();
+    };
+    const panelDate = computed(() => pickerContext.panelDate.value[props.index]);
+    const initPanelDate = () => {
+      let value = cloneDeep(pickerContext.value.value);
+      if (!value)
+        value = [null, null];
+      let current = null;
+      if (props.index == 0) {
+        if (value[0])
+          current = value[0].startOf("month");
+        else if (pickerContext.panelDate.value[0])
+          current = pickerContext.panelDate.value[0];
+        else if (value[1]) {
+          if (props.type == "datetime")
+            current = value[1].startOf("month");
+          else
+            current = value[1].startOf("month").subtract(1, "month");
+        } else
+          current = dayjs().startOf("month");
+      } else {
+        if (props.type == "datetime") {
+          if (value[1])
+            current = value[1].startOf("month");
+          else if (pickerContext.panelDate.value[1])
+            current = pickerContext.panelDate.value[1];
+          else if (pickerContext.panelDate.value[0])
+            current = pickerContext.panelDate.value[0];
+          else if (value[0])
+            current = value[0].startOf("month");
+          else
+            current = dayjs().startOf("month");
+        } else {
+          if (!props.unbound) {
+            if (pickerContext.panelDate.value[0])
+              current = pickerContext.panelDate.value[0].add(1, "month");
+            else if (value[0])
+              current = value[0].startOf("month").add(1, "month");
+            else if (pickerContext.panelDate.value[1])
+              current = pickerContext.panelDate.value[1];
+            else if (value[1])
+              current = value[1].startOf("month");
+            else
+              current = dayjs().startOf("month").add(1, "month");
+          } else {
+            if (pickerContext.panelDate.value[1])
+              current = pickerContext.panelDate.value[1];
+            else if (value[1])
+              current = value[1].startOf("month");
+            else if (value[0])
+              current = value[0].startOf("month").add(1, "month");
+            else
+              current = dayjs().startOf("month").add(1, "month");
+          }
+        }
+      }
+      pickerContext.setPanelDate(current, props.index);
+      if (isSameDate(pickerContext.panelDate.value[0], pickerContext.panelDate.value[1]) && pickerContext.panelDate.value[0]) {
+        pickerContext.panelDate.value[1] = pickerContext.panelDate.value[0].add(1, "month");
+      }
+    };
+    onBeforeMount(() => {
+      initPanelDate();
+    });
+    watch(() => pickerContext.value.value[props.index], () => {
+      initPanelDate();
+    }, {
+      deep: true
+    });
+    const pageTurn = (day) => {
+      if (props.range) {
+        if (!props.unbound) {
+          if (day.isBefore(pickerContext.panelDate.value[0].startOf("month")))
+            toPrevMonth();
+          else if (day.isAfter(pickerContext.panelDate.value[1].endOf("month")))
+            toNextMonth();
+        } else {
+          if (day.isBefore(pickerContext.panelDate.value[props.index].startOf("month")))
+            toPrevMonth();
+          else if (day.isAfter(pickerContext.panelDate.value[props.index].endOf("month")))
+            toNextMonth();
+        }
+      }
+    };
+    const handleTimeClick = (type, value, disableClose, isKeyboard) => {
+      if (!props.range)
+        pickerContext.setValue("date", value, props.index, !disableClose);
+      else {
+        let close = true;
+        if (disableClose)
+          close = false;
+        if (!pickerContext.hoverDate.value[0]) {
+          pickerContext.setHoverDate(value, null, isKeyboard);
+        } else {
+          if (isKeyboard) {
+            if (pickerContext.beforeHover.value) {
+              pickerContext.setHoverDate(value, null);
+            } else
+              pickerContext.setHoverDate(pickerContext.hoverDate.value[0], value);
+          } else
+            pickerContext.setRangeValue(pickerContext.hoverDate.value[0], value, close);
+        }
+      }
+      if (isKeyboard)
+        pickerContext.setHoverValue(value);
+    };
+    const handleKeydown = (code) => {
+      if (pickerContext.popVisible.value[props.index]) {
+        refPickerYear.value.handleKeydown(code);
+        return;
+      }
+      let newValue = void 0;
+      const timeType = "date";
+      let currentValue = pickerContext.value.value[props.index];
+      if (props.range) {
+        if (pickerContext.hoverDate.value[0]) {
+          if (pickerContext.hoverDate.value[1])
+            currentValue = pickerContext.hoverDate.value[1];
+          else
+            currentValue = pickerContext.hoverDate.value[0];
+        }
+      }
+      if (currentValue == null) {
+        newValue = panelDate.value;
+      } else {
+        let days = 0;
+        switch (code) {
+          case "ArrowUp":
+            days = -7;
+            break;
+          case "ArrowLeft":
+            days = -1;
+            break;
+          case "ArrowDown":
+            days = 7;
+            break;
+          case "ArrowRight":
+            days = 1;
+            break;
+        }
+        newValue = currentValue.add(days, "day");
+      }
+      if (props.disabledDates && props.disabledDates(newValue))
+        return;
+      handleTimeClick(timeType, newValue, true, true);
+      if (props.range) {
+        pageTurn(newValue);
+      }
+    };
+    const handlePopperClick = () => {
+      pickerContext.setFocus();
+    };
+    watch(() => pickerContext.visible.value, (newVal) => {
+      if (newVal)
+        loaded.value = true;
+    });
+    const realRange = computed(() => props.range || pickerContext.disabled.value[0] != pickerContext.disabled.value[1]);
+    const render = () => {
+      const weekElement = ["\u4E00", "\u4E8C", "\u4E09", "\u56DB", "\u4E94", "\u516D", "\u65E5"].map((item) => {
+        return createVNode("div", {
+          "class": `${prefixCls.value}-th`
+        }, [createVNode("span", {
+          "class": `${prefixCls.value}-words`
+        }, [item])]);
+      });
+      weekElement.unshift(createVNode("div", {
+        "class": [`${prefixCls.value}-th`, `is-week`]
+      }, [createVNode("span", {
+        "class": `${prefixCls.value}-date-week`
+      }, [createTextVNode("W")])]));
+      const oneDayElement = (day, isOther) => {
+        const rangeSelecting = pickerContext.hoverDate.value[0];
+        let innerClasses = [];
+        let spanClasses = [];
+        const disabled = props.disabledDates ? props.disabledDates(day) : false;
+        innerClasses = [[`${prefixCls.value}-inner`], {
+          ["is-disabled"]: disabled
+        }];
+        if (isOther) {
+          spanClasses = [[`${prefixCls.value}-words`], {
+            [`is-other`]: isOther
+          }];
+        } else {
+          spanClasses = [[`${prefixCls.value}-words`], {
+            [`is-other`]: isOther,
+            [`is-today`]: day.format("YYYY-MM-DD") == dayjs().format("YYYY-MM-DD"),
+            [`is-selected`]: !rangeSelecting && (isSameDate(day, pickerContext.value.value[0]) || isSameDate(day, pickerContext.value.value[1])) || rangeSelecting && (isSameDate(day, pickerContext.hoverDate.value[0]) || isSameDate(day, pickerContext.hoverDate.value[1]))
+          }];
+        }
+        const dayProps = disabled ? {} : {
+          onClick: () => {
+            if (!props.range)
+              pickerContext.setValue("date", day, props.index, props.type != "datetime");
+            else if (!pickerContext.hoverDate.value[0]) {
+              pickerContext.setHoverDate(day, null);
+            } else {
+              pickerContext.setRangeValue(pickerContext.hoverDate.value[0], day, true);
+            }
+          },
+          onmouseover: () => {
+            if (rangeSelecting) {
+              pickerContext.setHoverDate(pickerContext.hoverDate.value[0], day);
+            }
+          }
+        };
+        return createVNode(Fragment, null, [createVNode("div", mergeProps({
+          "class": `${prefixCls.value}-td`
+        }, dayProps), [createVNode("div", {
+          "class": innerClasses
+        }, [createVNode("span", {
+          "class": spanClasses
+        }, [day.date()])])])]);
+      };
+      const beforeDaysElement = computed(() => {
+        const days = panelDate.value.day() > 0 ? panelDate.value.day() - 1 : 6;
+        return [...Array(days)].map((item, index) => {
+          const day = panelDate.value.subtract(days - index, "day");
+          return [day, oneDayElement(day, true)];
+        });
+      });
+      const currentDaysElement = computed(() => {
+        return [...Array(panelDate.value.daysInMonth())].map((item, index) => {
+          const day = panelDate.value.add(index, "day");
+          return [day, oneDayElement(day, false)];
+        });
+      });
+      const afterDaysElement = computed(() => {
+        const allDays = 42;
+        const afterDays = allDays - beforeDaysElement.value.length - currentDaysElement.value.length;
+        return [...Array(afterDays)].map((item, index) => {
+          const day = panelDate.value.add(1, "month").add(index, "day");
+          return [day, oneDayElement(day, true)];
+        });
+      });
+      const daysElement = computed(() => {
+        const dayList = [...beforeDaysElement.value, ...currentDaysElement.value, ...afterDaysElement.value];
+        const weekList = [];
+        let oneWeek = [];
+        const rangeSelecting = pickerContext.hoverDate.value[0];
+        const minHoverDate = computed(() => {
+          if (!pickerContext.hoverDate.value[1])
+            return pickerContext.hoverDate.value[0];
+          if (pickerContext.hoverDate.value[0] < pickerContext.hoverDate.value[1])
+            return pickerContext.hoverDate.value[0];
+          else
+            return pickerContext.hoverDate.value[1];
+        });
+        const maxHoverDate = computed(() => {
+          if (!pickerContext.hoverDate.value[1])
+            return pickerContext.hoverDate.value[0];
+          if (pickerContext.hoverDate.value[0] > pickerContext.hoverDate.value[1])
+            return pickerContext.hoverDate.value[0];
+          else
+            return pickerContext.hoverDate.value[1];
+        });
+        const getWeekFirstDay = (day) => {
+          const week = day.day();
+          if (week == 0) {
+            return day.subtract(6, "day");
+          } else {
+            return day.subtract(week - 1, "day");
+          }
+        };
+        const getWeekLastDay = (day) => {
+          const week = day.day();
+          if (week == 0)
+            return day;
+          else
+            return day.add(7 - week, "day");
+        };
+        const getWeekClasses = (day) => {
+          return [[`${prefixCls.value}-week-row`], {
+            [`week-selected`]: !props.range && isSameWeek(day, pickerContext.value.value[0]),
+            [`week-selected-begin`]: realRange.value && !rangeSelecting && isSameWeek(day, pickerContext.value.value[0]) && !isSameWeek(pickerContext.value.value[0], pickerContext.value.value[1]),
+            [`week-selected-end`]: realRange.value && !rangeSelecting && pickerContext.value.value[1] && isSameWeek(day, pickerContext.value.value[1]) && !isSameWeek(pickerContext.value.value[0], pickerContext.value.value[1]),
+            ["week-selected-center"]: !rangeSelecting && pickerContext.value.value[1] && day.isAfter(pickerContext.value.value[0]) && day.isBefore(pickerContext.value.value[1].subtract(1, "week")),
+            [`week-selecting-selected`]: rangeSelecting && !pickerContext.beforeHover.value && isSameWeek(day, pickerContext.hoverDate.value[0]) && (!pickerContext.hoverDate.value[1] || isSameWeek(pickerContext.hoverDate.value[0], pickerContext.hoverDate.value[1])),
+            [`week-selecting-begin`]: rangeSelecting && !pickerContext.beforeHover.value && pickerContext.hoverDate.value[1] && isSameWeek(day, minHoverDate.value) && !isSameWeek(pickerContext.hoverDate.value[0], pickerContext.hoverDate.value[1]),
+            [`week-selecting-end`]: rangeSelecting && !pickerContext.beforeHover.value && pickerContext.hoverDate.value[1] && isSameWeek(day, maxHoverDate.value) && !isSameWeek(pickerContext.hoverDate.value[0], pickerContext.hoverDate.value[1]),
+            [`week-selecting-center`]: rangeSelecting && pickerContext.hoverDate.value[1] && day.isAfter(getWeekLastDay(minHoverDate.value)) && day.isBefore(getWeekFirstDay(maxHoverDate.value)),
+            [`is-hover`]: rangeSelecting && isSameWeek(day, pickerContext.hoverValue.value)
+          }];
+        };
+        let weekFirstDay = null;
+        dayList.forEach((oneDayArr, index) => {
+          const day = oneDayArr[0];
+          const dayElement = oneDayArr[1];
+          if (index % 7 == 0) {
+            if (oneWeek.length > 0) {
+              weekList.push(createVNode("div", {
+                "class": getWeekClasses(weekFirstDay)
+              }, [oneWeek]));
+            }
+            const weekNumElement = createVNode("div", {
+              "class": [`${prefixCls.value}-td`, `is-week`]
+            }, [createVNode("span", {
+              "class": `${prefixCls.value}-date-week`
+            }, [day.week()])]);
+            weekList.push(weekNumElement);
+            oneWeek = [];
+            weekFirstDay = day;
+          }
+          oneWeek.push(dayElement);
+        });
+        if (oneWeek.length > 0) {
+          weekList.push(createVNode("div", {
+            "class": getWeekClasses(weekFirstDay)
+          }, [oneWeek]));
+        }
+        return weekList;
+      });
+      const contentProps = {
+        class: `${prefixCls.value}-content`
+      };
+      const inSlots = {
+        trigger: () => createVNode("div", {
+          "onClick": handlePopperClick
+        }, [panelDate.value.format("YYYY\u5E74 MM\u6708")]),
+        content: () => createVNode("div", contentProps, [createVNode("div", {
+          "class": `${prefixCls.value}-panels`
+        }, [createVNode(DatePickerYear, {
+          "ref": refPickerYear,
+          "type": "month",
+          "visible": pickerContext.popVisible.value[props.index],
+          "innerUse": true,
+          "index": props.index
+        }, null)])])
+      };
+      const popperProps = {
+        placement: "bottom",
+        trigger: "click",
+        transitionName: "slide-up",
+        sameWidth: false,
+        isToggle: true,
+        disabled: props.disabled,
+        offset: 10,
+        showArrow: false,
+        minWidth: "60px",
+        maxWidth: "1000px"
+      };
+      const headerYearElement = computed(() => {
+        return createVNode(resolveComponent("t-popper"), mergeProps({
+          "ref": refPopper,
+          "class": " is-date",
+          "visible": pickerContext.popVisible.value[props.index],
+          "onUpdate:visible": ($event) => pickerContext.popVisible.value[props.index] = $event
+        }, popperProps), inSlots);
+      });
+      return createVNode(Fragment, null, [pickerContext.visible.value || loaded.value ? createVNode("div", {
+        "class": [`${prefixCls.value}-week`, {
+          ["show-week"]: props.week
+        }]
+      }, [createVNode("div", {
+        "class": `${prefixCls.value}-header`
+      }, [!props.range || props.index == 0 || props.unbound ? createVNode(Fragment, null, [createVNode("button", {
+        "onClick": toPrevYear
+      }, [createVNode(resolveComponent("t-icon"), null, {
+        default: () => [createVNode(KeyboardDoubleArrowLeftRound, null, null)]
+      })]), createVNode("button", {
+        "onClick": toPrevMonth
+      }, [createVNode(resolveComponent("t-icon"), null, {
+        default: () => [createVNode(KeyboardArrowLeftRound, null, null)]
+      })])]) : createVNode("div", {
+        "style": "width:48px"
+      }, null), createVNode("div", {
+        "class": `${prefixCls.value}-header-title`
+      }, [headerYearElement.value]), !props.range || props.index == 1 || props.unbound ? createVNode(Fragment, null, [createVNode("button", {
+        "onClick": toNextMonth
+      }, [createVNode(resolveComponent("t-icon"), null, {
+        default: () => [createVNode(KeyboardArrowRightRound, null, null)]
+      })]), createVNode("button", {
+        "onClick": toNextYear
+      }, [createVNode(resolveComponent("t-icon"), null, {
+        default: () => [createVNode(KeyboardDoubleArrowRightRound, null, null)]
+      })])]) : createVNode("div", {
+        "style": "width:48px"
+      }, null)]), createVNode("div", {
+        "class": `${prefixCls.value}-body`
+      }, [weekElement, daysElement.value])]) : null]);
+    };
+    return {
+      render,
+      handleKeydown
+    };
+  },
+  render() {
+    return this.render();
+  }
+});
+export { DatePickerWeek as default };

package/es/date-picker/src/date-picker-year.d.ts

@@ -0,0 +1,135 @@
+import type { PropType } from 'vue';
+import type { DatePickerType } from './context';
+declare const _default: import("vue").DefineComponent<{
+    index: import("vue-types").VueTypeValidableDef<number> & {
+        default: number;
+    } & {
+        default: number;
+    };
+    innerIndex: import("vue-types").VueTypeValidableDef<number> & {
+        default: number;
+    } & {
+        default: number;
+    };
+    range: import("vue-types").VueTypeValidableDef<boolean> & {
+        default: boolean;
+    } & {
+        default: boolean;
+    };
+    format: import("vue-types").VueTypeValidableDef<string> & {
+        default: string;
+    };
+    readonly: import("vue-types").VueTypeValidableDef<boolean> & {
+        default: boolean;
+    } & {
+        default: boolean;
+    };
+    disabled: import("vue-types").VueTypeValidableDef<boolean> & {
+        default: boolean;
+    } & {
+        default: boolean;
+    };
+    type: PropType<DatePickerType>;
+    disabledYears: {
+        type: PropType<Number[]>;
+        default: () => any[];
+    };
+    disabledMonths: {
+        type: PropType<Number[]>;
+        default: () => any[];
+    };
+    disabledQuarters: {
+        type: PropType<Number[]>;
+        default: () => any[];
+    };
+    /**
+     * 内部使用，在日期和星期的面板中选择年月时，用到此值
+     */
+    visible: import("vue-types").VueTypeValidableDef<boolean> & {
+        default: boolean;
+    } & {
+        default: boolean;
+    };
+    /**
+     * 内部使用，在日期和星期的面板中选择年月时，用到此值，仅关闭年月选择的popper
+     */
+    innerUse: import("vue-types").VueTypeValidableDef<boolean> & {
+        default: boolean;
+    } & {
+        default: boolean;
+    };
+}, {
+    render: () => JSX.Element;
+    handleKeydown: (code: string) => void;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    index: import("vue-types").VueTypeValidableDef<number> & {
+        default: number;
+    } & {
+        default: number;
+    };
+    innerIndex: import("vue-types").VueTypeValidableDef<number> & {
+        default: number;
+    } & {
+        default: number;
+    };
+    range: import("vue-types").VueTypeValidableDef<boolean> & {
+        default: boolean;
+    } & {
+        default: boolean;
+    };
+    format: import("vue-types").VueTypeValidableDef<string> & {
+        default: string;
+    };
+    readonly: import("vue-types").VueTypeValidableDef<boolean> & {
+        default: boolean;
+    } & {
+        default: boolean;
+    };
+    disabled: import("vue-types").VueTypeValidableDef<boolean> & {
+        default: boolean;
+    } & {
+        default: boolean;
+    };
+    type: PropType<DatePickerType>;
+    disabledYears: {
+        type: PropType<Number[]>;
+        default: () => any[];
+    };
+    disabledMonths: {
+        type: PropType<Number[]>;
+        default: () => any[];
+    };
+    disabledQuarters: {
+        type: PropType<Number[]>;
+        default: () => any[];
+    };
+    /**
+     * 内部使用，在日期和星期的面板中选择年月时，用到此值
+     */
+    visible: import("vue-types").VueTypeValidableDef<boolean> & {
+        default: boolean;
+    } & {
+        default: boolean;
+    };
+    /**
+     * 内部使用，在日期和星期的面板中选择年月时，用到此值，仅关闭年月选择的popper
+     */
+    innerUse: import("vue-types").VueTypeValidableDef<boolean> & {
+        default: boolean;
+    } & {
+        default: boolean;
+    };
+}>>, {
+    disabled: boolean;
+    visible: boolean;
+    range: boolean;
+    index: number;
+    format: string;
+    readonly: boolean;
+    innerIndex: number;
+    disabledYears: Number[];
+    disabledMonths: Number[];
+    disabledQuarters: Number[];
+    innerUse: boolean;
+}>;
+export default _default;