@nutui/nutui-react-taro 2.0.0-alpha.9 → 2.0.0-beta.2

package/dist/esm/calendaritem.taro-0262d6ab.js

@@ -0,0 +1,812 @@
+import React, { useState, useRef, useEffect } from "react";
+import classNames from "classnames";
+import { ScrollView } from "@tarojs/components";
+import Taro, { nextTick } from "@tarojs/taro";
+import { C as ComponentDefaults } from "./typings-11d83a22.js";
+import { u as useConfig } from "./configprovider.taro-a7f3bcfd.js";
+import { u as usePropsValue } from "./use-props-value-7ac1b1b5.js";
+const Utils = {
+  /**
+   * 是否为闫年
+   * @return {Boolse} true|false
+   */
+  isLeapYear(y) {
+    return y % 4 == 0 && y % 100 != 0 || y % 400 == 0;
+  },
+  /**
+   * 返回星期数
+   * @return {String}
+   */
+  getWhatDay(year, month, day) {
+    const date = /* @__PURE__ */ new Date(`${year}/${month}/${day}`);
+    const index = date.getDay();
+    const dayNames = [
+      "星期日",
+      "星期一",
+      "星期二",
+      "星期三",
+      "星期四",
+      "星期五",
+      "星期六"
+    ];
+    return dayNames[index];
+  },
+  /**
+   * 返回上一个月在当前面板中的天数
+   * @return {Number}
+   */
+  getMonthPreDay(year, month) {
+    const date = /* @__PURE__ */ new Date(`${year}/${month}/01`);
+    let day = date.getDay();
+    if (day === 0) {
+      day = 7;
+    }
+    return day;
+  },
+  /**
+   * 返回月份天数
+   * @return {Number}
+   */
+  getMonthDays(year, month) {
+    if (/^0/.test(month)) {
+      month = month.split("")[1];
+    }
+    return [
+      0,
+      31,
+      this.isLeapYear(Number(year)) ? 29 : 28,
+      31,
+      30,
+      31,
+      30,
+      31,
+      31,
+      30,
+      31,
+      30,
+      31
+    ][month];
+  },
+  /**
+   * 补齐数字位数
+   * @return {string}
+   */
+  getNumTwoBit(n) {
+    n = Number(n);
+    return (n > 9 ? "" : "0") + n;
+  },
+  /**
+   * 日期对象转成字符串
+   * @return {string}
+   */
+  date2Str(date, split) {
+    split = split || "-";
+    const y = date.getFullYear();
+    const m = this.getNumTwoBit(date.getMonth() + 1);
+    const d = this.getNumTwoBit(date.getDate());
+    return [y, m, d].join(split);
+  },
+  /**
+   * 返回日期格式字符串
+   * @param {Number} 0返回今天的日期、1返回明天的日期，2返回后天得日期，依次类推
+   * @return {string} '2014-12-31'
+   */
+  getDay(i) {
+    i = i || 0;
+    let date = /* @__PURE__ */ new Date();
+    const diff = i * (1e3 * 60 * 60 * 24);
+    date = new Date(date.getTime() + diff);
+    return this.date2Str(date);
+  },
+  /**
+   * 时间比较
+   * @return {Boolean}
+   */
+  compareDate(date1, date2) {
+    const startTime = new Date(date1.replace("-", "/").replace("-", "/"));
+    const endTime = new Date(date2.replace("-", "/").replace("-", "/"));
+    if (startTime >= endTime) {
+      return false;
+    }
+    return true;
+  },
+  /**
+   * 时间是否相等
+   * @return {Boolean}
+   */
+  isEqual(date1 = "", date2) {
+    const startTime = new Date(date1.replace("-", "/")).getTime();
+    const endTime = new Date(date2.replace("-", "/")).getTime();
+    if (startTime === endTime) {
+      return true;
+    }
+    return false;
+  },
+  getMonthWeek(year, month, date, firstDayOfWeek = 0) {
+    const dateNow = new Date(Number(year), parseInt(month) - 1, Number(date));
+    let w = dateNow.getDay();
+    const d = dateNow.getDate();
+    let remainder = 6 - w;
+    if (firstDayOfWeek !== 0) {
+      w = w === 0 ? 7 : w;
+      remainder = 7 - w;
+    }
+    return Math.ceil((d + remainder) / 7);
+  },
+  getYearWeek(year, month, date, firstDayOfWeek = 0) {
+    const dateNow = new Date(Number(year), parseInt(month) - 1, Number(date));
+    const dateFirst = new Date(Number(year), 0, 1);
+    const dataNumber = Math.round((dateNow.valueOf() - dateFirst.valueOf()) / 864e5);
+    return Math.ceil((dataNumber + (dateFirst.getDay() + 1 - 1)) / 7);
+  },
+  getWeekDate(year, month, date, firstDayOfWeek = 0) {
+    const dateNow = new Date(Number(year), parseInt(month) - 1, Number(date));
+    const nowTime = dateNow.getTime();
+    let day = dateNow.getDay();
+    if (firstDayOfWeek === 0) {
+      const oneDayTime2 = 24 * 60 * 60 * 1e3;
+      const SundayTime2 = nowTime - day * oneDayTime2;
+      const SaturdayTime = nowTime + (6 - day) * oneDayTime2;
+      const sunday2 = this.date2Str(new Date(SundayTime2));
+      const saturday = this.date2Str(new Date(SaturdayTime));
+      return [sunday2, saturday];
+    }
+    day = day === 0 ? 7 : day;
+    const oneDayTime = 24 * 60 * 60 * 1e3;
+    const MondayTime = nowTime - (day - 1) * oneDayTime;
+    const SundayTime = nowTime + (7 - day) * oneDayTime;
+    const monday = this.date2Str(new Date(MondayTime));
+    const sunday = this.date2Str(new Date(SundayTime));
+    return [monday, sunday];
+  },
+  formatResultDate(date) {
+    const days = [...date.split("-")];
+    days[2] = Utils.getNumTwoBit(Number(days[2]));
+    days[3] = `${days[0]}-${days[1]}-${days[2]}`;
+    days[4] = Utils.getWhatDay(+days[0], +days[1], +days[2]);
+    return days;
+  }
+};
+const getCurrMonthData = (type, year, month) => {
+  switch (type) {
+    case "prev":
+      month === 1 && (year -= 1);
+      month = month === 1 ? 12 : --month;
+      break;
+    case "next":
+      month === 12 && (year += 1);
+      month = month === 12 ? 1 : ++month;
+      break;
+  }
+  return [
+    year,
+    Utils.getNumTwoBit(month),
+    Utils.getMonthDays(String(year), String(month))
+  ];
+};
+const getDaysStatus = (type, year, month) => {
+  let days = Utils.getMonthDays(`${year}`, `${month}`);
+  if (type === "prev" && days >= 7) {
+    days -= 7;
+  }
+  return Array.from(Array(days), (v, k) => {
+    return {
+      day: k + 1,
+      type,
+      year,
+      month
+    };
+  });
+};
+const getPreMonthDates = (type, year, month, firstDayOfWeek) => {
+  let preMonth = +month - 1;
+  let preYear = year;
+  if (preMonth <= 0) {
+    preMonth = 12;
+    preYear += 1;
+  }
+  let days = Utils.getMonthPreDay(+year, +month);
+  days -= firstDayOfWeek;
+  if (type === "prev" && days >= 7) {
+    days -= 7;
+  }
+  const preDates = Utils.getMonthDays(`${preYear}`, `${preMonth}`);
+  const months = Array.from(Array(preDates), (v, k) => {
+    return {
+      day: k + 1,
+      type,
+      preYear,
+      preMonth
+    };
+  });
+  return months.slice(preDates - days);
+};
+const _window = window;
+function requestAniFrame() {
+  if (typeof _window !== "undefined") {
+    return _window.requestAnimationFrame || _window.webkitRequestAnimationFrame || function(callback) {
+      _window.setTimeout(callback, 1e3 / 60);
+    };
+  }
+  return function(callback) {
+    setTimeout(callback, 1e3 / 60);
+  };
+}
+const requestAniFrame$1 = requestAniFrame();
+const splitDate = (date) => {
+  const split = date.indexOf("-") !== -1 ? "-" : "/";
+  return date.split(split);
+};
+const isMultiple = (day, days) => {
+  if (days.length > 0) {
+    return days.some((item) => {
+      return Utils.isEqual(item, day);
+    });
+  }
+  return false;
+};
+const isCurrDay = (month, day) => {
+  const date = `${month.curData[0]}/${month.curData[1]}/${day}`;
+  return Utils.isEqual(date, Utils.date2Str(/* @__PURE__ */ new Date(), "/"));
+};
+const getCurrDate = (day, month) => {
+  return `${month.curData[0]}/${month.curData[1]}/${Utils.getNumTwoBit(+day.day)}`;
+};
+const isStart = (day, days) => {
+  return Utils.isEqual(days[0], day);
+};
+const isEnd = (day, days) => {
+  return Utils.isEqual(days[1], day);
+};
+const isStartAndEnd = (days) => {
+  return days.length >= 2 && Utils.isEqual(days[0], days[1]);
+};
+const defaultProps = {
+  ...ComponentDefaults,
+  type: "single",
+  autoBackfill: false,
+  popup: true,
+  title: "",
+  startDate: Utils.getDay(0),
+  endDate: Utils.getDay(365),
+  showToday: true,
+  startText: "",
+  endText: "",
+  confirmText: "",
+  showTitle: true,
+  showSubTitle: true,
+  scrollAnimation: true,
+  firstDayOfWeek: 0,
+  renderHeaderButtons: void 0,
+  renderDay: void 0,
+  renderDayTop: void 0,
+  renderDayBottom: void 0,
+  onConfirm: (data) => {
+  },
+  onUpdate: () => {
+  },
+  onDayClick: (data) => {
+  },
+  onPageChange: (data) => {
+  }
+};
+const CalendarItem = React.forwardRef((props, ref) => {
+  const { locale } = useConfig();
+  const { popup, type, autoBackfill, title, defaultValue, startDate, endDate, showToday, startText, endText, confirmText, showTitle, showSubTitle, scrollAnimation, firstDayOfWeek, renderHeaderButtons, renderDay, renderDayTop, renderDayBottom, onConfirm, onUpdate, onDayClick, onPageChange } = { ...defaultProps, ...props };
+  const weekdays = locale.calendaritem.weekdays;
+  const weeks = [
+    ...weekdays.slice(firstDayOfWeek, 7),
+    ...weekdays.slice(0, firstDayOfWeek)
+  ];
+  const monthTitle = locale.calendaritem.monthTitle;
+  const [yearMonthTitle, setYearMonthTitle] = useState("");
+  const [monthsData, setMonthsData] = useState([]);
+  const [monthsNum, setMonthsNum] = useState(0);
+  const [translateY, setTranslateY] = useState(0);
+  const [monthDefaultRange, setMonthDefaultRange] = useState([]);
+  const [scrollTop, setScrollTop] = useState(0);
+  const [scrollWithAnimation, setScrollWithAnimation] = useState(false);
+  const propStartDate = startDate || Utils.getDay(0);
+  const propEndDate = endDate || Utils.getDay(365);
+  const startDates = splitDate(propStartDate);
+  const endDates = splitDate(propEndDate);
+  const [state] = useState({
+    currDateArray: []
+  });
+  const resetDefaultValue = () => {
+    if (defaultValue || Array.isArray(defaultValue) && defaultValue.length > 0) {
+      return type !== "single" ? [...defaultValue] : defaultValue;
+    }
+    return void 0;
+  };
+  const [currentDate, setCurrentDate] = usePropsValue({
+    value: props.value,
+    defaultValue: resetDefaultValue(),
+    finalValue: [],
+    onChange: (val) => {
+    }
+  });
+  const weeksPanel = useRef(null);
+  const monthsRef = useRef(null);
+  const monthsPanel = useRef(null);
+  const viewAreaRef = useRef(null);
+  const [avgHeight, setAvgHeight] = useState(0);
+  let viewHeight = 0;
+  const classPrefix = "nut-calendar";
+  const dayPrefix = "nut-calendar-day";
+  const getMonthData = (curData, monthNum, type2) => {
+    let i = 0;
+    let date = curData;
+    const monthData = monthsData;
+    do {
+      const y = parseInt(date[0], 10);
+      const m = parseInt(date[1], 10);
+      const days = [
+        ...getPreMonthDates("prev", y, m, firstDayOfWeek),
+        ...getDaysStatus("active", y, m)
+      ];
+      const cssHeight = 39 + (days.length > 35 ? 384 : 320);
+      let scrollTop2 = 0;
+      if (monthData.length > 0) {
+        const monthEle = monthData[monthData.length - 1];
+        scrollTop2 = monthEle.scrollTop + monthEle.cssHeight;
+      }
+      const monthInfo = {
+        curData: date,
+        title: monthTitle(y, m),
+        monthData: days,
+        cssHeight,
+        scrollTop: scrollTop2
+      };
+      if (type2 === "next") {
+        if (!endDates || !Utils.compareDate(`${endDates[0]}/${endDates[1]}/${Utils.getMonthDays(endDates[0], endDates[1])}`, `${curData[0]}/${curData[1]}/${curData[2]}`)) {
+          monthData.push(monthInfo);
+        }
+      } else if (!startDates || !Utils.compareDate(`${curData[0]}/${curData[1]}/${curData[2]}`, `${startDates[0]}/${startDates[1]}/01`)) {
+        monthData.unshift(monthInfo);
+      }
+      date = getCurrMonthData("next", y, m);
+    } while (i++ < monthNum);
+    setMonthsData(monthData);
+  };
+  const setReachedYearMonthInfo = (current) => {
+    const currentMonthsData = monthsData[current];
+    const [year, month] = currentMonthsData.curData;
+    if (currentMonthsData.title === yearMonthTitle)
+      return;
+    onPageChange && onPageChange([year, month, `${year}-${month}`]);
+    setYearMonthTitle(currentMonthsData.title);
+  };
+  const setDefaultRange = (monthNum, current) => {
+    let start = 0;
+    let end = 0;
+    if (monthNum >= 3) {
+      if (current > 0 && current < monthNum) {
+        start = current - 1;
+        end = current + 3;
+      } else if (current === 0) {
+        start = current;
+        end = current + 4;
+      } else if (current === monthNum) {
+        start = current - 2;
+        end = current + 2;
+      }
+    } else {
+      start = 0;
+      end = monthNum + 2;
+    }
+    setMonthDefaultRange([start, end]);
+    setTranslateY(monthsData[start].scrollTop);
+    setReachedYearMonthInfo(current);
+  };
+  const getMonthNum = () => {
+    let monthNum = Number(endDates[1]) - Number(startDates[1]);
+    const yearNum = Number(endDates[0]) - Number(startDates[0]);
+    if (yearNum > 0) {
+      monthNum += 12 * yearNum;
+    }
+    if (monthNum <= 0) {
+      monthNum = 1;
+    }
+    setMonthsNum(monthNum);
+    return monthNum;
+  };
+  const setDefaultDate = () => {
+    let defaultData = [];
+    if (type === "range" && Array.isArray(currentDate)) {
+      if (currentDate.length > 0) {
+        if (propStartDate && Utils.compareDate(currentDate[0], propStartDate)) {
+          currentDate.splice(0, 1, propStartDate);
+        }
+        if (propEndDate && Utils.compareDate(propEndDate, currentDate[1])) {
+          currentDate.splice(1, 1, propEndDate);
+        }
+        defaultData = [
+          ...splitDate(currentDate[0]),
+          ...splitDate(currentDate[1])
+        ];
+      }
+    } else if (type === "multiple" && Array.isArray(currentDate)) {
+      if (currentDate.length > 0) {
+        const defaultArr = [];
+        const obj = {};
+        currentDate.forEach((item) => {
+          if (propStartDate && !Utils.compareDate(item, propStartDate) && propEndDate && !Utils.compareDate(propEndDate, item)) {
+            if (!Object.hasOwnProperty.call(obj, item)) {
+              defaultArr.push(item);
+              obj[item] = item;
+            }
+          }
+        });
+        currentDate.splice(0) && currentDate.push(...defaultArr);
+        defaultData = [...splitDate(defaultArr[0])];
+      }
+    } else if (type === "week" && Array.isArray(currentDate)) {
+      if (currentDate.length > 0) {
+        const [y, m, d] = splitDate(currentDate[0]);
+        const weekArr = Utils.getWeekDate(y, m, d, firstDayOfWeek);
+        currentDate.splice(0) && currentDate.push(...weekArr);
+        if (propStartDate && Utils.compareDate(currentDate[0], propStartDate)) {
+          currentDate.splice(0, 1, propStartDate);
+        }
+        if (propEndDate && Utils.compareDate(propEndDate, currentDate[1])) {
+          currentDate.splice(1, 1, propEndDate);
+        }
+        defaultData = [
+          ...splitDate(currentDate[0]),
+          ...splitDate(currentDate[1])
+        ];
+      }
+    } else if (currentDate) {
+      if (currentDate.length > 0) {
+        if (propStartDate && Utils.compareDate(currentDate, propStartDate)) {
+          defaultData = [...splitDate(propStartDate)];
+        } else if (propEndDate && !Utils.compareDate(currentDate, propEndDate)) {
+          defaultData = [...splitDate(propEndDate)];
+        } else {
+          defaultData = [...splitDate(currentDate)];
+        }
+      } else {
+        defaultData = [];
+      }
+    }
+    return defaultData;
+  };
+  const getCurrentIndex = (defaultData) => {
+    let current = 0;
+    let lastCurrent = 0;
+    if (defaultData.length > 0) {
+      monthsData.forEach((item, index) => {
+        if (item.title === monthTitle(defaultData[0], defaultData[1])) {
+          current = index;
+        }
+        if (type === "range" || type === "week") {
+          if (item.title === monthTitle(defaultData[3], defaultData[4])) {
+            lastCurrent = index;
+          }
+        }
+      });
+    } else {
+      const date = /* @__PURE__ */ new Date();
+      const year = date.getFullYear();
+      const month = date.getMonth() + 1;
+      const index = monthsData.findIndex((item) => {
+        return +item.curData[0] === year && +item.curData[1] === month;
+      });
+      if (index > -1) {
+        current = index;
+      }
+    }
+    return {
+      current,
+      lastCurrent
+    };
+  };
+  const renderCurrentDate = () => {
+    const defaultData = setDefaultDate();
+    const current = getCurrentIndex(defaultData);
+    if (defaultData.length > 0) {
+      if (type === "range") {
+        chooseDay({ day: defaultData[2], type: "active" }, monthsData[current.current], true);
+        chooseDay({ day: defaultData[5], type: "active" }, monthsData[current.lastCurrent], true);
+      } else if (props.type === "week") {
+        chooseDay({ day: defaultData[2], type: "curr" }, monthsData[current.current], true);
+      } else if (type === "multiple") {
+        [...currentDate].forEach((item) => {
+          const dateArr = splitDate(item);
+          let currentIndex = current.current;
+          monthsData.forEach((item2, index) => {
+            if (item2.title === monthTitle(dateArr[0], dateArr[1])) {
+              currentIndex = index;
+            }
+          });
+          chooseDay({ day: dateArr[2], type: "active" }, monthsData[currentIndex], true);
+        });
+      } else {
+        chooseDay({ day: defaultData[2], type: "active" }, monthsData[current.current], true);
+      }
+    }
+    return current.current;
+  };
+  const requestAniFrameFunc = (current, monthNum) => {
+    const lastItem = monthsData[monthsData.length - 1];
+    const containerHeight = lastItem.cssHeight + lastItem.scrollTop;
+    requestAniFrame$1(() => {
+      if (monthsRef && monthsPanel && viewAreaRef) {
+        viewHeight = monthsRef.current.clientHeight;
+        monthsPanel.current.style.height = `${containerHeight}px`;
+        monthsRef.current.scrollTop = monthsData[current].scrollTop;
+        setScrollTop(monthsData[current].scrollTop);
+        nextTick(() => setScrollWithAnimation(true));
+      }
+    });
+    setAvgHeight(Math.floor(containerHeight / (monthNum + 1)));
+  };
+  const initData = () => {
+    const monthNum = getMonthNum();
+    getMonthData(startDates, monthNum, "next");
+    const current = renderCurrentDate();
+    setDefaultRange(monthNum, current);
+    requestAniFrameFunc(current, monthNum);
+  };
+  useEffect(() => {
+    initData();
+  }, []);
+  const resetRender = () => {
+    state.currDateArray.splice(0);
+    monthsData.splice(0);
+    initData();
+  };
+  useEffect(() => {
+    setCurrentDate(resetDefaultValue() || []);
+    popup && resetRender();
+  }, [defaultValue]);
+  const scrollToDate = (date) => {
+    if (Utils.compareDate(date, propStartDate)) {
+      date = propStartDate;
+    } else if (!Utils.compareDate(date, propEndDate)) {
+      date = propEndDate;
+    }
+    const dateArr = splitDate(date);
+    monthsData.forEach((item, index) => {
+      if (item.title === monthTitle(dateArr[0], dateArr[1])) {
+        const currTop = monthsData[index].scrollTop;
+        if (monthsRef.current) {
+          const distance = currTop - monthsRef.current.scrollTop;
+          if (scrollAnimation) {
+            let flag = 0;
+            const interval = setInterval(() => {
+              flag++;
+              if (monthsRef.current) {
+                const offset = distance / 10;
+                monthsRef.current.scrollTop += offset;
+              }
+              if (flag >= 10) {
+                clearInterval(interval);
+                if (monthsRef.current) {
+                  monthsRef.current.scrollTop = currTop;
+                  setScrollTop(monthsRef.current.scrollTop);
+                }
+              }
+            }, 40);
+          } else {
+            monthsRef.current.scrollTop = currTop;
+            setScrollTop(monthsRef.current.scrollTop);
+          }
+        }
+      }
+    });
+  };
+  const monthsViewScroll = (e) => {
+    if (monthsData.length <= 1) {
+      return;
+    }
+    const scrollTop2 = e.detail.scrollTop;
+    Taro.getEnv() === "WEB" && setScrollTop(scrollTop2);
+    let current = Math.floor(scrollTop2 / avgHeight);
+    const nextTop = monthsData[current + 1].scrollTop;
+    const nextHeight = monthsData[current + 1].cssHeight;
+    if (current === 0) {
+      if (scrollTop2 >= nextTop) {
+        current += 1;
+      }
+    } else if (current > 0 && current < monthsNum - 1) {
+      if (scrollTop2 >= nextTop) {
+        current += 1;
+      }
+      if (scrollTop2 < monthsData[current].scrollTop) {
+        current -= 1;
+      }
+    } else {
+      const viewPosition = Math.round(scrollTop2 + viewHeight);
+      if (current + 1 <= monthsNum && viewPosition >= nextTop + nextHeight) {
+        current += 1;
+      }
+      if (current >= 1 && scrollTop2 < monthsData[current - 1].scrollTop) {
+        current -= 1;
+      }
+    }
+    setDefaultRange(monthsNum, current);
+  };
+  React.useImperativeHandle(ref, () => ({
+    scrollToDate
+  }));
+  const getClasses = (day, month) => {
+    const dateStr = getCurrDate(day, month);
+    if (day.type === "active") {
+      if (propStartDate && Utils.compareDate(dateStr, propStartDate) || propEndDate && Utils.compareDate(propEndDate, dateStr)) {
+        return `${dayPrefix}-disabled`;
+      }
+      if (type === "range" || type === "week") {
+        if (isStart(dateStr, currentDate) || isEnd(dateStr, currentDate)) {
+          return `${dayPrefix}-active ${isStart(dateStr, currentDate) ? "active-start" : ""} ${isEnd(dateStr, currentDate) ? "active-end" : ""}`;
+        }
+        if (Array.isArray(currentDate) && Object.values(currentDate).length === 2 && Utils.compareDate(currentDate[0], dateStr) && Utils.compareDate(dateStr, currentDate[1])) {
+          return `${dayPrefix}-choose`;
+        }
+        return null;
+      }
+      if (type === "multiple" && isMultiple(dateStr, currentDate) || !Array.isArray(currentDate) && Utils.isEqual(currentDate, dateStr)) {
+        return `${dayPrefix}-active`;
+      }
+      return null;
+    }
+    return `${dayPrefix}-disabled`;
+  };
+  const chooseDay = (day, month, isFirst) => {
+    if (getClasses(day, month) === `${dayPrefix}-disabled`) {
+      return;
+    }
+    const days = [...month.curData];
+    const [y, m] = month.curData;
+    days[2] = typeof day.day === "number" ? Utils.getNumTwoBit(day.day) : day.day;
+    days[3] = `${days[0]}/${days[1]}/${days[2]}`;
+    days[4] = Utils.getWhatDay(+days[0], +days[1], +days[2]);
+    if (type === "multiple") {
+      if (currentDate.length > 0) {
+        let hasIndex = "";
+        currentDate.forEach((item, index) => {
+          if (item === days[3]) {
+            hasIndex = index;
+          }
+        });
+        if (isFirst) {
+          state.currDateArray.push([...days]);
+        } else if (hasIndex !== "") {
+          currentDate.splice(hasIndex, 1);
+          state.currDateArray.splice(hasIndex, 1);
+        } else {
+          currentDate.push(days[3]);
+          state.currDateArray.push([...days]);
+        }
+      } else {
+        currentDate.push(days[3]);
+        state.currDateArray = [[...days]];
+      }
+    } else if (type === "range") {
+      const curDataLength = Object.values(currentDate).length;
+      if (curDataLength === 2 || curDataLength === 0) {
+        Array.isArray(currentDate) && currentDate.splice(0) && currentDate.push(days[3]);
+        state.currDateArray = [[...days]];
+      } else if (Utils.compareDate(currentDate[0], days[3])) {
+        Array.isArray(currentDate) && currentDate.push(days[3]);
+        state.currDateArray = [...state.currDateArray, [...days]];
+      } else {
+        Array.isArray(currentDate) && currentDate.unshift(days[3]);
+        state.currDateArray = [[...days], ...state.currDateArray];
+      }
+    } else if (type === "week") {
+      const weekArr = Utils.getWeekDate(y, m, `${day.day}`, firstDayOfWeek);
+      if (propStartDate && Utils.compareDate(weekArr[0], propStartDate)) {
+        weekArr.splice(0, 1, propStartDate);
+      }
+      if (propEndDate && Utils.compareDate(propEndDate, weekArr[1])) {
+        weekArr.splice(1, 1, propEndDate);
+      }
+      Array.isArray(currentDate) && currentDate.splice(0) && currentDate.push(...weekArr);
+      state.currDateArray = [
+        Utils.formatResultDate(weekArr[0]),
+        Utils.formatResultDate(weekArr[1])
+      ];
+    } else {
+      setCurrentDate(days[3]);
+      state.currDateArray = [...days];
+    }
+    if (!isFirst) {
+      onDayClick && onDayClick(state.currDateArray);
+      if (autoBackfill || !popup) {
+        confirm();
+      }
+    }
+    setMonthsData(monthsData.slice());
+  };
+  const confirm = () => {
+    if (type === "range" && state.currDateArray.length === 2 || type !== "range") {
+      const chooseData = state.currDateArray.slice(0);
+      onConfirm && onConfirm(chooseData);
+      if (popup) {
+        onUpdate && onUpdate();
+      }
+    }
+  };
+  const classes = classNames({
+    [`${classPrefix}-title`]: !popup,
+    [`${classPrefix}-nofooter`]: !!autoBackfill
+  }, classPrefix);
+  const headerClasses = classNames({
+    [`${classPrefix}-header`]: true,
+    [`${classPrefix}-header-title`]: !popup
+  });
+  const isStartTip = (day, month) => {
+    return (type === "range" || type === "week") && day.type === "active" && isStart(getCurrDate(day, month), currentDate);
+  };
+  const isEndTip = (day, month) => {
+    return currentDate.length >= 2 && (type === "range" || type === "week") && day.type === "active" && isEnd(getCurrDate(day, month), currentDate);
+  };
+  const renderHeader = () => {
+    return React.createElement(
+      "div",
+      { className: headerClasses },
+      showTitle && React.createElement("div", { className: `${classPrefix}-title` }, title || locale.calendaritem.title),
+      renderHeaderButtons && React.createElement("div", { className: `${classPrefix}-header-buttons` }, renderHeaderButtons()),
+      showSubTitle && React.createElement("div", { className: `${classPrefix}-sub-title` }, yearMonthTitle),
+      React.createElement("div", { className: `${classPrefix}-weeks`, ref: weeksPanel }, weeks.map((item) => React.createElement("div", { className: `${classPrefix}-week-item`, key: item }, item)))
+    );
+  };
+  const renderContent = () => {
+    return React.createElement(
+      ScrollView,
+      { scrollTop, scrollY: true, type: "list", scrollWithAnimation, className: `${classPrefix}-content`, onScroll: monthsViewScroll, ref: monthsRef },
+      React.createElement(
+        "div",
+        { className: `${classPrefix}-pannel`, ref: monthsPanel },
+        React.createElement("div", { className: "viewArea", ref: viewAreaRef, style: { transform: `translateY(${translateY}px)` } }, monthsData.slice(monthDefaultRange[0], monthDefaultRange[1]).map((month, key) => {
+          return React.createElement(
+            "div",
+            { className: `${classPrefix}-month`, key },
+            React.createElement("div", { className: `${classPrefix}-month-title` }, month.title),
+            React.createElement("div", { className: `${classPrefix}-days` }, month.monthData.map((day, i) => React.createElement(
+              "div",
+              { className: [
+                `${classPrefix}-day`,
+                getClasses(day, month)
+              ].join(" "), onClick: () => {
+                chooseDay(day, month);
+              }, key: i },
+              React.createElement("div", { className: `${classPrefix}-day-day` }, renderDay ? renderDay(day) : day.day),
+              !isStartTip(day, month) && renderDayTop && React.createElement("div", { className: `${classPrefix}-day-info-top` }, renderDayTop(day)),
+              !isStartTip(day, month) && !isEndTip(day, month) && renderDayBottom && React.createElement("div", { className: `${classPrefix}-day-info-bottom` }, renderDayBottom(day)),
+              !isStartTip(day, month) && !isEndTip(day, month) && !renderDayBottom && showToday && isCurrDay(month, day.day) && React.createElement("div", { className: `${classPrefix}-day-info-curr` }, locale.calendaritem.today),
+              isStartTip(day, month) && React.createElement("div", { className: `${classPrefix}-day-info ${isStartAndEnd(currentDate) ? `${classPrefix}-day-info-top` : ""}` }, startText || locale.calendaritem.start),
+              isEndTip(day, month) && React.createElement("div", { className: `${classPrefix}-day-info` }, endText || locale.calendaritem.end)
+            )))
+          );
+        }))
+      )
+    );
+  };
+  const renderFooter = () => {
+    return React.createElement(
+      "div",
+      { className: "nut-calendar-footer" },
+      React.createElement("div", { className: "calendar-confirm-btn", onClick: confirm }, confirmText || locale.confirm)
+    );
+  };
+  return React.createElement(
+    React.Fragment,
+    null,
+    React.createElement(
+      "div",
+      { className: classes },
+      renderHeader(),
+      renderContent(),
+      popup && !autoBackfill ? renderFooter() : ""
+    )
+  );
+});
+CalendarItem.defaultProps = defaultProps;
+CalendarItem.displayName = "NutCalendarItem";
+export {
+  CalendarItem as C,
+  Utils as U
+};