@touchvue/ui 1.0.0-beta.2 → 1.0.0-beta.3

package/lib/packages/components/calendar/src/calendar.vue2.js

@@ -0,0 +1,1260 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vue = require('vue');
+var index = require('../../../locale/index.js');
+var calendar = require('./calendar.js');
+var index$3 = require('../../button/index.js');
+var index$7 = require('../../grid/index.js');
+var index$4 = require('../../header/index.js');
+var index$2 = require('../../input/index.js');
+var index$6 = require('../../padding/index.js');
+var index$8 = require('../../card/index.js');
+var index$1 = require('../../tag/index.js');
+var index$5 = require('../../scroll/index.js');
+var dis = require('../../../directives/dis/src/dis.js');
+var tip = require('../../../directives/tip/src/tip.js');
+var useWidthStyle = require('../../../hooks/useWidthStyle.js');
+var types = require('../../../utils/types.js');
+var beforeChange = require('../../../utils/beforeChange.js');
+
+const __default__ = vue.defineComponent({
+  name: "ToCalendar"
+});
+var _sfc_main = /* @__PURE__ */ vue.defineComponent({
+  ...__default__,
+  props: calendar.calendarProps,
+  emits: ["change", "beforeChange", "close", "update:modelValue"],
+  setup(__props, { expose: __expose, emit: __emit }) {
+    const props = __props;
+    const emit = __emit;
+    const changeFrom = vue.ref("out");
+    const submitValue = vue.ref("");
+    const curYear = vue.ref((/* @__PURE__ */ new Date()).getFullYear());
+    const curMonth = vue.ref((/* @__PURE__ */ new Date()).getMonth() + 1);
+    const curDay = vue.ref((/* @__PURE__ */ new Date()).getDate());
+    const year = vue.ref(0);
+    const month = vue.ref(0);
+    const day = vue.ref(null);
+    const hour = vue.ref("0");
+    const minute = vue.ref("0");
+    const second = vue.ref("0");
+    const years = vue.ref([]);
+    const days = vue.ref([]);
+    const hours = vue.ref([]);
+    const minutes = vue.ref([]);
+    const seconds = vue.ref([]);
+    const monthLayer = vue.ref(false);
+    const timeLayer = vue.ref(false);
+    const tempYear = vue.ref(0);
+    const yearsPage = vue.ref(0);
+    const start = vue.ref({
+      year: 0,
+      month: 0,
+      day: 0
+    });
+    const end = vue.ref({
+      year: 0,
+      month: 0,
+      day: 0
+    });
+    const { widthStyle } = useWidthStyle.useWidthStyle(props.width);
+    const dayText = vue.computed(() => {
+      return (val) => {
+        const dayStr = year.value + "-" + addZero(month.value) + "-" + addZero(val);
+        if (props.holiday.length > 0 && props.holiday.indexOf(dayStr) > -1) {
+          return index.t("to.calendar.day.holiday");
+        } else {
+          return val;
+        }
+      };
+    });
+    const pointColor = vue.computed(() => {
+      return (val) => {
+        if (val === -1) {
+          return "danger";
+        }
+        if (val === 0) {
+          return "primary";
+        }
+        if (val === 1) {
+          return "success";
+        }
+      };
+    });
+    const hourz = vue.computed({
+      get() {
+        return addZero(hour.value);
+      },
+      set(val) {
+        hour.value = val;
+      }
+    });
+    const minutez = vue.computed({
+      get() {
+        return addZero(minute.value);
+      },
+      set(val) {
+        minute.value = val;
+      }
+    });
+    const secondz = vue.computed({
+      get() {
+        return addZero(second.value);
+      },
+      set(val) {
+        second.value = val;
+      }
+    });
+    const iValue = vue.computed(() => {
+      if (props.range) {
+        const startVal = start.value.day || start.value.month ? getStringValue(start.value) : "";
+        const endVal = end.value.day || end.value.month ? getStringValue(end.value) : "";
+        return `${startVal},${endVal}`;
+      } else {
+        return getStringValue();
+      }
+    });
+    const maxHour = vue.computed(() => {
+      let max;
+      if (typeof props.max === "string") {
+        max = props.max.replace(/-/gi, "/");
+      } else {
+        max = props.max;
+      }
+      return new Date(max).getHours();
+    });
+    const isDisableDay = vue.computed(() => {
+      return (item) => {
+        if (year.value && month.value && item.value) {
+          let dateString = `${year.value}/${month.value}/${Number(item.value)}`;
+          let min;
+          if (typeof props.min === "string") {
+            min = props.min.replace(/-/gi, "/");
+          } else {
+            min = props.min;
+          }
+          let max;
+          if (typeof props.max === "string") {
+            max = props.max.replace(/-/gi, "/");
+          } else {
+            max = props.max;
+          }
+          if (min && max) {
+            return new Date(dateString) < new Date(min) || new Date(dateString) > new Date(max);
+          }
+          if (props.disabledDate) {
+            return props.disabledDate(new Date(dateString));
+          }
+          return false;
+        } else {
+          return false;
+        }
+      };
+    });
+    const isDisableHour = vue.computed(() => {
+      return (item) => {
+        if (year.value && month.value && day.value !== null) {
+          let dateString = `${year.value}/${month.value}/${day.value} ${Number(item)}:00:00`;
+          let min;
+          if (typeof props.min === "string") {
+            min = props.min.replace(/-/gi, "/");
+          } else {
+            min = props.min;
+          }
+          let max;
+          if (typeof props.max === "string") {
+            max = props.max.replace(/-/gi, "/");
+          } else {
+            max = props.max;
+          }
+          if (min && max) {
+            return new Date(dateString) < new Date(min) || new Date(dateString) > new Date(max);
+          }
+          return false;
+        } else {
+          return false;
+        }
+      };
+    });
+    const isDisableMinute = vue.computed(() => {
+      return (item) => {
+        if (year.value && month.value && day.value !== null && hour.value) {
+          let dateString = `${year.value}/${month.value}/${day.value} ${hour.value}:${Number(item)}:00`;
+          let min;
+          if (typeof props.min === "string") {
+            min = props.min.replace(/-/gi, "/");
+          } else {
+            min = props.min;
+          }
+          let max;
+          if (typeof props.max === "string") {
+            max = props.max.replace(/-/gi, "/");
+          } else {
+            max = props.max;
+          }
+          if (min && max) {
+            return new Date(dateString) < new Date(min) || new Date(dateString) > new Date(max);
+          }
+          return false;
+        } else {
+          return false;
+        }
+      };
+    });
+    const isDisableSecond = vue.computed(() => {
+      return (item) => {
+        if (year.value && month.value && day.value !== null && hour.value && minute.value) {
+          let dateString = `${year.value}/${month.value}/${day.value} ${hour.value}:${minute.value}:${Number(item)}`;
+          let min;
+          if (typeof props.min === "string") {
+            min = props.min.replace(/-/gi, "/");
+          } else {
+            min = props.min;
+          }
+          let max;
+          if (typeof props.max === "string") {
+            max = props.max.replace(/-/gi, "/");
+          } else {
+            max = props.max;
+          }
+          if (min && max) {
+            return new Date(dateString) < new Date(min) || new Date(dateString) > new Date(max);
+          }
+          return false;
+        } else {
+          return false;
+        }
+      };
+    });
+    vue.watch(
+      () => props.modelValue,
+      (val) => {
+        setData();
+        if (changeFrom.value === "out") {
+          submitValue.value = val;
+        }
+      }
+    );
+    vue.watch(submitValue, (val) => {
+      emit("change", val);
+      emit("update:modelValue", val);
+      changeFrom.value = "in";
+      setTimeout(() => {
+        changeFrom.value = "out";
+      }, 100);
+    });
+    vue.watch(
+      () => props.min,
+      () => {
+      }
+    );
+    vue.watch(
+      () => props.max,
+      () => {
+      }
+    );
+    vue.watch(
+      () => props.point,
+      () => {
+        setDayData();
+      },
+      { deep: true }
+    );
+    const initCalendar = () => {
+      if (props.type === "time") {
+        showTimeLayer();
+      } else {
+        timeLayer.value = false;
+      }
+    };
+    const getValue = (arg) => {
+      return (/* @__PURE__ */ new Date(
+        `${arg.year || year.value}/${arg.month || month.value}/${arg.day || day.value || "01"}`
+      )).getTime();
+    };
+    const getStringValue = (arg = {}) => {
+      const yearVal = arg.year || year.value;
+      const monthVal = arg.month || month.value;
+      const dayVal = arg.day || day.value;
+      const hourVal = arg.hour || hourz.value;
+      const minuteVal = arg.minute || minutez.value;
+      const secondVal = arg.second || secondz.value;
+      const imonth = `${yearVal}-${addZero(monthVal)}`;
+      const iday = dayVal !== null && dayVal !== void 0 ? `${addZero(dayVal)}` : "01";
+      const itime = `${hourVal}:${minuteVal}:${secondVal}`;
+      if (props.type === "month") {
+        return imonth;
+      } else if (props.type === "datetime" || props.type === "time") {
+        return `${imonth}-${iday} ${itime}`;
+      } else {
+        return `${imonth}-${iday}`;
+      }
+    };
+    const getObjectValue = (str) => {
+      const date = new Date(str);
+      if (isDate(str) && str) {
+        return {
+          year: date.getFullYear(),
+          month: date.getMonth() + 1,
+          day: date.getDate()
+        };
+      } else if (isMonth(str) && str) {
+        return {
+          year: date.getFullYear(),
+          month: date.getMonth() + 1,
+          day: 0
+        };
+      } else {
+        return {
+          year: 0,
+          month: 0,
+          day: 0
+        };
+      }
+    };
+    const setData = () => {
+      setCurrent();
+      setYearData();
+      setDayData();
+      setTimeData();
+    };
+    const setCurrent = () => {
+      year.value = 0;
+      month.value = 0;
+      day.value = null;
+      if (props.range) {
+        let arr = props.modelValue.split(",");
+        const startVal = arr[0];
+        const endVal = arr[1];
+        if (!startVal || isDate(startVal) || isMonth(startVal)) {
+          start.value = getObjectValue(startVal);
+          if (!endVal || isDate(endVal) || isMonth(endVal)) {
+            end.value = getObjectValue(endVal);
+          }
+        }
+        if (props.rangeType === "end") {
+          year.value = year.value || (/* @__PURE__ */ new Date()).getFullYear();
+          if ((end.value.day || end.value.month) && isAnyDate(getStringValue(end.value))) {
+            if (props.type === "month") {
+              if (start.value.year === end.value.year) {
+                year.value = end.value.year + 1;
+              } else {
+                year.value = end.value.year;
+              }
+              month.value = 1;
+            } else {
+              if (start.value.month === end.value.month) {
+                if (Number(month.value) === 12) {
+                  year.value = end.value.year + 1;
+                  month.value = 1;
+                } else {
+                  month.value = end.value.month + 1;
+                }
+              } else {
+                month.value = end.value.month;
+              }
+            }
+          } else {
+            month.value = month.value || (/* @__PURE__ */ new Date()).getMonth() + 2;
+          }
+          if (month.value > 12) {
+            month.value = 1;
+            year.value += 1;
+          }
+        } else {
+          if ((start.value.day || start.value.month) && isAnyDate(getStringValue(start.value))) {
+            year.value = start.value.year;
+            month.value = start.value.month;
+          } else {
+            year.value = year.value || (/* @__PURE__ */ new Date()).getFullYear();
+            month.value = month.value || (/* @__PURE__ */ new Date()).getMonth() + 1;
+          }
+        }
+      } else {
+        if (props.modelValue && !isNaN(new Date(props.modelValue).getTime())) {
+          year.value = new Date(props.modelValue).getFullYear();
+          month.value = new Date(props.modelValue).getMonth() + 1;
+          day.value = new Date(props.modelValue).getDate();
+          hour.value = String(new Date(props.modelValue).getHours());
+          minute.value = String(new Date(props.modelValue).getMinutes());
+          second.value = String(new Date(props.modelValue).getSeconds());
+        } else if (props.modelValue && isNaN(new Date(props.modelValue).getTime()) && !isNaN(new Date(props.modelValue.replace(/-/g, "/")).getTime())) {
+          const value = props.modelValue.replace(/-/g, "/");
+          year.value = new Date(value).getFullYear();
+          month.value = new Date(value).getMonth() + 1;
+          day.value = new Date(value).getDate();
+          hour.value = String(new Date(value).getHours());
+          minute.value = String(new Date(value).getMinutes());
+          second.value = String(new Date(value).getSeconds());
+        } else {
+          year.value = (/* @__PURE__ */ new Date()).getFullYear();
+          month.value = (/* @__PURE__ */ new Date()).getMonth() + 1;
+          day.value = null;
+          hour.value = "0";
+          minute.value = "0";
+          second.value = "0";
+        }
+      }
+    };
+    const setYearData = (yearVal) => {
+      yearVal = yearVal || year.value;
+      let arr = [];
+      for (let i = 0; i < 10; i++) {
+        arr.push(Math.floor(yearVal / 10) * 10 + i);
+      }
+      years.value = arr;
+    };
+    const setDayData = () => {
+      let yearVal = new Date(props.modelValue).getFullYear();
+      let monthVal = new Date(props.modelValue).getMonth() + 1;
+      let dayVal = new Date(props.modelValue).getDate();
+      if (year.value === yearVal && month.value === monthVal) {
+        day.value = dayVal;
+      } else {
+        day.value = null;
+      }
+      const dayCount = getMonthDays(`${year.value}/${month.value}/1`);
+      const thisMonthFirstDay = /* @__PURE__ */ new Date(`${year.value}/${month.value}/1`);
+      thisMonthFirstDay.setMonth(thisMonthFirstDay.getMonth(), 1);
+      const emptyLength = new Date(thisMonthFirstDay.setMonth(thisMonthFirstDay.getMonth(), 1)).getDay();
+      days.value = (() => {
+        let arr = [];
+        for (let i = 0; i < emptyLength; i++) {
+          arr.push({});
+        }
+        for (let i = 1; i < dayCount + 1; i++) {
+          let obj = {};
+          obj.value = i;
+          if ((i + emptyLength) % 7 === 1) {
+            obj.sun = true;
+          }
+          if ((i + emptyLength) % 7 === 0) {
+            obj.sat = true;
+          }
+          const point = props.point.filter((item) => {
+            return item.day === `${year.value}-${addZero(month.value)}-${addZero(i)}`;
+          });
+          obj.point = point;
+          arr.push(obj);
+        }
+        return arr;
+      })();
+    };
+    const setTimeData = () => {
+      hours.value = genNumbers(0, 23);
+      minutes.value = genNumbers(0, 59);
+      seconds.value = genNumbers(0, 59);
+      const hourVal = String(new Date(props.modelValue).getHours());
+      const minuteVal = String(new Date(props.modelValue).getMinutes());
+      const secondVal = String(new Date(props.modelValue).getSeconds());
+      if (props.time) {
+        const arr = props.time.split(":");
+        hour.value = arr[0] || "0";
+        minute.value = arr[1] || "0";
+        second.value = arr[2] || "0";
+      }
+      if (!isNaN(Number(hourVal)) && !isNaN(Number(minuteVal)) && !isNaN(Number(secondVal))) {
+        hour.value = hourVal;
+        minute.value = minuteVal;
+        second.value = secondVal;
+      }
+    };
+    const selectYear = (item) => {
+      year.value = item;
+    };
+    const selectMonth = (item) => {
+      if (item) {
+        if (props.range && props.type === "month") {
+          let startVal = {};
+          let endVal = {};
+          if (!start.value.month && !end.value.month) {
+            startVal.year = year.value;
+            startVal.month = item;
+            startVal.day = "";
+          }
+          if (start.value.month) {
+            if (end.value.month) {
+              startVal.year = year.value;
+              startVal.month = item;
+              startVal.day = "";
+              endVal.year = "";
+              endVal.month = "";
+              endVal.day = "";
+            } else {
+              if (getValue(start.value) > getValue({ month: item })) {
+                endVal.year = start.value.year;
+                endVal.month = start.value.month;
+                endVal.day = "";
+                startVal.year = year.value;
+                startVal.month = item;
+                startVal.day = "";
+              } else {
+                startVal = JSON.parse(JSON.stringify(start.value));
+                endVal.year = year.value;
+                endVal.month = item;
+                endVal.day = "";
+              }
+            }
+          }
+          start.value = JSON.parse(JSON.stringify(startVal));
+          end.value = JSON.parse(JSON.stringify(endVal));
+          submitValue.value = iValue.value;
+        } else {
+          if (props.type === "month") {
+            emit(
+              "beforeChange",
+              getStringValue({
+                month: item
+              })
+            );
+          }
+          if (props.beforeChange) {
+            const fn = props.beforeChange(
+              getStringValue({
+                month: item
+              })
+            );
+            if (fn && types.isPromise(fn)) {
+              fn.then(() => {
+                selectMonthAction(item);
+              }).catch(() => {
+              });
+            } else {
+              if (fn) {
+                selectMonthAction(item);
+              }
+            }
+          } else {
+            selectMonthAction(item);
+          }
+        }
+      }
+    };
+    const selectMonthAction = (item) => {
+      month.value = item;
+      monthLayer.value = false;
+      setDayData();
+      if (props.type === "month") {
+        day.value = 1;
+        submitValue.value = iValue.value;
+      }
+    };
+    const selectDay = (item) => {
+      if (item.value) {
+        if (props.range) {
+          let startVal = {};
+          let endVal = {};
+          if (!start.value.day && !end.value.day) {
+            startVal.year = year.value;
+            startVal.month = month.value;
+            startVal.day = item.value;
+          }
+          if (start.value.day) {
+            if (end.value.day) {
+              startVal.year = year.value;
+              startVal.month = month.value;
+              startVal.day = item.value;
+              endVal.year = "";
+              endVal.month = "";
+              endVal.day = "";
+            } else {
+              if (getValue(start.value) > getValue({ day: item.value })) {
+                endVal.year = start.value.year;
+                endVal.month = start.value.month;
+                endVal.day = start.value.day;
+                startVal.year = year.value;
+                startVal.month = month.value;
+                startVal.day = item.value;
+              } else {
+                startVal = JSON.parse(JSON.stringify(start.value));
+                endVal.year = year.value;
+                endVal.month = month.value;
+                endVal.day = item.value;
+              }
+            }
+          }
+          start.value = JSON.parse(JSON.stringify(startVal));
+          end.value = JSON.parse(JSON.stringify(endVal));
+          submitValue.value = iValue.value;
+        } else {
+          let val = getStringValue({
+            day: item.value
+          });
+          if (!props.type || props.type === "date") {
+            emit("beforeChange", val);
+            beforeChange.handleBeforeChange(
+              props.beforeChange,
+              getStringValue({
+                day: item.value
+              })
+            ).then(() => {
+              selectDayAction(item);
+            }).catch(() => {
+            });
+          } else {
+            selectDayAction(item);
+          }
+        }
+      }
+    };
+    const selectDayAction = (item) => {
+      day.value = Number(item.value);
+      if (!props.type || props.type === "date") {
+        submitValue.value = iValue.value;
+      }
+    };
+    const selectTime = () => {
+      if (day.value === null && !props.min && !props.max) {
+        day.value = (/* @__PURE__ */ new Date()).getDate();
+      } else if (day.value === null && props.min && props.max) {
+        return;
+      }
+      emit("beforeChange", getStringValue());
+      if (props.beforeChange) {
+        const fn = props.beforeChange(getStringValue());
+        if (fn && types.isPromise(fn)) {
+          fn.then(() => {
+            selectTimeAction();
+          });
+        } else {
+          if (fn) {
+            selectTimeAction();
+          }
+        }
+      } else {
+        selectTimeAction();
+      }
+    };
+    const selectTimeAction = () => {
+      timeLayer.value = false;
+      submitValue.value = iValue.value;
+      emit("close");
+    };
+    const setYearClass = (item) => {
+      return {
+        cur: curYear.value === item,
+        on: year.value === item
+      };
+    };
+    const setMonthClass = (item) => {
+      let arr = [];
+      if (year.value === curYear.value && curMonth.value === item) {
+        arr.push("cur");
+      }
+      if (props.range && props.type === "month") {
+        if (year.value === start.value.year && item === start.value.month) {
+          if (end.value.month) {
+            arr.push("start");
+          } else {
+            arr.push("on");
+          }
+        }
+        if (year.value === end.value.year && item === end.value.month) {
+          arr.push("end");
+        }
+        const value = getValue({
+          year: year.value,
+          month: item,
+          day: 1
+        });
+        if ((value > getValue(start.value) || value === getValue(start.value)) && value < getValue(end.value)) {
+          arr.push("range");
+        }
+      } else {
+        if (month.value === item) {
+          arr.push("on");
+        }
+      }
+      if (item && (props.min || props.max)) {
+        let curData = year.value + "/" + (item > 9 ? item : "0" + item) + "/01";
+        let date = /* @__PURE__ */ new Date();
+        let hourVal = date.getHours();
+        let minuteVal = date.getMinutes();
+        let secondVal = date.getSeconds();
+        curData = curData + " " + (hourVal > 9 ? hourVal : "0" + hourVal) + ":" + (minuteVal > 9 ? minuteVal : "0" + minuteVal) + ":" + (secondVal > 9 ? secondVal : "0" + secondVal);
+        let curTime = new Date(curData).getTime();
+        let min = new Date(props.min).getTime();
+        let maxTime = new Date(props.max).getTime();
+        let cur = curData.split(" ")[0];
+        let yearVal = new Date(props.max).getFullYear();
+        let monthVal = new Date(props.max).getMonth() + 1;
+        let dayVal = new Date(props.max).getDate();
+        let max = yearVal + "/" + (monthVal > 9 ? monthVal : "0" + monthVal) + "/" + (dayVal > 9 ? dayVal : "0" + dayVal);
+        if (min === maxTime && cur !== max) {
+          if (curTime > maxTime) {
+            arr.push("to-dis");
+          }
+          if (curTime < min) {
+            arr.push("to-dis");
+          }
+        } else if (min !== maxTime && cur !== max) {
+          if (curTime > maxTime) {
+            arr.push("to-dis");
+          }
+          if (curTime < min) {
+            arr.push("to-dis");
+          }
+        }
+      }
+      return arr;
+    };
+    const setDayClass = (item) => {
+      let arr = [];
+      if (item.sat) {
+        arr.push("sat");
+      }
+      if (item.sun) {
+        arr.push("sun");
+      }
+      if (year.value === curYear.value && month.value === curMonth.value && curDay.value === item.value) {
+        arr.push("cur");
+      }
+      if (props.range) {
+        if (year.value === start.value.year && month.value === start.value.month && item.value === start.value.day) {
+          if (end.value.day) {
+            arr.push("start");
+          } else {
+            arr.push("on");
+          }
+        }
+        if (year.value === end.value.year && month.value === end.value.month && item.value === end.value.day) {
+          arr.push("end");
+        }
+        const value = getValue({
+          year: year.value,
+          month: month.value,
+          day: item.value
+        });
+        if (value > getValue(start.value) && value < getValue(end.value)) {
+          arr.push("range");
+        }
+      } else {
+        if (day.value === item.value) {
+          arr.push("on");
+        }
+      }
+      return arr;
+    };
+    const nextMonth = () => {
+      if (month.value === 12) {
+        year.value += 1;
+        month.value = 1;
+      } else {
+        month.value += 1;
+      }
+      setDayData();
+    };
+    const lastMonth = () => {
+      if (month.value === 1) {
+        year.value -= 1;
+        month.value = 12;
+      } else {
+        month.value -= 1;
+      }
+      setDayData();
+    };
+    const lastYears = () => {
+      yearsPage.value -= 1;
+      setYearData(year.value + 10 * yearsPage.value);
+    };
+    const nextYears = () => {
+      yearsPage.value += 1;
+      setYearData(year.value + 10 * yearsPage.value);
+    };
+    const nextYear = () => {
+      year.value += 1;
+      let yearVal = new Date(props.modelValue).getFullYear();
+      let monthVal = new Date(props.modelValue).getMonth() + 1;
+      let dayVal = new Date(props.modelValue).getDate();
+      if (year.value === yearVal && month.value === monthVal) {
+        day.value = dayVal;
+      } else {
+        day.value = null;
+      }
+    };
+    const lastYear = () => {
+      year.value -= 1;
+      let yearVal = new Date(props.modelValue).getFullYear();
+      let monthVal = new Date(props.modelValue).getMonth() + 1;
+      let dayVal = new Date(props.modelValue).getDate();
+      if (year.value === yearVal && month.value === monthVal) {
+        day.value = dayVal;
+      } else {
+        day.value = null;
+      }
+    };
+    const toggleMonthSelector = () => {
+      if (!monthLayer.value) {
+        monthLayer.value = true;
+        tempYear.value = year.value;
+        setYearData(year.value);
+      } else {
+        monthLayer.value = false;
+      }
+    };
+    const hourScroll = vue.ref();
+    const minuteScroll = vue.ref();
+    const secondScroll = vue.ref();
+    const showTimeLayer = () => {
+      timeLayer.value = true;
+      vue.nextTick(() => {
+        var _a, _b, _c;
+        (_a = hourScroll.value) == null ? void 0 : _a.adjust();
+        (_b = minuteScroll.value) == null ? void 0 : _b.adjust();
+        (_c = secondScroll.value) == null ? void 0 : _c.adjust();
+      });
+    };
+    const closeTimeLayer = () => {
+      if (props.type === "time") {
+        timeLayer.value = false;
+        emit("close");
+      } else {
+        timeLayer.value = false;
+      }
+    };
+    const isDate = (date) => {
+      const DateExp = /^[1-2][0-9]{3}-(0[1-9]|1[0-2])-(0[1-9]|[1-2][0-9]|3[0-1])$/;
+      if (DateExp.test(date)) {
+        return new Date(date).getDate() === Number(date.substring(date.length - 2));
+      } else {
+        return false;
+      }
+    };
+    const isMonth = (date) => {
+      const DateExp = /^[1-2][0-9]{3}-(0[1-9]|1[0-2])$/;
+      if (DateExp.test(date)) {
+        return (/* @__PURE__ */ new Date(date + "-01")).getDate() === Number(1);
+      } else {
+        return false;
+      }
+    };
+    const isDatetime = (time) => {
+      if (typeof time === "string") {
+        var reg = /^(\d{4})-(\d{2})-(\d{2})\s+(\d{2}):(\d{2}):(\d{2})$/;
+        return reg.test(time);
+      } else {
+        return false;
+      }
+    };
+    const isAnyDate = (date) => {
+      return isDate(date) || isMonth(date) || isDatetime(date);
+    };
+    const getMonthDays = (date) => {
+      const d = new Date(date);
+      d.setMonth(d.getMonth() + 1, 0);
+      return d.getDate();
+    };
+    const genNumbers = (min, max, step = 1) => {
+      const arr = [];
+      for (let i = min; i <= max; i += step) {
+        arr.push(String(i));
+      }
+      return arr;
+    };
+    const addZero = (str) => {
+      if (Number(str) < 10) {
+        return "0" + Number(str);
+      } else {
+        return String(str);
+      }
+    };
+    vue.onMounted(() => {
+      setData();
+      initCalendar();
+    });
+    __expose({
+      initCalendar,
+      setData,
+      addZero,
+      year,
+      month,
+      day,
+      hour,
+      minute,
+      second
+    });
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createElementBlock("div", {
+        class: vue.normalizeClass(["to-calendar", {
+          "to-calendar-type-month": _ctx.type === "month",
+          "to-calendar-size-large": _ctx.size === "large"
+        }]),
+        style: vue.normalizeStyle(vue.unref(widthStyle))
+      }, [
+        vue.createElementVNode("div", { class: "header" }, [
+          vue.createElementVNode("div", {
+            class: "prevYear",
+            onClick: lastYear
+          }),
+          vue.createElementVNode("div", {
+            class: "prev",
+            onClick: lastMonth
+          }),
+          vue.createElementVNode("div", {
+            class: vue.normalizeClass(["info", { "info-unfold": _ctx.type !== "month" }]),
+            onClick: toggleMonthSelector
+          }, [
+            vue.createElementVNode("span", { class: "year" }, vue.toDisplayString(year.value), 1),
+            vue.createElementVNode("span", { class: "month" }, vue.toDisplayString(addZero(month.value)), 1)
+          ], 2),
+          vue.createElementVNode("div", {
+            class: "next",
+            onClick: nextMonth
+          }),
+          vue.createElementVNode("div", {
+            class: "nextYear",
+            onClick: nextYear
+          })
+        ]),
+        vue.withDirectives(vue.createElementVNode("div", { class: "select" }, [
+          vue.createElementVNode("div", { class: "year" }, [
+            vue.createElementVNode("span", {
+              class: "prev",
+              onClick: lastYears
+            }),
+            vue.createElementVNode("ul", null, [
+              (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(years.value, (item, index) => {
+                return vue.openBlock(), vue.createElementBlock("li", {
+                  key: index,
+                  class: vue.normalizeClass(setYearClass(item)),
+                  onClick: ($event) => selectYear(item)
+                }, vue.toDisplayString(item), 11, ["onClick"]);
+              }), 128))
+            ]),
+            vue.createElementVNode("span", {
+              class: "next",
+              onClick: nextYears
+            })
+          ]),
+          vue.createElementVNode("div", { class: "month" }, [
+            vue.createElementVNode("ul", null, [
+              vue.createElementVNode("li", {
+                class: vue.normalizeClass(setMonthClass(1)),
+                onClick: ($event) => selectMonth(1)
+              }, vue.toDisplayString(vue.unref(index.t)("to.calendar.month.m1")), 11, ["onClick"]),
+              vue.createElementVNode("li", {
+                class: vue.normalizeClass(setMonthClass(2)),
+                onClick: ($event) => selectMonth(2)
+              }, vue.toDisplayString(vue.unref(index.t)("to.calendar.month.m2")), 11, ["onClick"]),
+              vue.createElementVNode("li", {
+                class: vue.normalizeClass(setMonthClass(3)),
+                onClick: ($event) => selectMonth(3)
+              }, vue.toDisplayString(vue.unref(index.t)("to.calendar.month.m3")), 11, ["onClick"]),
+              vue.createElementVNode("li", {
+                class: vue.normalizeClass(setMonthClass(4)),
+                onClick: ($event) => selectMonth(4)
+              }, vue.toDisplayString(vue.unref(index.t)("to.calendar.month.m4")), 11, ["onClick"]),
+              vue.createElementVNode("li", {
+                class: vue.normalizeClass(setMonthClass(5)),
+                onClick: ($event) => selectMonth(5)
+              }, vue.toDisplayString(vue.unref(index.t)("to.calendar.month.m5")), 11, ["onClick"]),
+              vue.createElementVNode("li", {
+                class: vue.normalizeClass(setMonthClass(6)),
+                onClick: ($event) => selectMonth(6)
+              }, vue.toDisplayString(vue.unref(index.t)("to.calendar.month.m6")), 11, ["onClick"]),
+              vue.createElementVNode("li", {
+                class: vue.normalizeClass(setMonthClass(7)),
+                onClick: ($event) => selectMonth(7)
+              }, vue.toDisplayString(vue.unref(index.t)("to.calendar.month.m7")), 11, ["onClick"]),
+              vue.createElementVNode("li", {
+                class: vue.normalizeClass(setMonthClass(8)),
+                onClick: ($event) => selectMonth(8)
+              }, vue.toDisplayString(vue.unref(index.t)("to.calendar.month.m8")), 11, ["onClick"]),
+              vue.createElementVNode("li", {
+                class: vue.normalizeClass(setMonthClass(9)),
+                onClick: ($event) => selectMonth(9)
+              }, vue.toDisplayString(vue.unref(index.t)("to.calendar.month.m9")), 11, ["onClick"]),
+              vue.createElementVNode("li", {
+                class: vue.normalizeClass(setMonthClass(10)),
+                onClick: ($event) => selectMonth(10)
+              }, vue.toDisplayString(vue.unref(index.t)("to.calendar.month.m10")), 11, ["onClick"]),
+              vue.createElementVNode("li", {
+                class: vue.normalizeClass(setMonthClass(11)),
+                onClick: ($event) => selectMonth(11)
+              }, vue.toDisplayString(vue.unref(index.t)("to.calendar.month.m11")), 11, ["onClick"]),
+              vue.createElementVNode("li", {
+                class: vue.normalizeClass(setMonthClass(12)),
+                onClick: ($event) => selectMonth(12)
+              }, vue.toDisplayString(vue.unref(index.t)("to.calendar.month.m12")), 11, ["onClick"])
+            ])
+          ])
+        ], 512), [
+          [vue.vShow, monthLayer.value || _ctx.type === "month"]
+        ]),
+        _ctx.type !== "month" ? (vue.openBlock(), vue.createElementBlock("div", {
+          key: 0,
+          class: "week"
+        }, [
+          vue.createElementVNode("ul", null, [
+            vue.createElementVNode("li", null, vue.toDisplayString(vue.unref(index.t)("to.calendar.week.w0")), 1),
+            vue.createElementVNode("li", null, vue.toDisplayString(vue.unref(index.t)("to.calendar.week.w1")), 1),
+            vue.createElementVNode("li", null, vue.toDisplayString(vue.unref(index.t)("to.calendar.week.w2")), 1),
+            vue.createElementVNode("li", null, vue.toDisplayString(vue.unref(index.t)("to.calendar.week.w3")), 1),
+            vue.createElementVNode("li", null, vue.toDisplayString(vue.unref(index.t)("to.calendar.week.w4")), 1),
+            vue.createElementVNode("li", null, vue.toDisplayString(vue.unref(index.t)("to.calendar.week.w5")), 1),
+            vue.createElementVNode("li", null, vue.toDisplayString(vue.unref(index.t)("to.calendar.week.w6")), 1)
+          ])
+        ])) : vue.createCommentVNode("", true),
+        _ctx.type !== "month" ? (vue.openBlock(), vue.createElementBlock("div", {
+          key: 1,
+          class: "day"
+        }, [
+          vue.createElementVNode("ul", null, [
+            (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(days.value, (item, index) => {
+              return vue.withDirectives((vue.openBlock(), vue.createElementBlock("li", {
+                key: index,
+                class: vue.normalizeClass(setDayClass(item)),
+                onClick: ($event) => selectDay(item)
+              }, [
+                vue.renderSlot(_ctx.$slots, "default", {
+                  item,
+                  index
+                }, () => [
+                  item.value ? (vue.openBlock(), vue.createElementBlock("span", {
+                    key: 0,
+                    class: "solar"
+                  }, vue.toDisplayString(dayText.value(item.value)), 1)) : vue.createCommentVNode("", true),
+                  item.point && item.point.length > 0 ? (vue.openBlock(), vue.createElementBlock("span", {
+                    key: 1,
+                    class: "to-calendar-points"
+                  }, [
+                    (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(item.point, (ipoint, pointIndex) => {
+                      return vue.withDirectives((vue.openBlock(), vue.createBlock(vue.unref(index$1.ToTag), {
+                        key: pointIndex,
+                        type: _ctx.size === "large" ? "dot" : "",
+                        color: pointColor.value(ipoint.type),
+                        fillet: _ctx.size === "large" ? "" : "round"
+                      }, {
+                        default: vue.withCtx(() => [
+                          vue.createTextVNode(vue.toDisplayString(ipoint.count), 1)
+                        ]),
+                        _: 2
+                      }, 1032, ["type", "color", "fillet"])), [
+                        [vue.unref(tip.default), ipoint.tooltip ? ipoint.tooltip : ""]
+                      ]);
+                    }), 128))
+                  ])) : vue.createCommentVNode("", true)
+                ])
+              ], 10, ["onClick"])), [
+                [vue.unref(dis.default), isDisableDay.value(item)]
+              ]);
+            }), 128))
+          ])
+        ])) : vue.createCommentVNode("", true),
+        _ctx.legend ? (vue.openBlock(), vue.createElementBlock("div", {
+          key: 2,
+          class: "to-calendar-legend"
+        }, [
+          vue.renderSlot(_ctx.$slots, "legend")
+        ])) : vue.createCommentVNode("", true),
+        _ctx.type === "datetime" || _ctx.type === "time" ? (vue.openBlock(), vue.createElementBlock("div", {
+          key: 3,
+          class: "time"
+        }, [
+          vue.createElementVNode("div", { class: "input to-calendar-time-input" }, [
+            vue.createVNode(vue.unref(index$2.ToInput), {
+              modelValue: hour.value,
+              "onUpdate:modelValue": ($event) => hour.value = $event,
+              type: "number",
+              mode: "none",
+              placeholder: vue.unref(index.t)("to.calendar.time.hPlaceholder"),
+              width: "full",
+              maxlength: 2,
+              max: maxHour.value,
+              min: 0,
+              onClick: showTimeLayer
+            }, null, 8, ["modelValue", "onUpdate:modelValue", "placeholder", "max"])
+          ]),
+          vue.createElementVNode("span", { class: "text" }, ":"),
+          vue.createElementVNode("span", { class: "input to-calendar-time-input" }, [
+            vue.createVNode(vue.unref(index$2.ToInput), {
+              modelValue: minute.value,
+              "onUpdate:modelValue": ($event) => minute.value = $event,
+              type: "number",
+              mode: "none",
+              placeholder: vue.unref(index.t)("to.calendar.time.mPlaceholder"),
+              width: "full",
+              maxlength: 2,
+              max: new Date(_ctx.max).getMinutes(),
+              min: 0,
+              onClick: showTimeLayer
+            }, null, 8, ["modelValue", "onUpdate:modelValue", "placeholder", "max"])
+          ]),
+          vue.createElementVNode("span", { class: "text" }, ":"),
+          vue.createElementVNode("span", { class: "input to-calendar-time-input" }, [
+            vue.createVNode(vue.unref(index$2.ToInput), {
+              modelValue: second.value,
+              "onUpdate:modelValue": ($event) => second.value = $event,
+              type: "number",
+              mode: "none",
+              placeholder: vue.unref(index.t)("to.calendar.time.sPlaceholder"),
+              width: "full",
+              maxlength: 2,
+              max: new Date(_ctx.max).getSeconds(),
+              min: 0,
+              onClick: showTimeLayer
+            }, null, 8, ["modelValue", "onUpdate:modelValue", "placeholder", "max"])
+          ]),
+          vue.createVNode(vue.unref(index$3.ToButton), {
+            color: "primary",
+            onClick: selectTime
+          }, {
+            default: vue.withCtx(() => [
+              vue.createTextVNode(vue.toDisplayString(vue.unref(index.t)("to.common.confirm")), 1)
+            ]),
+            _: 1
+          }),
+          vue.withDirectives(vue.createElementVNode("div", { class: "option" }, [
+            vue.createVNode(vue.unref(index$4.ToHeader), {
+              title: vue.unref(index.t)("to.calendar.time.title"),
+              color: "primary",
+              mode: "fill"
+            }, {
+              default: vue.withCtx(() => [
+                vue.createVNode(vue.unref(index$3.ToButton), {
+                  mode: "none",
+                  color: "bg",
+                  icon: "close",
+                  onClick: closeTimeLayer
+                })
+              ]),
+              _: 1
+            }, 8, ["title"]),
+            vue.createElementVNode("div", { class: "content" }, [
+              vue.createVNode(vue.unref(index$5.ToScroll), {
+                ref_key: "hourScroll",
+                ref: hourScroll,
+                vitrual: false,
+                "bar-display": "hover"
+              }, {
+                default: vue.withCtx(() => [
+                  vue.createVNode(vue.unref(index$6.ToPadding), { value: 0.5 }, {
+                    default: vue.withCtx(() => [
+                      vue.createVNode(vue.unref(index$7.ToGrid), { col: 2 }, {
+                        default: vue.withCtx(() => [
+                          (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(hours.value, (item) => {
+                            return vue.openBlock(), vue.createBlock(vue.unref(index$7.ToGridItem), { key: item }, {
+                              default: vue.withCtx(() => [
+                                vue.withDirectives((vue.openBlock(), vue.createBlock(vue.unref(index$8.ToCard), {
+                                  fillet: "normal",
+                                  color: hour.value === item ? "warning" : "default",
+                                  mode: hour.value === item ? "fill" : "none",
+                                  link: "",
+                                  onClick: ($event) => hour.value = item
+                                }, {
+                                  default: vue.withCtx(() => [
+                                    vue.createTextVNode(vue.toDisplayString(item), 1)
+                                  ]),
+                                  _: 2
+                                }, 1032, ["color", "mode", "onClick"])), [
+                                  [vue.unref(dis.default), isDisableHour.value(item)]
+                                ])
+                              ]),
+                              _: 2
+                            }, 1024);
+                          }), 128))
+                        ]),
+                        _: 1
+                      })
+                    ]),
+                    _: 1
+                  })
+                ]),
+                _: 1
+              }, 512),
+              vue.createVNode(vue.unref(index$5.ToScroll), {
+                ref_key: "minuteScroll",
+                ref: minuteScroll,
+                vitrual: false,
+                "bar-display": "hover"
+              }, {
+                default: vue.withCtx(() => [
+                  vue.createVNode(vue.unref(index$6.ToPadding), { value: 0.5 }, {
+                    default: vue.withCtx(() => [
+                      vue.createVNode(vue.unref(index$7.ToGrid), { col: 2 }, {
+                        default: vue.withCtx(() => [
+                          (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(minutes.value, (item) => {
+                            return vue.openBlock(), vue.createBlock(vue.unref(index$7.ToGridItem), { key: item }, {
+                              default: vue.withCtx(() => [
+                                vue.withDirectives((vue.openBlock(), vue.createBlock(vue.unref(index$8.ToCard), {
+                                  fillet: "normal",
+                                  color: minute.value === item ? "warning" : "default",
+                                  mode: minute.value === item ? "fill" : "none",
+                                  link: "",
+                                  onClick: ($event) => minute.value = item
+                                }, {
+                                  default: vue.withCtx(() => [
+                                    vue.createTextVNode(vue.toDisplayString(item), 1)
+                                  ]),
+                                  _: 2
+                                }, 1032, ["color", "mode", "onClick"])), [
+                                  [vue.unref(dis.default), isDisableMinute.value(item)]
+                                ])
+                              ]),
+                              _: 2
+                            }, 1024);
+                          }), 128))
+                        ]),
+                        _: 1
+                      })
+                    ]),
+                    _: 1
+                  })
+                ]),
+                _: 1
+              }, 512),
+              vue.createVNode(vue.unref(index$5.ToScroll), {
+                ref_key: "secondScroll",
+                ref: secondScroll,
+                vitrual: false,
+                "bar-display": "hover"
+              }, {
+                default: vue.withCtx(() => [
+                  vue.createVNode(vue.unref(index$6.ToPadding), { value: 0.5 }, {
+                    default: vue.withCtx(() => [
+                      vue.createVNode(vue.unref(index$7.ToGrid), { col: 2 }, {
+                        default: vue.withCtx(() => [
+                          (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(seconds.value, (item) => {
+                            return vue.openBlock(), vue.createBlock(vue.unref(index$7.ToGridItem), { key: item }, {
+                              default: vue.withCtx(() => [
+                                vue.withDirectives((vue.openBlock(), vue.createBlock(vue.unref(index$8.ToCard), {
+                                  fillet: "normal",
+                                  color: second.value === item ? "warning" : "default",
+                                  mode: second.value === item ? "fill" : "none",
+                                  link: "",
+                                  onClick: ($event) => second.value = item
+                                }, {
+                                  default: vue.withCtx(() => [
+                                    vue.createTextVNode(vue.toDisplayString(item), 1)
+                                  ]),
+                                  _: 2
+                                }, 1032, ["color", "mode", "onClick"])), [
+                                  [vue.unref(dis.default), isDisableSecond.value(item)]
+                                ])
+                              ]),
+                              _: 2
+                            }, 1024);
+                          }), 128))
+                        ]),
+                        _: 1
+                      })
+                    ]),
+                    _: 1
+                  })
+                ]),
+                _: 1
+              }, 512)
+            ])
+          ], 512), [
+            [vue.vShow, timeLayer.value]
+          ])
+        ])) : vue.createCommentVNode("", true)
+      ], 6);
+    };
+  }
+});
+
+exports.default = _sfc_main;
+//# sourceMappingURL=calendar.vue2.js.map