@opentiny/vue-renderless 3.11.8 → 3.12.0

package/anchor/index.js

@@ -33,6 +33,7 @@ const updateSkidPosition = ({ vm, state, emit }) => {
   if (!activeEl) {
     return;
   }
+  emit("change", currentLink);
   emit("onChange", currentLink);
   if (!anchorRef || !skidRef || !maskRef) {
     return;
@@ -92,7 +93,7 @@ const setChildOffsetTop = ({ state, props }) => {
   var _a;
   state.offsetTop = ((_a = document.querySelector(props.links[0].link)) == null ? void 0 : _a.offsetTop) || 0;
 };
-const getContainer = ({ props }) => () => props.containerId ? document.querySelector(props.containerId) : document.body;
+const getContainer = ({ props }) => () => props.containerId && document.querySelector(props.containerId) || document.body;
 const mounted = ({ state, api, props, nextTick }) => () => {
   nextTick(() => {
     api.setScrollContainer();
@@ -113,7 +114,7 @@ const unmounted = ({ state, api }) => () => {
     state.scrollContainer.removeEventListener("scroll", api.handleScroll());
   }
 };
-const onItersectionObserver = ({ state, props, api }) => () => {
+const onItersectionObserver = ({ state, props, api, vm, emit }) => () => {
   const { expandLink, scrollContainer } = state;
   state.intersectionObserver = new IntersectionObserver(
     (entries) => {
@@ -123,6 +124,12 @@ const onItersectionObserver = ({ state, props, api }) => () => {
         const key = item.target.id;
         state.observerLinks[key] = item;
       });
+      if (state.currentHash !== location.hash) {
+        state.currentHash = location.hash;
+        state.currentLink = state.currentHash;
+        updateSkidPosition({ vm, state, emit });
+        return;
+      }
       for (let key in state.observerLinks) {
         if (Object.prototype.hasOwnProperty.call(state.observerLinks, key)) {
           const item = state.observerLinks[key];
@@ -152,12 +159,12 @@ const linkClick = ({ state, vm, emit, props, api }) => (e, item) => {
   state.currentLink = link;
   updateSkidPosition({ vm, state, emit });
   setMarkClass({ state, props });
-  if (scrollContainer !== document.body && !isChangeHash) {
+  if (scrollContainer && scrollContainer !== document.body && !isChangeHash) {
     const linkEl = scrollContainer.querySelector(item.link);
-    const top = linkEl.offsetTop - scrollContainer.offsetTop;
+    const top = (linkEl == null ? void 0 : linkEl.offsetTop) - scrollContainer.offsetTop;
     const param = { top, left: 0, behavior: "smooth" };
-    scrollContainer.scrollTo(param);
-    scrollContainer.addEventListener("scroll", api.handleScroll());
+    scrollContainer == null ? void 0 : scrollContainer.scrollTo(param);
+    scrollContainer == null ? void 0 : scrollContainer.addEventListener("scroll", api.handleScroll());
   }
 };
 export {

package/anchor/vue.js

@@ -39,7 +39,7 @@ const renderless = (props, { onMounted, onUnmounted, onUpdated, reactive, watch
     unmounted: unmounted({ state, api: api2 }),
     getContainer: getContainer({ props }),
     linkClick: linkClick({ state, vm, emit, props, api: api2 }),
-    onItersectionObserver: onItersectionObserver({ state, props, api: api2 }),
+    onItersectionObserver: onItersectionObserver({ state, props, api: api2, vm, emit }),
     setScrollContainer: setScrollContainer({ state, api: api2 }),
     getCurrentAnchor: getCurrentAnchor({ vm, state, emit }),
     setFixAnchor: setFixAnchor({ vm, props }),

package/breadcrumb/index.js

@@ -1,5 +1,10 @@
 import "../chunk-G2ADBYYC.js";
-const breadcrumbItemSelect = ({ api, emit, state, constants }) => {
+const breadcrumbItemSelect = ({
+  api,
+  emit,
+  state,
+  constants
+}) => {
   state.breadcrumbEmitter.on(constants.EVENT_NAME.breadcrumbItemSelect, (value) => {
     state.currentBreadcrumbItem = value;
     emit("select", value);

package/breadcrumb-item/index.js

@@ -1,5 +1,12 @@
 import "../chunk-G2ADBYYC.js";
-const linkClick = ({ props, refs, router, emit, breadcrumbEmitter, constants }) => (event) => {
+const linkClick = ({
+  props,
+  refs,
+  router,
+  emit,
+  breadcrumbEmitter,
+  constants
+}) => (event) => {
   const { replace, to, option } = props;
   const currentBreadcrumbItem = { link: refs.link, replace, to, event, option };
   breadcrumbEmitter.emit(constants.EVENT_NAME.breadcrumbItemSelect, currentBreadcrumbItem);

package/calendar-bar/index.js

@@ -1,9 +1,9 @@
 import "../chunk-G2ADBYYC.js";
+import { lastMonth, nextMonth } from "../common/calendar/calendar";
+import { getDirection } from "../common/deps/touch";
 const normalConfig = (config, state) => {
-  let { weekFirst, disabled, holiday, workday, mark } = config || {};
-  const minWeekFirst = 0;
-  const maxWeekFirst = state.dayOfWeek - 1;
-  weekFirst = typeof weekFirst === "number" && weekFirst >= minWeekFirst && weekFirst <= maxWeekFirst ? Math.round(weekFirst) : minWeekFirst;
+  let { disabled, holiday, workday, mark } = config || {};
+  const weekFirst = getWeekFirst(state, { config });
   disabled = typeof disabled === "function" ? disabled : () => false;
   holiday = typeof holiday === "function" ? holiday : () => true;
   workday = typeof workday === "function" ? workday : () => true;
@@ -26,7 +26,7 @@ const splitDate = (date) => {
   return { todayFullYear, todayMonth, todayDate, currentFullYear, currentMonth, currentDate };
 };
 const getBuildDay = (args) => (year, month, date) => {
-  const { pad0: pad02, isCurrent, currentFullYear, currentMonth, holiday, workday, mark } = args;
+  const { pad0: pad02, isCurrent, holiday, workday, mark, type } = args;
   const { currentDate, isToday, disabled, dayOfWeek } = args;
   const dateStr = `${year}-${pad02(month)}-${pad02(date)}`;
   const d = new Date(dateStr);
@@ -34,22 +34,21 @@ const getBuildDay = (args) => (year, month, date) => {
   const isSat = d.getDay() === dayOfWeek - 1;
   const isSun = d.getDay() === 0;
   let isWorkday, isHoliday;
-  if (year === currentFullYear && month === currentMonth) {
-    if (isSat || isSun) {
-      isHoliday = holiday(d);
-      isWorkday = !isHoliday;
-    } else {
-      isWorkday = workday(d);
-      isHoliday = !isWorkday;
-    }
+  if (isSat || isSun) {
+    isHoliday = holiday(d);
+    isWorkday = !isHoliday;
+  } else {
+    isWorkday = workday(d);
+    isHoliday = !isWorkday;
   }
   const markMsg = mark(d);
   const marked = !!markMsg;
   const day = { dateStr, marked, markMsg, isWorkday, isHoliday, isSat, isSun, isCurMon };
-  day.isCur = isCurMon && date === currentDate;
+  day.isCur = isCurMon && date === currentDate && type === "cur";
   day.isToday = isToday(year, month, date);
   day.disabled = disabled(d);
   day.dateArr = [year, month, date];
+  day.type = type;
   return day;
 };
 const getPadCalendarDays = ({ calendarDays, buildDay }) => (flag, count, cur) => {
@@ -63,10 +62,29 @@ const getPadCalendarDays = ({ calendarDays, buildDay }) => (flag, count, cur) =>
   });
 };
 const equalArr = (arr1, arr2) => Array.isArray(arr1) && Array.isArray(arr2) && arr1.join(",") === arr2.join(",");
-const setDayRow = ({ calendarDays, state }) => calendarDays.map((day, i) => day.row = Math.floor(i / state.dayOfWeek));
+const setDayRow = ({ calendarDays, state }) => calendarDays.map((day, i) => {
+  day.row = Math.floor(i / state.dayOfWeek);
+  if (day.isCur) {
+    state.activeRow = day.row;
+    state.activeDate = day.dateStr;
+  }
+});
 const pad0 = (str, n = 2) => String(str).padStart(n, "0");
-const getCalendarDays = (state) => (date, config) => {
-  date = normalDate(date);
+const getDate = (state, type, date) => {
+  let resDate = /* @__PURE__ */ new Date();
+  if (type === "last") {
+    const { year, month } = lastMonth(state.currentYear, state.currentMonth);
+    resDate = /* @__PURE__ */ new Date(`${year}-${month}-01`);
+  } else if (type === "next") {
+    const { year, month } = nextMonth(state.currentYear, state.currentMonth);
+    resDate = /* @__PURE__ */ new Date(`${year}-${month}-01`);
+  } else {
+    resDate = normalDate(date);
+  }
+  return resDate;
+};
+const getCalendarDays = (state) => (date, config, type = "cur") => {
+  date = getDate(state, type, date);
   let { weekFirst, disabled, holiday, workday, mark } = normalConfig(config, state);
   const { todayFullYear, todayMonth, todayDate, currentFullYear, currentMonth, currentDate } = splitDate(date);
   const isToday = (year, month, date2) => year === todayFullYear && month === todayMonth && date2 === todayDate;
@@ -76,7 +94,7 @@ const getCalendarDays = (state) => (date, config) => {
   const f = (arr) => arr[0];
   const l = (arr) => arr[arr.length - 1];
   const { dayOfWeek } = state;
-  const args = { pad0, isCurrent, currentFullYear, currentMonth, holiday, workday, mark };
+  const args = { pad0, isCurrent, currentFullYear, currentMonth, holiday, workday, mark, type };
   Object.assign(args, { currentDate, isToday, disabled, dayOfWeek });
   const buildDay = getBuildDay(args);
   const calendarDays = Array.from({ length: monthDays[currentMonth] }).map(
@@ -90,29 +108,107 @@ const getCalendarDays = (state) => (date, config) => {
   padCalendarDays("s", count, new Date(f(calendarDays).dateStr));
   count = monthDaysLast !== l(weekDays) ? dayOfWeek - 1 - weekDays.indexOf(monthDaysLast) : dayOfWeek;
   padCalendarDays("e", count, new Date(l(calendarDays).dateStr));
+  setCalendarDays(state, type, calendarDays);
+  if (type !== "cur")
+    return;
   setDayRow({ calendarDays, state });
   if (!equalArr(state.weekDays, weekDays)) {
     state.weekDays = weekDays;
   }
-  state.calendarDays = calendarDays;
-  state.currentYear = `${currentFullYear}`;
-  state.currentMonth = `${currentMonth}`;
-  state.currentDate = `${currentDate}`;
+  state.currentYear = currentFullYear;
+  state.currentMonth = currentMonth;
+  state.currentDate = currentDate;
   state.cascaderCurrent = [currentFullYear, currentMonth];
 };
-const setStackRows = (state) => {
-  const { calendarDays } = state;
-  if (Array.isArray(calendarDays) && calendarDays.length) {
-    const currentDay = calendarDays.find((day) => day.isCur);
-    const allRows = [...new Set(calendarDays.map((day) => day.row))];
-    const index = allRows.indexOf(currentDay.row);
-    const stackRows = allRows.slice(index + 1).reverse().concat(allRows.slice(0, index));
-    state.stackRows = stackRows;
+const setCalendarDays = (state, type, calendarDays) => {
+  if (type === "last") {
+    state.lastCalendarDays = calendarDays;
+  } else if (type === "next") {
+    state.nextCalendarDays = calendarDays;
+  } else {
+    state.calendarDays = calendarDays;
+  }
+};
+const getPrevWeek = ({ props, emit, state, api }) => () => {
+  let newPrevDate = new Date(state.weekDates[0].dateStr);
+  newPrevDate.setDate(newPrevDate.getDate() - 7);
+  state.weekDates = api.getAllDatesOfCurrWeek(new Date(newPrevDate));
+  setActiveDate(state, props, emit);
+};
+const getNextWeek = ({ props, emit, state, api }) => () => {
+  let newNextDate = new Date(state.weekDates[6].dateStr);
+  newNextDate.setDate(newNextDate.getDate() + 7);
+  state.weekDates = api.getAllDatesOfCurrWeek(new Date(newNextDate));
+  setActiveDate(state, props, emit);
+};
+const setActiveDate = (state, props, emit) => {
+  state.weekDates.forEach((day2) => day2.isCur = false);
+  const day = new Date(props.modelValue).getDay();
+  const dayIdx = state.weekDays.indexOf(day);
+  const curDate = state.weekDates[dayIdx];
+  curDate.isCur = true;
+  emit("update:modelValue", curDate.dateStr);
+  state.activeDate = curDate.dateStr;
+  state.currentDate = curDate.dateArr[2];
+  state.activeRow = curDate.row;
+};
+const getAllDatesOfCurrWeek = ({ state, props }) => (date) => {
+  const weekFirst = getWeekFirst(state, props);
+  const weekDates = [];
+  let weekDate = new Date(date);
+  const calDate = weekDate.getDate() - weekDate.getDay() + weekFirst;
+  const weekFirstDate = calDate > weekDate.getDate() ? calDate - 7 : calDate;
+  weekDate.setDate(weekFirstDate);
+  const threeMonthDays = [...state.calendarDays, ...state.lastCalendarDays, ...state.nextCalendarDays];
+  const len = threeMonthDays.length;
+  for (let i = 0; i < 7; i++) {
+    const date2 = formatDate(new Date(weekDate));
+    let findDate = false;
+    for (let j = 0; j < len; j++) {
+      if (threeMonthDays[j].dateStr === date2) {
+        threeMonthDays[j].type = "cur";
+        weekDates.push(threeMonthDays[j]);
+        findDate = true;
+        break;
+      }
+    }
+    if (!findDate) {
+      const newDate = new Date(weekDate);
+      weekDates.push({ dateStr: date2, dateArr: [newDate.getFullYear(), newDate.getMonth() + 1, newDate.getDate()] });
+    }
+    weekDate.setDate(weekDate.getDate() + 1);
+  }
+  return weekDates;
+};
+const getWeekOfDate = ({ api }) => (type, date) => {
+  const aWeekTimestamp = 7 * 24 * 60 * 60 * 1e3;
+  let nextDate = +new Date(date);
+  if (type === "prev") {
+    nextDate = +new Date(date) - aWeekTimestamp;
+  } else {
+    nextDate = +new Date(date) + aWeekTimestamp;
+  }
+  return api.getAllDatesOfCurrWeek(new Date(nextDate));
+};
+const showWeekChange = ({ state }) => (value) => {
+  if (value) {
+    state.weekDates = state.calendarDays.filter((day) => day.row === state.activeRow);
+  } else {
+    state.calendarDays.forEach((date) => {
+      if (state.activeDate === date.dateStr) {
+        date.isCur = true;
+      } else {
+        date.isCur = false;
+      }
+    });
   }
 };
+const formatDate = (date) => {
+  const newDate = new Date(date);
+  return newDate.getFullYear() + "-" + pad0(newDate.getMonth() + 1) + "-" + pad0(newDate.getDate());
+};
 const computedCurrentRow = (state) => () => {
   const { calendarDays } = state;
-  setStackRows(state);
   if (Array.isArray(calendarDays) && calendarDays.length) {
     const currentDay = calendarDays.find((day) => day.isCur);
     if (currentDay) {
@@ -121,6 +217,13 @@ const computedCurrentRow = (state) => () => {
   }
   return null;
 };
+const computedData = (state) => () => {
+  if (state.showWeek) {
+    return [state.prevWeekDates, state.weekDates, state.nextWeekDates];
+  } else {
+    return [state.lastCalendarDays, state.calendarDays, state.nextCalendarDays];
+  }
+};
 const computedFilteredCalendarDays = (state) => () => {
   const { calendarDays, currentRow, visibleRows } = state;
   if (Array.isArray(calendarDays) && calendarDays.length && currentRow !== null) {
@@ -129,23 +232,27 @@ const computedFilteredCalendarDays = (state) => () => {
   }
   return [];
 };
-const clearVisibleRows = (state) => state.visibleRows = [];
-const fillVisibleRows = (state) => state.visibleRows = [...new Set((state.calendarDays || []).map((day) => day.row))];
-const handleDraggerClick = (state) => () => {
-  const { visibleRows } = state;
+const handleDraggerClick = (state, emit) => () => {
   if (state.dragging)
     return;
-  if (Array.isArray(visibleRows) && visibleRows.length) {
-    clearVisibleRows(state);
-  } else {
-    fillVisibleRows(state);
-  }
+  state.showWeek = !state.showWeek;
+  emit("expand", !state.showWeek);
 };
-const handleClickDay = ({ api, emit, props }) => (day) => {
+const handleClickDay = ({ api, emit, props, state }) => (day) => {
   if (day.isCur || day.disabled)
     return;
   if (typeof day.dateStr === "string") {
-    api.getCalendarDays(day.dateStr, props.config);
+    const isCurrent = day.dateArr[0] === +state.currentYear && day.dateArr[1] === +state.currentMonth;
+    if (!isCurrent) {
+      api.getCalendarDays(day.dateStr, props.config, "cur");
+      api.getCalendarDays(day.dateStr, props.config, "last");
+      api.getCalendarDays(day.dateStr, props.config, "next");
+    }
+    const showCalendarDays = [...state.calendarDays, ...state.weekDates];
+    showCalendarDays.forEach((date) => date.isCur = day.dateStr === date.dateStr);
+    state.activeDate = day.dateStr;
+    state.currentDate = day.dateArr[2];
+    state.activeRow = day.row;
     emit("update:modelValue", day.dateStr);
   }
 };
@@ -158,36 +265,70 @@ const calcCalendarItemHeight = ({ state, vm }) => () => {
   }
 };
 const computedTotalRows = (state) => () => {
+  const len = state.dragging ? state.calendarDaysCopy.length : calendarDays.length;
   const { calendarDays, dayOfWeek } = state;
-  const total = Math.floor(calendarDays.length / dayOfWeek);
+  const total = Math.floor(len / dayOfWeek);
   return total;
 };
-const dragStart = ({ state, vm, clientX, clientY }) => {
-  state.dragPosStart = state.dragPos = { clientX, clientY };
+const dragStart = ({ state, clientX, clientY, vm }) => {
+  state.showRows = 0;
+  state.calendarDaysCopy = state.calendarDays.slice(0);
   state.calendarPanelHeight = vm.$refs.calendarPanel.offsetHeight;
-  state.stackRowsCopy = state.stackRows.slice(0);
+  state.dragPosStart = state.dragPos = { clientX, clientY };
 };
-const dragEnd = ({ state, vm, clientY }) => {
+const dragEnd = ({ state, vm, clientY, emit }) => {
   const dy = clientY - state.dragPosStart.clientY;
+  if (dy === 0)
+    return;
   state.dragPosStart = state.dragPos = {};
-  vm.$refs.calendarPanel.style.height = "auto";
-  if (dy > 0) {
-    fillVisibleRows(state);
-  } else if (dy < 0) {
-    clearVisibleRows(state);
+  if (state.showWeek) {
+    if (state.showRows >= 2) {
+      state.showWeek = false;
+    }
+  } else {
+    if (state.showRows <= 5) {
+      state.showWeek = true;
+    }
   }
+  emit("expand", !state.showWeek);
+  state.weekDates = state.copyWeekDates;
+  state.calendarDays = state.calendarDaysCopy;
+  vm.$refs.calendarPanel.style.height = "auto";
+  state.showRows = 0;
 };
 const dragMove = ({ state, vm, clientX, clientY }) => {
-  const { dragPos: lastPos, itemHeight, totalRows, stackRowsCopy, currentRow } = state;
+  const { dragPos: lastPos, itemHeight } = state;
+  const totalRows = 6;
+  if (lastPos.clientY === void 0 || lastPos.clientX === void 0) {
+    state.dragging = false;
+    return;
+  }
   const minH = itemHeight;
   const maxH = itemHeight * totalRows;
   state.dragPos = { clientX, clientY };
   state.calendarPanelHeight += clientY - lastPos.clientY;
   let h = state.calendarPanelHeight;
   h = h < minH ? minH : h > maxH ? maxH : h;
-  const showRows = Math.floor(h / itemHeight);
+  state.showRows = Math.floor(h / itemHeight);
   vm.$refs.calendarPanel.style.height = `${h}px`;
-  state.visibleRows = stackRowsCopy.slice(0).concat(currentRow).reverse().slice(0, showRows);
+  if (state.showWeek) {
+    if (state.showRows === 1) {
+      state.weekDates = [...state.copyWeekDates];
+    }
+    if (state.showRows === 2) {
+      state.weekDates = [...state.prevWeekDates, ...state.copyWeekDates];
+    }
+    if (state.showRows === 3) {
+      state.weekDates = [...state.prevWeekDates, ...state.copyWeekDates, ...state.nextWeekDates];
+    }
+  } else {
+    getShowedCalendarDays(state);
+  }
+};
+const getShowedCalendarDays = (state) => {
+  if (state.showRows === 0)
+    return;
+  state.calendarDays = state.calendarDaysCopy.slice(0, state.showRows * 7);
 };
 const handleDraggerMousedown = ({ api, state, vm }) => (e) => {
   const { clientX, clientY } = e;
@@ -195,11 +336,11 @@ const handleDraggerMousedown = ({ api, state, vm }) => (e) => {
   document.addEventListener("mouseup", api.handleMouseup);
   document.addEventListener("mousemove", api.throttledHandleMousemove);
 };
-const handleMouseup = ({ api, state, vm }) => (e) => {
+const handleMouseup = ({ api, state, vm, emit }) => (e) => {
   setTimeout(() => state.dragging = false);
   document.removeEventListener("mouseup", api.handleMouseup);
   document.removeEventListener("mousemove", api.throttledHandleMousemove);
-  dragEnd({ state, vm, clientY: e.clientY });
+  dragEnd({ state, vm, clientY: e.clientY, emit });
 };
 const handleMousemove = ({ state, vm }) => (e) => {
   state.dragging = true;
@@ -211,10 +352,10 @@ const handleDraggerTouchstart = ({ state, vm }) => (e) => {
   state.touching = true;
   dragStart({ state, vm, clientX, clientY });
 };
-const handleDraggerTouchend = ({ state, vm }) => (e) => {
+const handleDraggerTouchend = ({ state, vm, emit }) => (e) => {
   const { clientY } = e.changedTouches[0];
   state.touching = false;
-  dragEnd({ state, vm, clientY });
+  dragEnd({ state, vm, clientY, emit });
 };
 const handleDraggerTouchmove = ({ state, vm }) => (e) => {
   const { clientX, clientY } = e.changedTouches[0];
@@ -222,15 +363,12 @@ const handleDraggerTouchmove = ({ state, vm }) => (e) => {
 };
 const setCascaderVisible = (state) => (value) => state.cascaderVisible = !!value;
 const handleCascaderChange = ({ api, emit, props, state }) => (val) => {
-  const { currentDate } = state;
-  let dateStr = `${val[0]}-${pad0(val[1])}-${pad0(currentDate)}`;
-  const numberCurrentDate = Number(currentDate);
-  const { currentFullYear: curYear, currentMonth: curMonth, currentDate: curDate } = splitDate(new Date(dateStr));
-  if (curYear !== val[0] || curMonth !== val[1] || curDate !== numberCurrentDate) {
-    dateStr = `${val[0]}-${pad0(val[1])}-01`;
-  }
-  api.getCalendarDays(dateStr, props.config);
+  const dateStr = getDateStr(state, val[0], val[1]);
+  api.getCalendarDays(dateStr, props.config, "cur");
+  api.getCalendarDays(dateStr, props.config, "last");
+  api.getCalendarDays(dateStr, props.config, "next");
   emit("update:modelValue", dateStr);
+  state.weekDates = state.calendarDays.filter((day) => day.row === state.activeRow);
 };
 const computeCascaderOptions = (t) => () => [
   {
@@ -247,13 +385,97 @@ const i18nYearMonth = ({ state, t }) => () => {
   template = template.replace("%m", monthAbbr);
   return template;
 };
+const touchmove = ({ state }) => (event) => {
+  const touch = event.touches[0];
+  state.deltaPos.Y = touch.clientY - state.startPos.Y;
+  state.deltaPos.X = touch.clientX - state.startPos.X;
+  state.offsetPos.Y = Math.abs(state.deltaPos.Y);
+  state.offsetPos.X = Math.abs(state.deltaPos.X);
+  state.direction = getDirection(state.offsetPos.X, state.offsetPos.Y);
+  if (state.direction === "vertical")
+    return;
+  state.delta = state.deltaPos.X;
+};
+const touchstart = ({ state }) => (event) => {
+  event.stopPropagation();
+  resetTouchStatus(state);
+  state.duration = 300;
+  state.moving = true;
+  state.touchTime = Date.now();
+  state.startPos.X = event.touches[0].clientX;
+  state.startPos.Y = event.touches[0].clientY;
+};
+const touchend = ({ state, api, vm }) => () => {
+  const weekPanel = vm.$refs.weekPanel;
+  const width = weekPanel && weekPanel.offsetWidth;
+  const speed = state.delta / (Date.now() - state.touchTime);
+  const isShouldMove = Math.abs(speed) > 0.3 || Math.abs(state.delta) > +(width / 3).toFixed(2);
+  if (isShouldMove) {
+    const delta = state.delta;
+    state.duration = 300;
+    state.delta = delta > 0 ? width : -width;
+    setTimeout(() => {
+      if (state.showWeek) {
+        delta > 0 ? api.getPrevWeek() : api.getNextWeek();
+        if (state.weekDates[3].dateArr[0] !== +state.currentYear || state.weekDates[3].dateArr[1] !== +state.currentMonth) {
+          api.updateCalendarDays(delta);
+        }
+      } else {
+        api.updateCalendarDays(delta);
+      }
+      state.duration = 0;
+      state.delta = 0;
+    }, 300);
+  } else {
+    state.delta = 0;
+  }
+  state.moving = false;
+};
+const updateCalendarDays = ({ props, state, api, emit }) => (delta) => {
+  let { year, month } = delta > 0 ? lastMonth(state.currentYear, state.currentMonth) : nextMonth(state.currentYear, state.currentMonth);
+  const dateStr = getDateStr(state, year, month);
+  api.getCalendarDays(dateStr, props.config, "cur");
+  api.getCalendarDays(dateStr, props.config, "last");
+  api.getCalendarDays(dateStr, props.config, "next");
+  !state.showWeek && emit("update:modelValue", dateStr);
+};
+function getDateStr(state, year, month) {
+  const { currentDate } = state;
+  let dateStr = `${year}-${pad0(month)}-${pad0(currentDate)}`;
+  const numberCurrentDate = Number(currentDate);
+  const { currentFullYear: curYear, currentMonth: curMonth, currentDate: curDate } = splitDate(new Date(dateStr));
+  if (curYear !== year || curMonth !== month || curDate !== numberCurrentDate) {
+    dateStr = `${year}-${pad0(month)}-01`;
+  }
+  return dateStr;
+}
+function getWeekFirst(state, props) {
+  let weekFirst = props.config.weekFirst || 0;
+  const minWeekFirst = 0;
+  const maxWeekFirst = state.dayOfWeek - 1;
+  weekFirst = typeof weekFirst === "number" && weekFirst >= minWeekFirst && weekFirst <= maxWeekFirst ? Math.round(weekFirst) : minWeekFirst;
+  return weekFirst;
+}
+function resetTouchStatus(state) {
+  state.direction = "";
+  state.delta = 0;
+  state.deltaPos.X = 0;
+  state.deltaPos.Y = 0;
+  state.offsetPos.X = 0;
+  state.offsetPos.Y = 0;
+}
 export {
   calcCalendarItemHeight,
   computeCascaderOptions,
   computedCurrentRow,
+  computedData,
   computedFilteredCalendarDays,
   computedTotalRows,
+  getAllDatesOfCurrWeek,
   getCalendarDays,
+  getNextWeek,
+  getPrevWeek,
+  getWeekOfDate,
   handleCascaderChange,
   handleClickDay,
   handleDraggerClick,
@@ -264,5 +486,10 @@ export {
   handleMousemove,
   handleMouseup,
   i18nYearMonth,
-  setCascaderVisible
+  setCascaderVisible,
+  showWeekChange,
+  touchend,
+  touchmove,
+  touchstart,
+  updateCalendarDays
 };