@ibiz-template/mob-vue3-components 0.0.1-alpha.19

package/lib/node_modules/.pnpm/vue3-hash-calendar@1.1.3_vue@3.3.8/node_modules/vue3-hash-calendar/es/Calendar.cjs

@@ -0,0 +1,567 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vue = require('vue');
+require('./constant/index.cjs');
+require('./utils/index.cjs');
+var index = require('./language/index.cjs');
+require('./hooks/index.cjs');
+var CalendarDate = require('./CalendarDate.cjs');
+var CalendarTime = require('./CalendarTime.cjs');
+var CalendarYearMonth = require('./CalendarYearMonth.cjs');
+var props = require('./utils/props.cjs');
+var basic = require('./utils/basic.cjs');
+var useExpose = require('./hooks/use-expose.cjs');
+var useMountedOrActivated = require('./hooks/use-mounted-or-activated.cjs');
+var img = require('./constant/img.cjs');
+
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+const calendarProps = {
+  themeColor: {
+    type: Object,
+    default: () => ({})
+  },
+  changeYearFast: Boolean,
+  showArrow: Boolean,
+  showWeekView: Boolean,
+  visible: Boolean,
+  disabledWeekView: Boolean,
+  showAction: props.truthProp,
+  pickerType: props.makeStringProp("datetime"),
+  selectType: props.makeStringProp("single"),
+  defaultYearMonth: {
+    type: Object,
+    default: {}
+  },
+  allowSameDay: Boolean,
+  showTodayButton: props.truthProp,
+  defaultDatetime: [Date, Array],
+  minDate: props.makeDateProp(null),
+  maxDate: props.makeDateProp(null),
+  maxRange: props.makeNumberProp(0),
+  format: props.makeStringProp(""),
+  model: props.makeStringProp("inline"),
+  markType: props.makeStringProp("dot"),
+  markDate: props.makeArrayProp(),
+  disabledDate: {
+    type: Function,
+    default: () => false
+  },
+  disabledTime: {
+    type: Function,
+    default: () => false
+  },
+  lang: props.makeStringProp("CN"),
+  scrollChangeDate: props.truthProp,
+  minuteStep: props.makeNumberProp(1),
+  weekStart: props.makeStringProp("Sunday"),
+  disabledScroll: {
+    type: [Boolean, String],
+    default: () => false
+  },
+  showNotCurrentMonthDay: props.truthProp,
+  firstDayOfMonthClassName: props.makeStringProp(""),
+  todayClassName: props.makeStringProp(""),
+  checkedDayClassName: props.makeStringProp(""),
+  notCurrentMonthDayClassName: props.makeStringProp(""),
+  disabledClassName: props.makeStringProp("")
+};
+var stdin_default = vue.defineComponent({
+  name: "VueHashCalendar",
+  props: calendarProps,
+  emits: ["update:visible", "update:showWeekView", "calendarTypeChange", "click", "confirm", "change", "overRange", "slidechange", "touchstart", "touchmove", "touchend"],
+  setup(props, {
+    emit,
+    slots
+  }) {
+    const calendarRef = vue.ref();
+    const isShowCalendar = vue.ref(true);
+    const isShowWeek = vue.ref(props.showWeekView);
+    const calendarBodyHeight = vue.ref(0);
+    const firstTimes = vue.ref(true);
+    const currentYearMonth = vue.ref({
+      year: new Date().getFullYear(),
+      month: new Date().getMonth()
+    });
+    const limitDateRange = (date, minDate = props.minDate, maxDate = props.maxDate) => {
+      if (minDate && basic.compareDay(basic.transDateToYearMonthDay(date), basic.transDateToYearMonthDay(minDate)) === -1) {
+        return minDate;
+      }
+      if (maxDate && basic.compareDay(basic.transDateToYearMonthDay(date), basic.transDateToYearMonthDay(maxDate)) === 1) {
+        return maxDate;
+      }
+      return date;
+    };
+    const getInitialDateTime = (defaultDatetime = props.defaultDatetime) => {
+      const {
+        selectType,
+        minDate,
+        maxDate,
+        allowSameDay
+      } = props;
+      if (defaultDatetime === null)
+        return defaultDatetime;
+      const nowDate = basic.getToday();
+      const nowDatetime = new Date();
+      if (selectType === "range") {
+        if (!Array.isArray(defaultDatetime)) {
+          defaultDatetime = [];
+        }
+        const start = limitDateRange(defaultDatetime[0] || nowDate, minDate, allowSameDay ? maxDate : basic.getPrevDay(basic.transDateToYearMonthDay(maxDate)));
+        const end = limitDateRange(defaultDatetime[1] || nowDate, allowSameDay ? minDate : basic.getNextDay(basic.transDateToYearMonthDay(minDate)));
+        return [start, end];
+      }
+      if (selectType === "multiple") {
+        if (Array.isArray(defaultDatetime)) {
+          return defaultDatetime.map((date) => limitDateRange(date));
+        }
+        return [limitDateRange(nowDate)];
+      }
+      if (!defaultDatetime || Array.isArray(defaultDatetime)) {
+        defaultDatetime = nowDatetime;
+      }
+      return limitDateRange(defaultDatetime);
+    };
+    const currDateTime = vue.ref(getInitialDateTime());
+    const checkedDate = vue.ref([basic.transDateToHourMinute(new Date())]);
+    const yearMonthType = vue.ref("date");
+    const isShowDatetimePicker = vue.computed({
+      get() {
+        return props.model === "inline" ? true : props.visible;
+      },
+      set(val) {
+        emit("update:visible", val);
+      }
+    });
+    const isShowArrowImg = vue.computed(() => props.showArrow && props.model === "inline");
+    const calendarContentHeight = vue.computed(() => {
+      if (props.pickerType === "time") {
+        return 245;
+      }
+      return calendarBodyHeight.value;
+    });
+    const slideChange = (direction) => {
+      emit("slidechange", direction);
+    };
+    const toggleWeek = () => {
+      isShowWeek.value = !isShowWeek.value;
+      if (isShowWeek.value)
+        slideChange("up");
+      else
+        slideChange("down");
+    };
+    const today = () => {
+      var _a;
+      if (props.disabledDate(new Date()))
+        return;
+      (_a = calendarRef.value) == null ? void 0 : _a.today();
+    };
+    const reset = (date = getInitialDateTime()) => {
+      currDateTime.value = date;
+    };
+    const lastMonth = () => {
+      var _a;
+      (_a = calendarRef.value) == null ? void 0 : _a.getLastMonth();
+    };
+    const nextMonth = () => {
+      var _a;
+      (_a = calendarRef.value) == null ? void 0 : _a.getNextMonth();
+    };
+    const lastWeek = () => {
+      var _a, _b;
+      (_a = calendarRef.value) == null ? void 0 : _a.getLastMonth();
+      (_b = calendarRef.value) == null ? void 0 : _b.changeWeekView({
+        isNext: false
+      });
+    };
+    const nextWeek = () => {
+      var _a, _b;
+      (_a = calendarRef.value) == null ? void 0 : _a.getNextMonth();
+      (_b = calendarRef.value) == null ? void 0 : _b.changeWeekView({
+        isNext: true
+      });
+    };
+    const dateChange = (date) => {
+      if (props.selectType === "single") {
+        checkedDate.value = [__spreadValues(__spreadValues({}, checkedDate.value[0]), date[0])];
+      } else {
+        checkedDate.value = date;
+      }
+    };
+    const dateClick = (date) => {
+      if (!date.day)
+        return;
+      let fDate;
+      if (props.selectType === "single") {
+        const checked = checkedDate.value[0];
+        date.minutes = checked.minutes;
+        date.hours = checked.hours;
+        fDate = basic.transHourMinuteToDate(date);
+      } else {
+        fDate = basic.transYearMontDayToDate(date);
+      }
+      currDateTime.value = new Date(fDate);
+      if (props.format) {
+        fDate = basic.formatDate(fDate, props.format, props.lang);
+      }
+      emit("click", fDate);
+    };
+    const yearMonthClick = (date, type) => {
+      if (type) {
+        switch (type) {
+          case "yearRange":
+            yearMonthType.value = "year";
+            break;
+          case "year":
+            yearMonthType.value = "month";
+            break;
+          case "month":
+            yearMonthType.value = "date";
+            break;
+        }
+        emit("calendarTypeChange", yearMonthType.value);
+      }
+      currentYearMonth.value = {
+        year: date.year,
+        month: date.month
+      };
+      dateClick(date);
+      if (props.selectType === "single") {
+        const {
+          day,
+          hours,
+          minutes
+        } = checkedDate.value[0];
+        let emitDate = basic.transHourMinuteToDate(__spreadProps(__spreadValues({}, currentYearMonth.value), {
+          day,
+          hours,
+          minutes
+        }));
+        if (props.format) {
+          emitDate = basic.formatDate(emitDate, props.format, props.lang);
+        }
+        emit("change", emitDate);
+      }
+    };
+    const timeChange = (date) => {
+      const {
+        minutes,
+        hours
+      } = date;
+      const checked = checkedDate.value[0];
+      checkedDate.value = [__spreadProps(__spreadValues({}, checked), {
+        minutes,
+        hours
+      })];
+    };
+    const close = () => {
+      isShowDatetimePicker.value = false;
+    };
+    const makeEmitDate = () => {
+      const dateArr = checkedDate.value.map((item) => {
+        let date = basic.transYearMontDayToDate(item);
+        if (props.selectType === "single") {
+          date = basic.transHourMinuteToDate(item);
+        }
+        if (props.format) {
+          return basic.formatDate(date, props.format, props.lang);
+        }
+        return date;
+      });
+      if (props.selectType === "single") {
+        return dateArr[0];
+      }
+      return dateArr;
+    };
+    const confirm = () => {
+      emit("confirm", makeEmitDate());
+      if (props.model === "dialog") {
+        close();
+      }
+    };
+    const formatDatetime = (time, format) => basic.formatDate(time, format, props.lang);
+    const showYearMonthPicker = () => {
+      if (!props.changeYearFast)
+        return;
+      if (yearMonthType.value === "date") {
+        yearMonthType.value = "month";
+      } else if (yearMonthType.value === "month") {
+        yearMonthType.value = "year";
+      } else if (yearMonthType.value === "year") {
+        yearMonthType.value = "yearRange";
+      } else {
+        yearMonthType.value = "date";
+      }
+      emit("calendarTypeChange", yearMonthType.value);
+    };
+    const showCalendar = () => {
+      if (isShowCalendar.value) {
+        showYearMonthPicker();
+      } else {
+        emit("calendarTypeChange", "date");
+      }
+      isShowCalendar.value = true;
+    };
+    const showTime = () => {
+      isShowCalendar.value = false;
+      emit("calendarTypeChange", "time");
+      yearMonthType.value = "date";
+    };
+    const heightChange = (height) => {
+      if (!firstTimes.value && props.model === "dialog")
+        return;
+      calendarBodyHeight.value = height;
+      firstTimes.value = false;
+    };
+    const getThemeColor = () => {
+      const cssVar = {};
+      if (props.themeColor) {
+        const themeColorKeys = Object.keys(props.themeColor || {});
+        if (themeColorKeys.length) {
+          themeColorKeys.forEach((k) => {
+            cssVar[`--hash-calendar-${k}`] = props.themeColor[k];
+          });
+        }
+      }
+      return cssVar;
+    };
+    const touchStart = (event) => {
+      emit("touchstart", event);
+    };
+    const touchMove = (event) => {
+      emit("touchmove", event);
+    };
+    const touchEnd = (event) => {
+      emit("touchend", event);
+    };
+    vue.watch(checkedDate, () => {
+      const emitDate = makeEmitDate();
+      if (props.selectType === "range" && Array.isArray(emitDate) && emitDate.length === 1) {
+        return;
+      }
+      emit("change", emitDate);
+    }, {
+      deep: true
+    });
+    vue.watch(() => props.showWeekView, (val) => {
+      isShowWeek.value = val;
+    });
+    vue.watch(() => [props.selectType, props.minDate, props.maxDate], () => {
+      if (props.selectType === "single") {
+        reset(getInitialDateTime());
+      } else {
+        reset(getInitialDateTime(currDateTime.value));
+      }
+    });
+    useExpose.useExpose({
+      today,
+      reset,
+      lastMonth,
+      nextMonth,
+      lastWeek,
+      nextWeek
+    });
+    const init = () => {
+      const date = currDateTime.value;
+      if (!date) {
+        checkedDate.value = [];
+      } else if (date instanceof Date) {
+        currentYearMonth.value = {
+          year: date.getFullYear(),
+          month: date.getMonth()
+        };
+        checkedDate.value = [basic.transDateToHourMinute(date)];
+      } else if (Array.isArray(date)) {
+        if (props.selectType === "range") {
+          const dateArr = basic.calcMiddleDay([__spreadProps(__spreadValues({}, basic.transDateToHourMinute(date[0])), {
+            type: "start"
+          }), __spreadProps(__spreadValues({}, basic.transDateToHourMinute(date[1])), {
+            type: "end"
+          })]);
+          checkedDate.value = dateArr.map((item) => basic.transDateToHourMinute(basic.transYearMontDayToDate(item)));
+        } else {
+          checkedDate.value = date.map((item) => basic.transDateToHourMinute(item));
+        }
+      }
+      if (props.pickerType === "time") {
+        showTime();
+      } else {
+        isShowCalendar.value = true;
+      }
+    };
+    useMountedOrActivated.useMountedOrActivated(init);
+    const renderTodayButton = () => {
+      let todayEle = index.default[props.lang].TODAY;
+      if (slots.today) {
+        todayEle = slots.today();
+      }
+      if (props.showTodayButton) {
+        return vue.createVNode("div", {
+          "class": `calendar_confirm ${props.disabledDate(new Date()) ? "today_disable" : ""}`,
+          "onClick": today
+        }, [todayEle]);
+      }
+    };
+    const renderConfirmButton = () => {
+      let confirmEle = index.default[props.lang].CONFIRM;
+      if (slots.confirm) {
+        confirmEle = slots.confirm();
+      }
+      if (props.model === "dialog") {
+        return vue.createVNode("div", {
+          "class": "calendar_confirm",
+          "onClick": confirm
+        }, [confirmEle]);
+      }
+    };
+    const renderAction = () => {
+      let timeText = "";
+      const {
+        year,
+        month
+      } = currentYearMonth.value;
+      let dateText = formatDatetime(`${year}/${month + 1}`, index.default[props.lang].DEFAULT_YEAR_MONTH_FORMAT);
+      if (props.selectType === "single") {
+        const {
+          day,
+          hours,
+          minutes
+        } = checkedDate.value[0];
+        timeText = formatDatetime(`${year}/${month + 1}/${day} ${basic.fillNumber(hours)}:${basic.fillNumber(minutes)}`, index.default[props.lang].DEFAULT_TIME_FORMAT);
+        dateText = formatDatetime(`${year}/${month + 1}/${day}`, index.default[props.lang].DEFAULT_DATE_FORMAT);
+      }
+      if (props.showAction) {
+        return vue.createVNode("div", {
+          "class": "calendar_title",
+          "onClick": (e) => {
+            if (e.cancelable)
+              e.preventDefault();
+            e.stopPropagation();
+          },
+          "style": {
+            bottom: props.model === "dialog" ? `${calendarContentHeight.value}px` : "unset"
+          }
+        }, [slots.action ? slots.action() : vue.createVNode(vue.Fragment, null, [vue.createVNode("div", {
+          "class": "calendar_title_date"
+        }, [props.pickerType !== "time" ? vue.createVNode("span", {
+          "class": `calendar_title_date_year ${isShowCalendar.value ? "calendar_title_date_active" : ""}`,
+          "onClick": showCalendar
+        }, [dateText]) : null, props.pickerType !== "date" && props.selectType === "single" ? vue.createVNode("span", {
+          "class": `calendar_title_date_time ${!isShowCalendar.value ? "calendar_title_date_active" : ""}`,
+          "onClick": showTime
+        }, [timeText]) : null]), renderTodayButton(), renderConfirmButton()])]);
+      }
+      return null;
+    };
+    const updateShowWeekView = (val) => {
+      if (isShowWeek.value === val)
+        return;
+      if (val) {
+        emit("calendarTypeChange", "week");
+      } else {
+        emit("calendarTypeChange", "date");
+      }
+      isShowWeek.value = val;
+    };
+    const yearMonthChange = (yearMonth) => {
+      currentYearMonth.value = yearMonth;
+    };
+    const renderCalendar = () => vue.createVNode(CalendarDate.default, vue.mergeProps({
+      "ref": calendarRef,
+      "show": isShowCalendar.value,
+      "onHeight": heightChange,
+      "defaultDate": currDateTime.value,
+      "onTouchstart": touchStart,
+      "onTouchmove": touchMove,
+      "onTouchend": touchEnd,
+      "onSlidechange": slideChange,
+      "onYearMonthChange": yearMonthChange,
+      "onChange": dateChange,
+      "onOverRange": () => emit("overRange"),
+      "onClick": dateClick,
+      "showWeekView": isShowWeek.value,
+      "onUpdate:showWeekView": updateShowWeekView
+    }, basic.pick(props, ["minDate", "maxDate", "maxRange", "disabledWeekView", "markType", "selectType", "allowSameDay", "defaultYearMonth", "markDate", "disabledDate", "lang", "weekStart", "disabledScroll", "scrollChangeDate", "showNotCurrentMonthDay", "firstDayOfMonthClassName", "todayClassName", "checkedDayClassName", "notCurrentMonthDayClassName", "disabledClassName"])), basic.pick(slots, ["week", "day"]));
+    const renderTimePicker = () => {
+      if (props.pickerType === "datetime" || props.pickerType === "time") {
+        return vue.createVNode(CalendarTime.default, vue.mergeProps({
+          "show": !isShowCalendar.value,
+          "defaultTime": currDateTime.value,
+          "calendarDate": checkedDate.value[0],
+          "onChange": timeChange
+        }, basic.pick(props, ["minuteStep", "disabledTime"])), null);
+      }
+    };
+    const renderYearMonthPicker = () => vue.createVNode(CalendarYearMonth.default, vue.mergeProps({
+      "calendarContentHeight": calendarContentHeight.value,
+      "currentYearMonth": currentYearMonth.value,
+      "type": yearMonthType.value,
+      "onTouchstart": touchStart,
+      "onTouchmove": touchMove,
+      "onTouchend": touchEnd,
+      "onSlidechange": slideChange,
+      "onClick": yearMonthClick
+    }, basic.pick(props, ["minDate", "maxDate", "disabledDate", "lang", "disabledScroll", "checkedDayClassName", "notCurrentMonthDayClassName", "disabledClassName"])), null);
+    const renderCtrlImg = () => {
+      let confirmEle = vue.createVNode("img", {
+        "src": isShowWeek.value ? img.ARROW_DOWN_IMG : img.ARROW_UP_IMG
+      }, null);
+      if (slots.arrow) {
+        confirmEle = slots.arrow({
+          isShowWeek: isShowWeek.value
+        });
+      }
+      if (isShowArrowImg.value) {
+        return vue.createVNode("div", {
+          "class": "ctrl-img",
+          "onClick": toggleWeek,
+          "style": {
+            "margin-top": props.model === "dialog" ? `${calendarContentHeight.value}px` : "unset"
+          }
+        }, [confirmEle]);
+      }
+    };
+    const renderHashCalendar = () => {
+      if (isShowDatetimePicker.value || props.model === "inline") {
+        return vue.createVNode("div", {
+          "class": `hash-calendar ${props.model === "inline" ? "calendar_inline" : ""}`,
+          "style": __spreadValues({}, getThemeColor()),
+          "onClick": close
+        }, [renderAction(), vue.createVNode("div", {
+          "class": "calendar_content",
+          "style": {
+            height: `${calendarContentHeight.value}px`
+          },
+          "onClick": (e) => {
+            if (e.cancelable)
+              e.preventDefault();
+            e.stopImmediatePropagation();
+          }
+        }, [props.pickerType !== "time" ? renderCalendar() : "", props.selectType === "single" && renderTimePicker(), props.changeYearFast ? renderYearMonthPicker() : ""]), renderCtrlImg()]);
+      }
+    };
+    return () => renderHashCalendar();
+  }
+});
+
+exports.calendarProps = calendarProps;
+exports.default = stdin_default;