vft 0.0.374 → 0.0.375

package/es/components/countdown/utils.js

@@ -1,5 +1,5 @@
-import { isNumber as g } from "@vft/utils";
-const i = [
+import { isNumber } from "@vft/utils";
+const timeUnits = [
   ["Y", 1e3 * 60 * 60 * 24 * 365],
   // years
   ["M", 1e3 * 60 * 60 * 24 * 30],
@@ -14,22 +14,28 @@ const i = [
   // seconds
   ["S", 1]
   // million seconds
-], x = (e) => g(e) ? new Date(e).getTime() : e.valueOf(), T = (e, s) => {
-  let r = e;
-  const a = /\[([^\]]*)]/g;
-  return i.reduce((t, [m, n]) => {
-    const o = new RegExp(`${m}+(?![^\\[\\]]*\\])`, "g");
-    if (o.test(t)) {
-      const c = Math.floor(r / n);
-      return r -= c * n, t.replace(
-        o,
-        (p) => String(c).padStart(p.length, "0")
+];
+const getTime = (value) => {
+  return isNumber(value) ? new Date(value).getTime() : value.valueOf();
+};
+const formatTime = (timestamp, format) => {
+  let timeLeft = timestamp;
+  const escapeRegex = /\[([^\]]*)]/g;
+  const replacedText = timeUnits.reduce((current, [name, unit]) => {
+    const replaceRegex = new RegExp(`${name}+(?![^\\[\\]]*\\])`, "g");
+    if (replaceRegex.test(current)) {
+      const value = Math.floor(timeLeft / unit);
+      timeLeft -= value * unit;
+      return current.replace(
+        replaceRegex,
+        (match) => String(value).padStart(match.length, "0")
       );
     }
-    return t;
-  }, s).replace(a, "$1");
+    return current;
+  }, format);
+  return replacedText.replace(escapeRegex, "$1");
 };
 export {
-  T as formatTime,
-  x as getTime
+  formatTime,
+  getTime
 };

package/es/components/date-picker/composables/use-basic-date-table.js

@@ -1,182 +1,344 @@
-import { ref as k, computed as m, unref as r, watch as Y, nextTick as Z } from "vue";
-import P from "dayjs";
-import { flatten as p, isArray as ee } from "lodash-es";
+import { ref, computed, unref, watch, nextTick } from "vue";
+import dayjs from "dayjs";
+import { flatten, isArray } from "lodash-es";
 import "@vueuse/core";
 import "@vft/utils";
-import { castArray as x } from "../../../utils/helper.js";
-import { useNamespace as te } from "../../../hooks/use-namespace/index.js";
+import { castArray } from "../../../utils/helper.js";
+import { useNamespace } from "../../../hooks/use-namespace/index.js";
 import "../../../hooks/use-model-toggle/index.js";
 import "@popperjs/core";
 import "../../../hooks/use-z-index/index.js";
-import { buildPickerTable as ae } from "../utils.js";
-const N = (a = "") => ["normal", "today"].includes(a), he = (a, f) => {
-  const D = k("zh-cn"), y = k(), b = k(), g = k(), w = k(), C = k([[], [], [], [], [], []]);
-  let o = !1;
-  const c = a.date.$locale().weekStart || 7, S = a.date.locale("zh-cn").localeData().weekdaysShort().map((e) => e.toLowerCase()), O = m(() => c > 3 ? 7 - c : -c), v = m(() => {
-    const e = a.date.startOf("month");
-    return e.subtract(e.day() || 7, "day");
-  }), j = m(() => S.concat(S).slice(
-    c,
-    c + 7
-  )), R = m(() => p(r(M)).some((e) => e.isCurrent)), A = m(() => {
-    const e = a.date.startOf("month"), t = e.day() || 7, n = e.daysInMonth(), s = e.subtract(1, "month").daysInMonth();
+import { buildPickerTable } from "../utils.js";
+const isNormalDay = (type = "") => {
+  return ["normal", "today"].includes(type);
+};
+const useBasicDateTable = (props, emit) => {
+  const lang = ref("zh-cn");
+  const tbodyRef = ref();
+  const currentCellRef = ref();
+  const lastRow = ref();
+  const lastColumn = ref();
+  const tableRows = ref([[], [], [], [], [], []]);
+  let focusWithClick = false;
+  const firstDayOfWeek = props.date.$locale().weekStart || 7;
+  const WEEKS_CONSTANT = props.date.locale("zh-cn").localeData().weekdaysShort().map((_) => _.toLowerCase());
+  const offsetDay = computed(() => {
+    return firstDayOfWeek > 3 ? 7 - firstDayOfWeek : -firstDayOfWeek;
+  });
+  const startDate = computed(() => {
+    const startDayOfMonth = props.date.startOf("month");
+    return startDayOfMonth.subtract(startDayOfMonth.day() || 7, "day");
+  });
+  const WEEKS = computed(() => {
+    return WEEKS_CONSTANT.concat(WEEKS_CONSTANT).slice(
+      firstDayOfWeek,
+      firstDayOfWeek + 7
+    );
+  });
+  const hasCurrent = computed(() => {
+    return flatten(unref(rows)).some((row) => {
+      return row.isCurrent;
+    });
+  });
+  const days = computed(() => {
+    const startOfMonth = props.date.startOf("month");
+    const startOfMonthDay = startOfMonth.day() || 7;
+    const dateCountOfMonth = startOfMonth.daysInMonth();
+    const dateCountOfLastMonth = startOfMonth.subtract(1, "month").daysInMonth();
     return {
-      startOfMonthDay: t,
-      dateCountOfMonth: n,
-      dateCountOfLastMonth: s
+      startOfMonthDay,
+      dateCountOfMonth,
+      dateCountOfLastMonth
     };
-  }), K = m(() => a.selectionMode === "dates" ? x(a.parsedValue) : []), L = (e, { count: t, rowIndex: n, columnIndex: s }) => {
-    const { startOfMonthDay: l, dateCountOfMonth: i, dateCountOfLastMonth: u } = r(A), h = r(O);
-    if (n >= 0 && n <= 1) {
-      const d = l + h < 0 ? 7 + l + h : l + h;
-      if (s + n * 7 >= d)
-        return e.text = t, !0;
-      e.text = u - (d - s % 7) + 1 + n * 7, e.type = "prev-month";
-    } else
-      return t <= i ? e.text = t : (e.text = t - i, e.type = "next-month"), !0;
-    return !1;
-  }, F = (e, { columnIndex: t, rowIndex: n }, s) => {
-    const { disabledDate: l, cellClassName: i } = a, u = r(K), h = L(e, { count: s, rowIndex: n, columnIndex: t }), d = e.dayjs.toDate();
-    return e.selected = u.find((X) => X.isSame(e.dayjs, "day")), e.isSelected = !!e.selected, e.isCurrent = W(e), e.disabled = l?.(d), e.customClass = i?.(d), h;
-  }, _ = (e) => {
-    if (a.selectionMode === "week") {
-      const [t, n] = a.showWeekNumber ? [1, 7] : [0, 6], s = I(e[t + 1]);
-      e[t].inRange = s, e[t].start = s, e[n].inRange = s, e[n].end = s;
-    }
-  }, M = m(() => {
-    const { minDate: e, maxDate: t, rangeState: n, showWeekNumber: s } = a, l = r(O), i = r(C), u = "day";
-    let h = 1;
-    if (ae({ row: 6, column: 7 }, i, {
-      startDate: e,
-      columnIndexOffset: s ? 1 : 0,
-      nextEndDate: n.endDate || t || n.selecting && e || null,
-      now: P().locale(r(D)).startOf(u),
-      unit: u,
-      relativeDateGetter: (d) => r(v).add(d - l, u),
-      setCellMetadata: (...d) => {
-        F(...d, h) && (h += 1);
+  });
+  const selectedDate = computed(() => {
+    return props.selectionMode === "dates" ? castArray(props.parsedValue) : [];
+  });
+  const setDateText = (cell, { count, rowIndex, columnIndex }) => {
+    const { startOfMonthDay, dateCountOfMonth, dateCountOfLastMonth } = unref(days);
+    const offset = unref(offsetDay);
+    if (rowIndex >= 0 && rowIndex <= 1) {
+      const numberOfDaysFromPreviousMonth = startOfMonthDay + offset < 0 ? 7 + startOfMonthDay + offset : startOfMonthDay + offset;
+      if (columnIndex + rowIndex * 7 >= numberOfDaysFromPreviousMonth) {
+        cell.text = count;
+        return true;
+      } else {
+        cell.text = dateCountOfLastMonth - (numberOfDaysFromPreviousMonth - columnIndex % 7) + 1 + rowIndex * 7;
+        cell.type = "prev-month";
+      }
+    } else {
+      if (count <= dateCountOfMonth) {
+        cell.text = count;
+      } else {
+        cell.text = count - dateCountOfMonth;
+        cell.type = "next-month";
+      }
+      return true;
+    }
+    return false;
+  };
+  const setCellMetadata = (cell, { columnIndex, rowIndex }, count) => {
+    const { disabledDate, cellClassName } = props;
+    const _selectedDate = unref(selectedDate);
+    const shouldIncrement = setDateText(cell, { count, rowIndex, columnIndex });
+    const cellDate = cell.dayjs.toDate();
+    cell.selected = _selectedDate.find((d) => d.isSame(cell.dayjs, "day"));
+    cell.isSelected = !!cell.selected;
+    cell.isCurrent = isCurrent(cell);
+    cell.disabled = disabledDate?.(cellDate);
+    cell.customClass = cellClassName?.(cellDate);
+    return shouldIncrement;
+  };
+  const setRowMetadata = (row) => {
+    if (props.selectionMode === "week") {
+      const [start, end] = props.showWeekNumber ? [1, 7] : [0, 6];
+      const isActive = isWeekActive(row[start + 1]);
+      row[start].inRange = isActive;
+      row[start].start = isActive;
+      row[end].inRange = isActive;
+      row[end].end = isActive;
+    }
+  };
+  const rows = computed(() => {
+    const { minDate, maxDate, rangeState, showWeekNumber } = props;
+    const offset = unref(offsetDay);
+    const rows_ = unref(tableRows);
+    const dateUnit = "day";
+    let count = 1;
+    buildPickerTable({ row: 6, column: 7 }, rows_, {
+      startDate: minDate,
+      columnIndexOffset: showWeekNumber ? 1 : 0,
+      nextEndDate: rangeState.endDate || maxDate || rangeState.selecting && minDate || null,
+      now: dayjs().locale(unref(lang)).startOf(dateUnit),
+      unit: dateUnit,
+      relativeDateGetter: (idx) => unref(startDate).add(idx - offset, dateUnit),
+      setCellMetadata: (...args) => {
+        if (setCellMetadata(...args, count)) {
+          count += 1;
+        }
       },
-      setRowMetadata: _
-    }), s)
-      for (let d = 0; d < 6; d++)
-        i[d][1].dayjs && (i[d][0] = {
-          type: "week",
-          text: i[d][1].dayjs.week()
-        });
-    return i;
+      setRowMetadata
+    });
+    if (showWeekNumber) {
+      for (let rowIndex = 0; rowIndex < 6; rowIndex++) {
+        if (rows_[rowIndex][1].dayjs) {
+          rows_[rowIndex][0] = {
+            type: "week",
+            text: rows_[rowIndex][1].dayjs.week()
+          };
+        }
+      }
+    }
+    return rows_;
   });
-  Y(
-    () => a.date,
+  watch(
+    () => props.date,
     async () => {
-      r(y)?.contains(document.activeElement) && (await Z(), await V());
+      if (unref(tbodyRef)?.contains(document.activeElement)) {
+        await nextTick();
+        await focus();
+      }
     }
   );
-  const V = async () => r(b)?.focus(), W = (e) => a.selectionMode === "date" && N(e.type) && $(e, a.parsedValue), $ = (e, t) => t ? P(t).locale(r(D)).isSame(a.date.date(Number(e.text)), "day") : !1, T = (e, t) => {
-    const n = e * 7 + (t - (a.showWeekNumber ? 1 : 0)) - r(O);
-    return r(v).add(n, "day");
-  }, z = (e) => {
-    if (!a.rangeState.selecting) return;
-    let t = e.target;
-    if (t.tagName === "SPAN" && (t = t.parentNode?.parentNode), t.tagName === "DIV" && (t = t.parentNode), t.tagName !== "TD") return;
-    const n = t.parentNode.rowIndex - 1, s = t.cellIndex;
-    r(M)[n][s].disabled || (n !== r(g) || s !== r(w)) && (g.value = n, w.value = s, f("changerange", {
-      selecting: !0,
-      endDate: T(n, s)
-    }));
-  }, B = (e) => !r(R) && e?.text === 1 && e.type === "normal" || e.isCurrent, U = (e) => {
-    o || r(R) || a.selectionMode !== "date" || E(e, !0);
-  }, G = (e) => {
-    e.target.closest("td") && (o = !0);
-  }, H = (e) => {
-    e.target.closest("td") && (o = !1);
-  }, q = (e) => {
-    !a.rangeState.selecting || !a.minDate ? (f("pick", { minDate: e, maxDate: null }), f("select", !0)) : (e >= a.minDate ? f("pick", { minDate: a.minDate, maxDate: e }) : f("pick", { minDate: e, maxDate: a.minDate }), f("select", !1));
-  }, J = (e) => {
-    const t = e.week(), n = `${e.year()}w${t}`;
-    f("pick", {
-      year: e.year(),
-      week: t,
-      value: n,
-      date: e.startOf("week")
+  const focus = async () => unref(currentCellRef)?.focus();
+  const isCurrent = (cell) => {
+    return props.selectionMode === "date" && isNormalDay(cell.type) && cellMatchesDate(cell, props.parsedValue);
+  };
+  const cellMatchesDate = (cell, date) => {
+    if (!date) return false;
+    return dayjs(date).locale(unref(lang)).isSame(props.date.date(Number(cell.text)), "day");
+  };
+  const getDateOfCell = (row, column) => {
+    const offsetFromStart = row * 7 + (column - (props.showWeekNumber ? 1 : 0)) - unref(offsetDay);
+    return unref(startDate).add(offsetFromStart, "day");
+  };
+  const handleMouseMove = (event) => {
+    if (!props.rangeState.selecting) return;
+    let target = event.target;
+    if (target.tagName === "SPAN") {
+      target = target.parentNode?.parentNode;
+    }
+    if (target.tagName === "DIV") {
+      target = target.parentNode;
+    }
+    if (target.tagName !== "TD") return;
+    const row = target.parentNode.rowIndex - 1;
+    const column = target.cellIndex;
+    if (unref(rows)[row][column].disabled) return;
+    if (row !== unref(lastRow) || column !== unref(lastColumn)) {
+      lastRow.value = row;
+      lastColumn.value = column;
+      emit("changerange", {
+        selecting: true,
+        endDate: getDateOfCell(row, column)
+      });
+    }
+  };
+  const isSelectedCell = (cell) => {
+    return !unref(hasCurrent) && cell?.text === 1 && cell.type === "normal" || cell.isCurrent;
+  };
+  const handleFocus = (event) => {
+    if (focusWithClick || unref(hasCurrent) || props.selectionMode !== "date")
+      return;
+    handlePickDate(event, true);
+  };
+  const handleMouseDown = (event) => {
+    const target = event.target.closest("td");
+    if (!target) return;
+    focusWithClick = true;
+  };
+  const handleMouseUp = (event) => {
+    const target = event.target.closest("td");
+    if (!target) return;
+    focusWithClick = false;
+  };
+  const handleRangePick = (newDate) => {
+    if (!props.rangeState.selecting || !props.minDate) {
+      emit("pick", { minDate: newDate, maxDate: null });
+      emit("select", true);
+    } else {
+      if (newDate >= props.minDate) {
+        emit("pick", { minDate: props.minDate, maxDate: newDate });
+      } else {
+        emit("pick", { minDate: newDate, maxDate: props.minDate });
+      }
+      emit("select", false);
+    }
+  };
+  const handleWeekPick = (newDate) => {
+    const weekNumber = newDate.week();
+    const value = `${newDate.year()}w${weekNumber}`;
+    emit("pick", {
+      year: newDate.year(),
+      week: weekNumber,
+      value,
+      date: newDate.startOf("week")
     });
-  }, Q = (e, t) => {
-    const n = t ? x(a.parsedValue).filter(
-      (s) => s?.valueOf() !== e.valueOf()
-    ) : x(a.parsedValue).concat([e]);
-    f("pick", n);
-  }, E = (e, t = !1) => {
-    const n = e.target.closest("td");
-    if (!n) return;
-    const s = n.parentNode.rowIndex - 1, l = n.cellIndex, i = r(M)[s][l];
-    if (i.disabled || i.type === "week") return;
-    const u = T(s, l);
-    switch (a.selectionMode) {
+  };
+  const handleDatesPick = (newDate, selected) => {
+    const newValue = selected ? castArray(props.parsedValue).filter(
+      (d) => d?.valueOf() !== newDate.valueOf()
+    ) : castArray(props.parsedValue).concat([newDate]);
+    emit("pick", newValue);
+  };
+  const handlePickDate = (event, isKeyboardMovement = false) => {
+    const target = event.target.closest("td");
+    if (!target) return;
+    const row = target.parentNode.rowIndex - 1;
+    const column = target.cellIndex;
+    const cell = unref(rows)[row][column];
+    if (cell.disabled || cell.type === "week") return;
+    const newDate = getDateOfCell(row, column);
+    switch (props.selectionMode) {
       case "range": {
-        q(u);
+        handleRangePick(newDate);
         break;
       }
       case "date": {
-        f("pick", u, t);
+        emit("pick", newDate, isKeyboardMovement);
         break;
       }
       case "week": {
-        J(u);
+        handleWeekPick(newDate);
         break;
       }
       case "dates": {
-        Q(u, !!i.selected);
+        handleDatesPick(newDate, !!cell.selected);
         break;
       }
     }
-  }, I = (e) => {
-    if (a.selectionMode !== "week") return !1;
-    let t = a.date.startOf("day");
-    if (e.type === "prev-month" && (t = t.subtract(1, "month")), e.type === "next-month" && (t = t.add(1, "month")), t = t.date(Number.parseInt(e.text, 10)), a.parsedValue && !ee(a.parsedValue)) {
-      const n = (a.parsedValue.day() - c + 7) % 7 - 1;
-      return a.parsedValue.subtract(n, "day").isSame(t, "day");
+  };
+  const isWeekActive = (cell) => {
+    if (props.selectionMode !== "week") return false;
+    let newDate = props.date.startOf("day");
+    if (cell.type === "prev-month") {
+      newDate = newDate.subtract(1, "month");
+    }
+    if (cell.type === "next-month") {
+      newDate = newDate.add(1, "month");
+    }
+    newDate = newDate.date(Number.parseInt(cell.text, 10));
+    if (props.parsedValue && !isArray(props.parsedValue)) {
+      const dayOffset = (props.parsedValue.day() - firstDayOfWeek + 7) % 7 - 1;
+      const weekDate = props.parsedValue.subtract(dayOffset, "day");
+      return weekDate.isSame(newDate, "day");
     }
-    return !1;
+    return false;
   };
   return {
-    WEEKS: j,
-    rows: M,
-    tbodyRef: y,
-    currentCellRef: b,
+    WEEKS,
+    rows,
+    tbodyRef,
+    currentCellRef,
     // cellMatchesDate,
     // getDateOfCell,
-    focus: V,
-    isCurrent: W,
-    isWeekActive: I,
-    isSelectedCell: B,
-    handlePickDate: E,
-    handleMouseUp: H,
-    handleMouseDown: G,
-    handleMouseMove: z,
-    handleFocus: U
-  };
-}, ye = (a, {
-  isCurrent: f,
-  isWeekActive: D
+    focus,
+    isCurrent,
+    isWeekActive,
+    isSelectedCell,
+    handlePickDate,
+    handleMouseUp,
+    handleMouseDown,
+    handleMouseMove,
+    handleFocus
+  };
+};
+const useBasicDateTableDOM = (props, {
+  isCurrent,
+  isWeekActive
 }) => {
-  const y = te("date-table"), b = m(() => [
-    y.b(),
-    { "is-week-mode": a.selectionMode === "week" }
-  ]), g = m(() => "使用方向键与 Enter 键可选择日期"), w = (o) => {
-    const c = [];
-    return N(o.type) && !o.disabled ? (c.push("available"), o.type === "today" && c.push("today")) : c.push(o.type), f(o) && c.push("current"), o.inRange && (N(o.type) || a.selectionMode === "week") && (c.push("in-range"), o.start && c.push("start-date"), o.end && c.push("end-date")), o.disabled && c.push("disabled"), o.selected && c.push("selected"), o.customClass && c.push(o.customClass), c.join(" ");
-  }, C = (o) => [
-    y.e("row"),
-    { current: D(o) }
+  const ns = useNamespace("date-table");
+  const tableKls = computed(() => [
+    ns.b(),
+    { "is-week-mode": props.selectionMode === "week" }
+  ]);
+  const tableLabel = computed(() => "使用方向键与 Enter 键可选择日期");
+  const getCellClasses = (cell) => {
+    const classes = [];
+    if (isNormalDay(cell.type) && !cell.disabled) {
+      classes.push("available");
+      if (cell.type === "today") {
+        classes.push("today");
+      }
+    } else {
+      classes.push(cell.type);
+    }
+    if (isCurrent(cell)) {
+      classes.push("current");
+    }
+    if (cell.inRange && (isNormalDay(cell.type) || props.selectionMode === "week")) {
+      classes.push("in-range");
+      if (cell.start) {
+        classes.push("start-date");
+      }
+      if (cell.end) {
+        classes.push("end-date");
+      }
+    }
+    if (cell.disabled) {
+      classes.push("disabled");
+    }
+    if (cell.selected) {
+      classes.push("selected");
+    }
+    if (cell.customClass) {
+      classes.push(cell.customClass);
+    }
+    return classes.join(" ");
+  };
+  const getRowKls = (cell) => [
+    ns.e("row"),
+    { current: isWeekActive(cell) }
   ];
   return {
-    tableKls: b,
-    tableLabel: g,
-    weekHeaderClass: y.e("week-header"),
-    getCellClasses: w,
-    getRowKls: C
+    tableKls,
+    tableLabel,
+    weekHeaderClass: ns.e("week-header"),
+    getCellClasses,
+    getRowKls
   };
 };
 export {
-  he as useBasicDateTable,
-  ye as useBasicDateTableDOM
+  useBasicDateTable,
+  useBasicDateTableDOM
 };

package/es/components/date-picker/composables/use-month-range-header.js

@@ -1,29 +1,50 @@
-import { computed as a } from "vue";
-const b = ({
-  unlinkPanels: u,
-  leftDate: e,
-  rightDate: r
+import { computed } from "vue";
+const useMonthRangeHeader = ({
+  unlinkPanels,
+  leftDate,
+  rightDate
 }) => {
-  const v = () => {
-    e.value = e.value.subtract(1, "year"), u.value || (r.value = r.value.subtract(1, "year"));
-  }, l = () => {
-    u.value || (e.value = e.value.add(1, "year")), r.value = r.value.add(1, "year");
-  }, o = () => {
-    e.value = e.value.add(1, "year");
-  }, c = () => {
-    r.value = r.value.subtract(1, "year");
-  }, n = a(() => `${e.value.year()} 年`), y = a(() => `${r.value.year()} 年`), s = a(() => e.value.year()), d = a(() => r.value.year() === e.value.year() ? e.value.year() + 1 : r.value.year());
+  const leftPrevYear = () => {
+    leftDate.value = leftDate.value.subtract(1, "year");
+    if (!unlinkPanels.value) {
+      rightDate.value = rightDate.value.subtract(1, "year");
+    }
+  };
+  const rightNextYear = () => {
+    if (!unlinkPanels.value) {
+      leftDate.value = leftDate.value.add(1, "year");
+    }
+    rightDate.value = rightDate.value.add(1, "year");
+  };
+  const leftNextYear = () => {
+    leftDate.value = leftDate.value.add(1, "year");
+  };
+  const rightPrevYear = () => {
+    rightDate.value = rightDate.value.subtract(1, "year");
+  };
+  const leftLabel = computed(() => {
+    return `${leftDate.value.year()} 年`;
+  });
+  const rightLabel = computed(() => {
+    return `${rightDate.value.year()} 年`;
+  });
+  const leftYear = computed(() => {
+    return leftDate.value.year();
+  });
+  const rightYear = computed(() => {
+    return rightDate.value.year() === leftDate.value.year() ? leftDate.value.year() + 1 : rightDate.value.year();
+  });
   return {
-    leftPrevYear: v,
-    rightNextYear: l,
-    leftNextYear: o,
-    rightPrevYear: c,
-    leftLabel: n,
-    rightLabel: y,
-    leftYear: s,
-    rightYear: d
+    leftPrevYear,
+    rightNextYear,
+    leftNextYear,
+    rightPrevYear,
+    leftLabel,
+    rightLabel,
+    leftYear,
+    rightYear
   };
 };
 export {
-  b as useMonthRangeHeader
+  useMonthRangeHeader
 };