@zag-js/date-utils 0.0.0-dev-20230107115230 → 0.0.0-dev-20230107153917

package/dist/index.js

@@ -27,11 +27,11 @@ __export(src_exports, {
   alignEnd: () => alignEnd,
   alignStart: () => alignStart,
   alignStartDate: () => alignStartDate,
-  clampDate: () => clampDate,
   constrainStart: () => constrainStart,
   constrainValue: () => constrainValue,
   formatRange: () => formatRange,
   formatSelectedDate: () => formatSelectedDate,
+  formatVisibleRange: () => formatVisibleRange,
   getDatesInWeek: () => getDatesInWeek,
   getEndDate: () => getEndDate,
   getMonthDates: () => getMonthDates,
@@ -39,6 +39,7 @@ __export(src_exports, {
   getNextPage: () => getNextPage,
   getNextRow: () => getNextRow,
   getNextSection: () => getNextSection,
+  getPreviousAvailableDate: () => getPreviousAvailableDate,
   getPreviousDay: () => getPreviousDay,
   getPreviousPage: () => getPreviousPage,
   getPreviousRow: () => getPreviousRow,
@@ -69,8 +70,7 @@ module.exports = __toCommonJS(src_exports);
 
 // src/constrain.ts
 var import_date = require("@internationalized/date");
-function alignCenter(ctx, date) {
-  const { duration } = ctx;
+function alignCenter(date, duration, locale, min, max) {
   let halfDuration = {};
   for (let key in duration) {
     halfDuration[key] = Math.floor(duration[key] / 2);
@@ -78,11 +78,10 @@ function alignCenter(ctx, date) {
       halfDuration[key]--;
     }
   }
-  let aligned = alignStart(ctx, date).subtract(halfDuration);
-  return constrainStart(ctx, date, aligned);
+  let aligned = alignStart(date, duration, locale).subtract(halfDuration);
+  return constrainStart(date, aligned, duration, locale, min, max);
 }
-function alignStart(ctx, date) {
-  let { locale, duration } = ctx;
+function alignStart(date, duration, locale, min, max) {
   let aligned = date;
   if (duration.years) {
     aligned = (0, import_date.startOfYear)(date);
@@ -91,10 +90,9 @@ function alignStart(ctx, date) {
   } else if (duration.weeks) {
     aligned = (0, import_date.startOfWeek)(date, locale);
   }
-  return constrainStart(ctx, date, aligned);
+  return constrainStart(date, aligned, duration, locale, min, max);
 }
-function alignEnd(ctx, date) {
-  const { duration } = ctx;
+function alignEnd(date, duration, locale, min, max) {
   let d = { ...duration };
   if (d.days) {
     d.days--;
@@ -105,86 +103,83 @@ function alignEnd(ctx, date) {
   } else if (d.years) {
     d.years--;
   }
-  let aligned = alignStart(ctx, date).subtract(d);
-  return constrainStart(ctx, date, aligned);
+  let aligned = alignStart(date, duration, locale).subtract(d);
+  return constrainStart(date, aligned, duration, locale, min, max);
 }
-function constrainValue(ctx, date) {
-  let { min, max } = ctx;
-  if (min) {
-    date = (0, import_date.maxDate)(date, (0, import_date.toCalendarDate)(min));
-  }
-  if (max) {
-    date = (0, import_date.minDate)(date, (0, import_date.toCalendarDate)(max));
-  }
-  return date;
-}
-function constrainStart(ctx, date, aligned) {
-  let { min, max } = ctx;
+function constrainStart(date, aligned, duration, locale, min, max) {
   if (min && date.compare(min) >= 0) {
-    aligned = (0, import_date.maxDate)(aligned, alignStart(ctx, (0, import_date.toCalendarDate)(min)));
+    aligned = (0, import_date.maxDate)(aligned, alignStart((0, import_date.toCalendarDate)(min), duration, locale));
   }
   if (max && date.compare(max) <= 0) {
-    aligned = (0, import_date.minDate)(aligned, alignEnd(ctx, (0, import_date.toCalendarDate)(max)));
+    aligned = (0, import_date.minDate)(aligned, alignEnd((0, import_date.toCalendarDate)(max), duration, locale));
   }
   return aligned;
 }
+function constrainValue(date, minValue, maxValue) {
+  if (minValue) {
+    date = (0, import_date.maxDate)(date, (0, import_date.toCalendarDate)(minValue));
+  }
+  if (maxValue) {
+    date = (0, import_date.minDate)(date, (0, import_date.toCalendarDate)(maxValue));
+  }
+  return date;
+}
 
 // src/align.ts
-function alignDate(ctx, date, alignment) {
+function alignDate(date, alignment, duration, locale, min, max) {
   switch (alignment) {
     case "start":
-      return alignStart(ctx, date);
+      return alignStart(date, duration, locale, min, max);
     case "end":
-      return alignEnd(ctx, date);
+      return alignEnd(date, duration, locale, min, max);
     case "center":
     default:
-      return alignCenter(ctx, date);
+      return alignCenter(date, duration, locale, min, max);
   }
 }
-function alignStartDate(ctx, focusedDate, startDate, endDate) {
-  if (focusedDate.compare(startDate) < 0) {
-    return alignEnd(ctx, focusedDate);
+function alignStartDate(date, startDate, endDate, duration, locale, min, max) {
+  if (date.compare(startDate) < 0) {
+    return alignEnd(date, duration, locale, min, max);
   }
-  if (focusedDate.compare(endDate) > 0) {
-    return alignStart(ctx, focusedDate);
+  if (date.compare(endDate) > 0) {
+    return alignStart(date, duration, locale, min, max);
   }
   return startDate;
 }
 
 // src/assertion.ts
 var import_date2 = require("@internationalized/date");
-function isTodayDate(date, timezone) {
-  return (0, import_date2.isToday)(date, timezone);
+function isTodayDate(date, timeZone) {
+  return (0, import_date2.isToday)(date, timeZone);
 }
 function isDateEqual(dateA, dateB) {
   return dateB != null && (0, import_date2.isSameDay)(dateA, dateB);
 }
-function isDateInvalid(ctx, date) {
-  return ctx.min != null && date.compare(ctx.min) < 0 || ctx.max != null && date.compare(ctx.max) > 0;
+function isDateInvalid(date, minValue, maxValue) {
+  return minValue != null && date.compare(minValue) < 0 || maxValue != null && date.compare(maxValue) > 0;
 }
-function isDateDisabled(ctx, date, startDate, endDate) {
-  return date.compare(startDate) < 0 || date.compare(endDate) > 0 || isDateInvalid(ctx, date);
+function isDateDisabled(date, startDate, endDate, minValue, maxValue) {
+  return date.compare(startDate) < 0 || date.compare(endDate) > 0 || isDateInvalid(date, minValue, maxValue);
 }
-function isDateUnavailable(ctx, date) {
-  var _a;
+function isDateUnavailable(date, isUnavailable, minValue, maxValue) {
   if (!date) {
     return false;
   }
-  if ((_a = ctx.isUnavailable) == null ? void 0 : _a.call(ctx, date)) {
+  if (isUnavailable == null ? void 0 : isUnavailable(date)) {
     return true;
   }
-  return isDateInvalid(ctx, date);
+  return isDateInvalid(date, minValue, maxValue);
 }
 function isDateOutsideVisibleRange(date, startDate, endDate) {
   return date.compare(startDate) < 0 || date.compare(endDate) > 0;
 }
-function isPreviousVisibleRangeInvalid(ctx, startDate) {
-  let prev = startDate.subtract({ days: 1 });
-  return (0, import_date2.isSameDay)(prev, startDate) || isDateInvalid(ctx, prev);
+function isPreviousVisibleRangeInvalid(startDate, minValue, maxValue) {
+  const prevDate = startDate.subtract({ days: 1 });
+  return (0, import_date2.isSameDay)(prevDate, startDate) || isDateInvalid(prevDate, minValue, maxValue);
 }
-function isNextVisibleRangeInvalid(ctx, endDate) {
-  let next = endDate.add({ days: 1 });
-  return (0, import_date2.isSameDay)(next, endDate) || isDateInvalid(ctx, next);
+function isNextVisibleRangeInvalid(endDate, minValue, maxValue) {
+  const nextDate = endDate.add({ days: 1 });
+  return (0, import_date2.isSameDay)(nextDate, endDate) || isDateInvalid(nextDate, minValue, maxValue);
 }
 
 // src/duration.ts
@@ -206,8 +201,8 @@ function getEndDate(startDate, duration) {
 }
 
 // src/format-range.ts
-function formatRange(ctx, formatter) {
-  let parts = formatter.formatRangeToParts(ctx.start.toDate(ctx.timeZone), ctx.end.toDate(ctx.timeZone));
+function formatRange(startDate, endDate, formatter, toString, timeZone) {
+  let parts = formatter.formatRangeToParts(startDate.toDate(timeZone), endDate.toDate(timeZone));
   let separatorIndex = -1;
   for (let i = 0; i < parts.length; i++) {
     let part = parts[i];
@@ -226,20 +221,19 @@ function formatRange(ctx, formatter) {
       end += parts[i].value;
     }
   }
-  return ctx.toString(start, end);
+  return toString(start, end);
 }
 
 // src/format-selected-date.ts
 var import_date3 = require("@internationalized/date");
 
-// src/get-era-format.ts
+// src/get-formatter.ts
 function getEraFormat(date) {
   return (date == null ? void 0 : date.calendar.identifier) === "gregory" && date.era === "BC" ? "short" : void 0;
 }
-
-// src/get-formatter.ts
-function getDateFormatter(ctx) {
-  const { start, end = start, getDateFormatter: getDateFormatter2, timeZone } = ctx;
+function getDateFormatter(startDate, endDate, getDateFormatter2, timeZone) {
+  let start = startDate;
+  let end = endDate != null ? endDate : startDate;
   let era = getEraFormat(start) || getEraFormat(end);
   return getDateFormatter2({
     weekday: "long",
@@ -250,34 +244,67 @@ function getDateFormatter(ctx) {
     timeZone
   });
 }
+function getMonthFormatter(startDate, endDate, getDateFormatter2, timeZone) {
+  let start = startDate;
+  let end = endDate != null ? endDate : startDate;
+  let era = getEraFormat(start) || getEraFormat(end);
+  return getDateFormatter2({
+    month: "long",
+    year: "numeric",
+    era,
+    calendar: start == null ? void 0 : start.calendar.identifier,
+    timeZone
+  });
+}
 
 // src/format-selected-date.ts
-function formatSelectedDate(ctx) {
-  const { start, end = start, timeZone } = ctx;
-  let formatter = getDateFormatter(ctx);
-  if (ctx.isSelectingRange || start == null || end == null) {
+function formatSelectedDate(startDate, endDate, getFormatter, isSelectingRange, timeZone) {
+  let start = startDate;
+  let end = endDate != null ? endDate : startDate;
+  let formatter = getDateFormatter(start, end, getFormatter, timeZone);
+  if (isSelectingRange || start == null || end == null) {
     return "";
   }
   if ((0, import_date3.isSameDay)(start, end)) {
     return formatter.format(start.toDate(timeZone));
   }
-  return formatRange(ctx, formatter);
+  return formatRange(start, end, formatter, (start2, end2) => `${start2} \u2013 ${end2}`, timeZone);
 }
 
-// src/get-week-dates.ts
+// src/format-visible-range.ts
 var import_date4 = require("@internationalized/date");
+function formatVisibleRange(startDate, endDate, getFormatter, isAria, timeZone) {
+  if (!startDate)
+    return "";
+  let start = startDate;
+  let end = endDate != null ? endDate : startDate;
+  let monthFormatter = getMonthFormatter(start, end, getFormatter, timeZone);
+  let dateFormatter = getDateFormatter(start, end, getFormatter, timeZone);
+  if (!(0, import_date4.isSameDay)(start, (0, import_date4.startOfMonth)(start))) {
+    return isAria ? formatRange(start, end, dateFormatter, (start2, end2) => `${start2} \u2013 ${end2}`, timeZone) : dateFormatter.formatRange(start.toDate(timeZone), end.toDate(timeZone));
+  }
+  if ((0, import_date4.isSameDay)(end, (0, import_date4.endOfMonth)(start))) {
+    return monthFormatter.format(start.toDate(timeZone));
+  }
+  if ((0, import_date4.isSameDay)(end, (0, import_date4.endOfMonth)(end))) {
+    return isAria ? formatRange(start, end, monthFormatter, (start2, end2) => `${start2} \u2013 ${end2}`, timeZone) : monthFormatter.formatRange(start.toDate(timeZone), end.toDate(timeZone));
+  }
+}
+
+// src/get-week-dates.ts
+var import_date5 = require("@internationalized/date");
 function getDatesInWeek(weekIndex, fromDate, locale) {
   let date = fromDate.add({ weeks: weekIndex });
   let dates = [];
-  date = (0, import_date4.startOfWeek)(date, locale);
-  let dayOfWeek = (0, import_date4.getDayOfWeek)(date, locale);
+  date = (0, import_date5.startOfWeek)(date, locale);
+  let dayOfWeek = (0, import_date5.getDayOfWeek)(date, locale);
   for (let i = 0; i < dayOfWeek; i++) {
     dates.push(null);
   }
   while (dates.length < 7) {
     dates.push(date);
     let nextDate = date.add({ days: 1 });
-    if ((0, import_date4.isSameDay)(date, nextDate)) {
+    if ((0, import_date5.isSameDay)(date, nextDate)) {
       break;
     }
     date = nextDate;
@@ -287,8 +314,8 @@ function getDatesInWeek(weekIndex, fromDate, locale) {
   }
   return dates;
 }
-function getWeekDates(timeZone, locale) {
-  let weekStart = (0, import_date4.startOfWeek)((0, import_date4.today)(timeZone), locale);
+function getWeekDates(fromDate, timeZone, locale) {
+  let weekStart = (0, import_date5.startOfWeek)(fromDate, locale);
   let weekArr = [...new Array(7).keys()];
   return weekArr.map((index) => {
     return weekStart.add({ days: index }).toDate(timeZone);
@@ -296,10 +323,10 @@ function getWeekDates(timeZone, locale) {
 }
 
 // src/get-month-dates.ts
-var import_date5 = require("@internationalized/date");
+var import_date6 = require("@internationalized/date");
 function getMonthDates(startDate, duration, locale) {
   var _a;
-  let weeksInMonth = (0, import_date5.getWeeksInMonth)(startDate, locale);
+  let weeksInMonth = (0, import_date6.getWeeksInMonth)(startDate, locale);
   let numOfWeeks = (_a = duration.weeks) != null ? _a : weeksInMonth;
   let weekArr = [...new Array(numOfWeeks).keys()];
   return weekArr.map((index) => {
@@ -317,12 +344,9 @@ function getYearsRange(range) {
 }
 
 // src/mutation.ts
-var import_date6 = require("@internationalized/date");
-function clampDate(ctx, date) {
-  return constrainValue(ctx, date);
-}
+var import_date7 = require("@internationalized/date");
 function getTodayDate(timezone) {
-  return (0, import_date6.today)(timezone);
+  return (0, import_date7.today)(timezone);
 }
 function getNextDay(date) {
   return date.add({ days: 1 });
@@ -337,26 +361,19 @@ function setYear(date, year) {
   return date.set({ year });
 }
 function setCalendar(date, calendar) {
-  return (0, import_date6.toCalendar)((0, import_date6.toCalendarDate)(date), calendar);
+  return (0, import_date7.toCalendar)((0, import_date7.toCalendarDate)(date), calendar);
 }
-function setDate(ctx, date, nextDate, startDate) {
+function setDate(date, startDate, isDateUnavailable2, minValue, maxValue) {
   let result;
-  result = clampDate(ctx, nextDate);
-  result = getPreviousAvailableDate(ctx, nextDate, startDate);
-  if (!result)
-    return;
-  result = (0, import_date6.toCalendar)(result, (date == null ? void 0 : date.calendar) || new import_date6.GregorianCalendar());
-  if (date && "hour" in date) {
-    return date.set(result);
-  }
+  result = constrainValue(date, minValue, maxValue);
+  result = getPreviousAvailableDate(date, startDate, isDateUnavailable2);
   return result;
 }
-function getPreviousAvailableDate(ctx, date, min) {
-  const minValue = min != null ? min : ctx.min;
-  if (!isDateUnavailable(ctx, date) || !minValue) {
+function getPreviousAvailableDate(date, minValue, isDateUnavailable2) {
+  if (!isDateUnavailable2) {
     return date;
   }
-  while (date.compare(minValue) >= 0 && isDateUnavailable(ctx, date)) {
+  while (date.compare(minValue) >= 0 && isDateUnavailable2(date)) {
     date = date.subtract({ days: 1 });
   }
   if (date.compare(minValue) >= 0) {
@@ -365,93 +382,176 @@ function getPreviousAvailableDate(ctx, date, min) {
 }
 
 // src/pagination.ts
-var import_date7 = require("@internationalized/date");
-function getNextPage(ctx, date, startDate) {
-  const start = startDate.add(ctx.duration);
-  return {
-    startDate: alignStart(ctx, constrainStart(ctx, date, start)),
-    focusedDate: constrainValue(ctx, date.add(ctx.duration))
-  };
-}
-function getPreviousPage(ctx, date, startDate) {
-  const start = startDate.subtract(ctx.duration);
-  return {
-    startDate: alignStart(ctx, constrainStart(ctx, date, start)),
-    focusedDate: constrainValue(ctx, date.subtract(ctx.duration))
+var import_date8 = require("@internationalized/date");
+function getAdjustedDateFn(visibleDuration, locale, minValue, maxValue) {
+  return function getDate(options) {
+    const { startDate, focusedDate } = options;
+    const endDate = getEndDate(startDate, visibleDuration);
+    if (isDateInvalid(focusedDate, minValue, maxValue)) {
+      return {
+        startDate,
+        focusedDate: constrainValue(focusedDate, minValue, maxValue),
+        endDate
+      };
+    }
+    if (focusedDate.compare(startDate) < 0) {
+      return {
+        startDate: alignEnd(focusedDate, visibleDuration, locale, minValue, maxValue),
+        endDate,
+        focusedDate: constrainValue(focusedDate, minValue, maxValue)
+      };
+    }
+    if (focusedDate.compare(endDate) > 0) {
+      return {
+        startDate: alignStart(focusedDate, visibleDuration, locale, minValue, maxValue),
+        endDate,
+        focusedDate: constrainValue(focusedDate, minValue, maxValue)
+      };
+    }
+    return {
+      startDate,
+      endDate,
+      focusedDate: constrainValue(focusedDate, minValue, maxValue)
+    };
   };
 }
-function getSectionStart(ctx, date, startDate) {
-  const d = ctx.duration;
-  if (d.days) {
-    return startDate;
-  }
-  if (d.weeks) {
-    return (0, import_date7.startOfWeek)(date, ctx.locale);
-  }
-  if (d.months || d.years) {
-    return (0, import_date7.startOfMonth)(date);
-  }
-}
-function getSectionEnd(ctx, date, endDate) {
-  const d = ctx.duration;
-  if (d.days) {
-    return endDate;
-  }
-  if (d.weeks) {
-    return (0, import_date7.endOfWeek)(date, ctx.locale);
-  }
-  if (d.months || d.years) {
-    return (0, import_date7.endOfMonth)(date);
-  }
-}
-function getNextSection(ctx, date, larger) {
-  const d = ctx.duration;
-  const unitDuration = getUnitDuration(ctx.duration);
-  if (!larger && !d.days) {
-    return date.add(unitDuration);
-  }
-  if (d.days) {
-    return date.add(d);
-  }
-  if (d.weeks) {
-    return date.add({ months: 1 });
-  }
-  if (d.months || d.years) {
-    return date.add({ years: 1 });
-  }
-}
-function getPreviousSection(ctx, date, larger) {
-  const d = ctx.duration;
-  const unitDuration = getUnitDuration(ctx.duration);
-  if (!larger && !d.days) {
-    return date.subtract(unitDuration);
-  }
-  if (d.days) {
-    return date.subtract(ctx.duration);
-  }
-  if (d.weeks) {
-    return date.subtract({ months: 1 });
-  }
-  if (d.months || d.years) {
-    return date.subtract({ years: 1 });
-  }
+function getNextPage(focusedDate, startDate, visibleDuration, locale, minValue, maxValue) {
+  const adjust = getAdjustedDateFn(visibleDuration, locale, minValue, maxValue);
+  const start = startDate.add(visibleDuration);
+  return adjust({
+    focusedDate: focusedDate.add(visibleDuration),
+    startDate: alignStart(
+      constrainStart(focusedDate, start, visibleDuration, locale, minValue, maxValue),
+      visibleDuration,
+      locale
+    )
+  });
 }
-function getNextRow(ctx, date, startDate) {
-  const d = ctx.duration;
-  if (d.days) {
-    return getNextPage(ctx, date, startDate);
-  }
-  if (d.weeks || d.months || d.years) {
-    return date.add({ weeks: 1 });
-  }
+function getPreviousPage(focusedDate, startDate, visibleDuration, locale, minValue, maxValue) {
+  const adjust = getAdjustedDateFn(visibleDuration, locale, minValue, maxValue);
+  let start = startDate.subtract(visibleDuration);
+  return adjust({
+    focusedDate: focusedDate.subtract(visibleDuration),
+    startDate: alignStart(
+      constrainStart(focusedDate, start, visibleDuration, locale, minValue, maxValue),
+      visibleDuration,
+      locale
+    )
+  });
 }
-function getPreviousRow(ctx, date, startDate) {
-  const d = ctx.duration;
-  if (d.days) {
-    return getPreviousPage(ctx, date, startDate);
-  }
-  if (d.weeks || d.months || d.years) {
-    return date.subtract({ weeks: 1 });
+function getNextRow(focusedDate, startDate, visibleDuration, locale, minValue, maxValue) {
+  const adjust = getAdjustedDateFn(visibleDuration, locale, minValue, maxValue);
+  if (visibleDuration.days) {
+    return getNextPage(focusedDate, startDate, visibleDuration, locale, minValue, maxValue);
+  }
+  if (visibleDuration.weeks || visibleDuration.months || visibleDuration.years) {
+    return adjust({
+      focusedDate: focusedDate.add({ weeks: 1 }),
+      startDate
+    });
+  }
+}
+function getPreviousRow(focusedDate, startDate, visibleDuration, locale, minValue, maxValue) {
+  const adjust = getAdjustedDateFn(visibleDuration, locale, minValue, maxValue);
+  if (visibleDuration.days) {
+    return getPreviousPage(focusedDate, startDate, visibleDuration, locale, minValue, maxValue);
+  }
+  if (visibleDuration.weeks || visibleDuration.months || visibleDuration.years) {
+    return adjust({
+      focusedDate: focusedDate.subtract({ weeks: 1 }),
+      startDate
+    });
+  }
+}
+function getSectionStart(focusedDate, startDate, visibleDuration, locale, minValue, maxValue) {
+  const adjust = getAdjustedDateFn(visibleDuration, locale, minValue, maxValue);
+  if (visibleDuration.days) {
+    return adjust({
+      focusedDate: startDate,
+      startDate
+    });
+  }
+  if (visibleDuration.weeks) {
+    return adjust({
+      focusedDate: (0, import_date8.startOfWeek)(focusedDate, locale),
+      startDate
+    });
+  }
+  if (visibleDuration.months || visibleDuration.years) {
+    return adjust({
+      focusedDate: (0, import_date8.startOfMonth)(focusedDate),
+      startDate
+    });
+  }
+}
+function getSectionEnd(focusedDate, startDate, visibleDuration, locale, minValue, maxValue) {
+  const adjust = getAdjustedDateFn(visibleDuration, locale, minValue, maxValue);
+  const endDate = getEndDate(startDate, visibleDuration);
+  if (visibleDuration.days) {
+    return adjust({
+      focusedDate: endDate,
+      startDate
+    });
+  }
+  if (visibleDuration.weeks) {
+    return adjust({
+      focusedDate: (0, import_date8.endOfWeek)(focusedDate, locale),
+      startDate
+    });
+  }
+  if (visibleDuration.months || visibleDuration.years) {
+    return adjust({
+      focusedDate: (0, import_date8.endOfMonth)(focusedDate),
+      startDate
+    });
+  }
+}
+function getNextSection(focusedDate, startDate, larger, visibleDuration, locale, minValue, maxValue) {
+  const adjust = getAdjustedDateFn(visibleDuration, locale, minValue, maxValue);
+  if (!larger && !visibleDuration.days) {
+    return adjust({
+      focusedDate: focusedDate.add(getUnitDuration(visibleDuration)),
+      startDate
+    });
+  }
+  if (visibleDuration.days) {
+    return getNextPage(focusedDate, startDate, visibleDuration, locale, minValue, maxValue);
+  }
+  if (visibleDuration.weeks) {
+    return adjust({
+      focusedDate: focusedDate.add({ months: 1 }),
+      startDate
+    });
+  }
+  if (visibleDuration.months || visibleDuration.years) {
+    return adjust({
+      focusedDate: focusedDate.add({ years: 1 }),
+      startDate
+    });
+  }
+}
+function getPreviousSection(focusedDate, startDate, larger, visibleDuration, locale, minValue, maxValue) {
+  const adjust = getAdjustedDateFn(visibleDuration, locale, minValue, maxValue);
+  if (!larger && !visibleDuration.days) {
+    return adjust({
+      focusedDate: focusedDate.subtract(getUnitDuration(visibleDuration)),
+      startDate
+    });
+  }
+  if (visibleDuration.days) {
+    return getPreviousPage(focusedDate, startDate, visibleDuration, locale, minValue, maxValue);
+  }
+  if (visibleDuration.weeks) {
+    return adjust({
+      focusedDate: focusedDate.subtract({ months: 1 }),
+      startDate
+    });
+  }
+  if (visibleDuration.months || visibleDuration.years) {
+    return adjust({
+      focusedDate: focusedDate.subtract({ years: 1 }),
+      startDate
+    });
   }
 }
 
@@ -479,7 +579,7 @@ function isSegmentEditable(segment) {
 }
 
 // src/segment-limit.ts
-var import_date8 = require("@internationalized/date");
+var import_date9 = require("@internationalized/date");
 function getSegmentLimits(date, type, options) {
   switch (type) {
     case "era": {
@@ -499,13 +599,13 @@ function getSegmentLimits(date, type, options) {
     case "month":
       return {
         value: date.month,
-        min: (0, import_date8.getMinimumMonthInYear)(date),
+        min: (0, import_date9.getMinimumMonthInYear)(date),
         max: date.calendar.getMonthsInYear(date)
       };
     case "day":
       return {
         value: date.day,
-        min: (0, import_date8.getMinimumDayInMonth)(date),
+        min: (0, import_date9.getMinimumDayInMonth)(date),
         max: date.calendar.getDaysInMonth(date)
       };
   }
@@ -518,7 +618,7 @@ function getSegmentLimits(date, type, options) {
           max: 12
         };
       case "hour":
-        if (options.hour12) {
+        if (options == null ? void 0 : options.hour12) {
           let isPM = date.hour >= 12;
           return {
             value: date.hour,
@@ -569,10 +669,11 @@ function addSegment(date, part, amount, options) {
       case "second":
         return date.cycle(part, amount, {
           round: part !== "hour",
-          hourCycle: options.hour12 ? 12 : 24
+          hourCycle: (options == null ? void 0 : options.hour12) ? 12 : 24
         });
     }
   }
+  return date;
 }
 function setSegment(date, part, value, options) {
   switch (part) {
@@ -591,7 +692,7 @@ function setSegment(date, part, value, options) {
         return isPM === wasPM ? date : date.set({ hour: wasPM ? hours - 12 : hours + 12 });
       }
       case "hour":
-        if (options.hour12) {
+        if (options == null ? void 0 : options.hour12) {
           let hours = date.hour;
           let wasPM = hours >= 12;
           if (!wasPM && value === 12) {
@@ -606,6 +707,7 @@ function setSegment(date, part, value, options) {
         return date.set({ [part]: value });
     }
   }
+  return date;
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
@@ -616,11 +718,11 @@ function setSegment(date, part, value, options) {
   alignEnd,
   alignStart,
   alignStartDate,
-  clampDate,
   constrainStart,
   constrainValue,
   formatRange,
   formatSelectedDate,
+  formatVisibleRange,
   getDatesInWeek,
   getEndDate,
   getMonthDates,
@@ -628,6 +730,7 @@ function setSegment(date, part, value, options) {
   getNextPage,
   getNextRow,
   getNextSection,
+  getPreviousAvailableDate,
   getPreviousDay,
   getPreviousPage,
   getPreviousRow,