@zag-js/date-utils 0.9.2 → 0.10.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zag-js/date-utils",
-  "version": "0.9.2",
+  "version": "0.10.1",
   "description": "Date utilities for zag.js",
   "keywords": [
     "js",
@@ -14,7 +14,8 @@
   "repository": "https://github.com/chakra-ui/zag/tree/main/packages/utilities/date-utils",
   "sideEffects": false,
   "files": [
-    "dist/**/*"
+    "dist",
+    "src"
   ],
   "publishConfig": {
     "access": "public"

package/src/align.ts

@@ -0,0 +1,40 @@
+import type { DateDuration, DateValue } from "@internationalized/date"
+import { alignCenter, alignEnd, alignStart } from "./constrain"
+import type { DateAlignment } from "./types"
+
+export function alignDate(
+  date: DateValue,
+  alignment: DateAlignment,
+  duration: DateDuration,
+  locale: string,
+  min?: DateValue | undefined,
+  max?: DateValue | undefined,
+) {
+  switch (alignment) {
+    case "start":
+      return alignStart(date, duration, locale, min, max)
+    case "end":
+      return alignEnd(date, duration, locale, min, max)
+    case "center":
+    default:
+      return alignCenter(date, duration, locale, min, max)
+  }
+}
+
+export function alignStartDate(
+  date: DateValue,
+  startDate: DateValue,
+  endDate: DateValue,
+  duration: DateDuration,
+  locale: string,
+  min?: DateValue | undefined,
+  max?: DateValue | undefined,
+) {
+  if (date.compare(startDate) < 0) {
+    return alignEnd(date, duration, locale, min, max)
+  }
+  if (date.compare(endDate) > 0) {
+    return alignStart(date, duration, locale, min, max)
+  }
+  return startDate
+}

package/src/assertion.ts

@@ -0,0 +1,62 @@
+import { DateValue, isSameDay, isToday } from "@internationalized/date"
+import type { DateAvailableFn } from "./types"
+
+export function isTodayDate(date: DateValue, timeZone: string) {
+  return isToday(date, timeZone)
+}
+
+export function isDateEqual(dateA: DateValue, dateB?: DateValue | null) {
+  return dateB != null && isSameDay(dateA, dateB)
+}
+
+export function isDateInvalid(date: DateValue, minValue?: DateValue | null, maxValue?: DateValue | null) {
+  return (minValue != null && date.compare(minValue) < 0) || (maxValue != null && date.compare(maxValue) > 0)
+}
+
+export function isDateDisabled(
+  date: DateValue,
+  startDate: DateValue,
+  endDate: DateValue,
+  minValue?: DateValue | null,
+  maxValue?: DateValue | null,
+) {
+  return date.compare(startDate) < 0 || date.compare(endDate) > 0 || isDateInvalid(date, minValue, maxValue)
+}
+
+export function isDateUnavailable(
+  date: DateValue | null,
+  isUnavailable: DateAvailableFn | undefined,
+  locale: string,
+  minValue?: DateValue | null,
+  maxValue?: DateValue | null,
+) {
+  if (!date) {
+    return false
+  }
+  if (isUnavailable?.(date, locale)) {
+    return true
+  }
+  return isDateInvalid(date, minValue, maxValue)
+}
+
+export function isDateOutsideVisibleRange(date: DateValue, startDate: DateValue, endDate: DateValue) {
+  return date.compare(startDate) < 0 || date.compare(endDate) > 0
+}
+
+export function isPreviousVisibleRangeInvalid(
+  startDate: DateValue,
+  minValue?: DateValue | null,
+  maxValue?: DateValue | null,
+) {
+  const prevDate = startDate.subtract({ days: 1 })
+  return isSameDay(prevDate, startDate) || isDateInvalid(prevDate, minValue, maxValue)
+}
+
+export function isNextVisibleRangeInvalid(
+  endDate: DateValue,
+  minValue?: DateValue | null,
+  maxValue?: DateValue | null,
+) {
+  const nextDate = endDate.add({ days: 1 })
+  return isSameDay(nextDate, endDate) || isDateInvalid(nextDate, minValue, maxValue)
+}

package/src/constrain.ts

@@ -0,0 +1,109 @@
+import {
+  DateDuration,
+  DateValue,
+  maxDate,
+  minDate,
+  startOfMonth,
+  startOfWeek,
+  startOfYear,
+  toCalendarDate,
+} from "@internationalized/date"
+
+/* -----------------------------------------------------------------------------
+ * Align date to start, end, or center of a duration
+ * -----------------------------------------------------------------------------*/
+
+export function alignCenter(
+  date: DateValue,
+  duration: DateDuration,
+  locale: string,
+  min?: DateValue,
+  max?: DateValue,
+): DateValue {
+  let halfDuration: DateDuration = {}
+  for (let key in duration) {
+    halfDuration[key] = Math.floor(duration[key] / 2)
+    if (halfDuration[key] > 0 && duration[key] % 2 === 0) {
+      halfDuration[key]--
+    }
+  }
+
+  let aligned = alignStart(date, duration, locale).subtract(halfDuration)
+  return constrainStart(date, aligned, duration, locale, min, max)
+}
+
+export function alignStart(
+  date: DateValue,
+  duration: DateDuration,
+  locale: string,
+  min?: DateValue,
+  max?: DateValue,
+): DateValue {
+  // align to the start of the largest unit
+  let aligned = date
+  if (duration.years) {
+    aligned = startOfYear(date)
+  } else if (duration.months) {
+    aligned = startOfMonth(date)
+  } else if (duration.weeks) {
+    aligned = startOfWeek(date, locale)
+  }
+
+  return constrainStart(date, aligned, duration, locale, min, max)
+}
+
+export function alignEnd(
+  date: DateValue,
+  duration: DateDuration,
+  locale: string,
+  min?: DateValue,
+  max?: DateValue,
+): DateValue {
+  let d: DateDuration = { ...duration }
+  // subtract 1 from the smallest unit
+  if (d.days) {
+    d.days--
+  } else if (d.weeks) {
+    d.weeks--
+  } else if (d.months) {
+    d.months--
+  } else if (d.years) {
+    d.years--
+  }
+
+  let aligned = alignStart(date, duration, locale).subtract(d)
+  return constrainStart(date, aligned, duration, locale, min, max)
+}
+
+/* -----------------------------------------------------------------------------
+ * Constrain a date to a min/max range
+ * -----------------------------------------------------------------------------*/
+
+export function constrainStart(
+  date: DateValue,
+  aligned: DateValue,
+  duration: DateDuration,
+  locale: string,
+  min?: DateValue,
+  max?: DateValue,
+): DateValue {
+  if (min && date.compare(min) >= 0) {
+    aligned = maxDate(aligned, alignStart(toCalendarDate(min), duration, locale))
+  }
+
+  if (max && date.compare(max) <= 0) {
+    aligned = minDate(aligned, alignEnd(toCalendarDate(max), duration, locale))
+  }
+
+  return aligned
+}
+
+export function constrainValue(date: DateValue, minValue?: DateValue, maxValue?: DateValue): DateValue {
+  if (minValue) {
+    date = maxDate(date, toCalendarDate(minValue))
+  }
+  if (maxValue) {
+    date = minDate(date, toCalendarDate(maxValue))
+  }
+  return date
+}

package/src/duration.ts

@@ -0,0 +1,19 @@
+import type { DateDuration, DateValue } from "@internationalized/date"
+
+export function getUnitDuration(duration: DateDuration) {
+  let d = { ...duration }
+  for (let key in d) {
+    d[key] = 1
+  }
+  return d
+}
+
+export function getEndDate(startDate: DateValue, duration: DateDuration) {
+  let d = { ...duration }
+  if (d.days) {
+    d.days--
+  } else {
+    d.days = -1
+  }
+  return startDate.add(d)
+}

package/src/format-date.ts

@@ -0,0 +1,67 @@
+import { DateValue, toCalendarDateTime } from "@internationalized/date"
+
+function createRegEx(sign: string) {
+  let symbols = "\\s|\\.|-|/|\\\\|,|\\$|\\!|\\?|:|;"
+  return new RegExp("(^|>|" + symbols + ")(" + sign + ")($|<|" + symbols + ")", "g")
+}
+
+/**
+ * Formats a date using the given format string as defined in:
+ * https://www.unicode.org/reports/tr35/tr35-dates.html#Date_Field_Symbol_Table
+ */
+export function formatDate(value: DateValue, formatString: string, locale: string, timeZone: string = "UTC") {
+  const datetime = toCalendarDateTime(value)
+  const date = datetime.toDate(timeZone)
+
+  const formats = {
+    // Time in ms
+    T: date.getTime(),
+
+    // Minutes
+    m: date.toLocaleString(locale, { minute: "numeric" }),
+    mm: date.toLocaleString(locale, { minute: "2-digit" }),
+
+    // Seconds
+    s: date.toLocaleString(locale, { second: "numeric" }),
+    ss: date.toLocaleString(locale, { second: "2-digit" }),
+
+    // Hours
+    h: date.toLocaleString(locale, { hour: "numeric", hour12: true }),
+    hh: date.toLocaleString(locale, { hour: "2-digit", hour12: true }),
+    H: date.toLocaleString(locale, { hour: "numeric", hour12: false }),
+    HH: date.toLocaleString(locale, { hour: "2-digit", hour12: false }),
+
+    // Day period
+    aa: date.toLocaleString(locale, { hour: "numeric", hour12: true }).toLowerCase(),
+    AA: date.toLocaleString(locale, { hour: "numeric", hour12: true }).toUpperCase(),
+
+    // Day of week
+    E: date.toLocaleString(locale, { weekday: "short" }),
+    EE: date.toLocaleString(locale, { weekday: "short" }),
+    EEE: date.toLocaleString(locale, { weekday: "short" }),
+    EEEE: date.toLocaleString(locale, { weekday: "long" }),
+
+    // Date of month
+    d: datetime.day,
+    dd: date.toLocaleString(locale, { day: "2-digit" }),
+
+    // Months
+    M: datetime.month + 1,
+    MM: date.toLocaleString(locale, { month: "2-digit" }),
+    MMM: date.toLocaleString(locale, { month: "short" }),
+    MMMM: date.toLocaleString(locale, { month: "long" }),
+
+    // Years
+    yy: date.toLocaleString(locale, { year: "2-digit" }),
+    yyyy: date.toLocaleString(locale, { year: "numeric" }),
+    YY: date.toLocaleString(locale, { year: "2-digit" }),
+    YYYY: date.toLocaleString(locale, { year: "numeric" }),
+  }
+
+  let result = formatString
+  for (const key in formats) {
+    result = result.replace(createRegEx(key), "$1" + formats[key] + "$3")
+  }
+
+  return result
+}

package/src/format-range.ts

@@ -0,0 +1,35 @@
+import type { DateValue, DateFormatter } from "@internationalized/date"
+
+export function formatRange(
+  startDate: DateValue,
+  endDate: DateValue,
+  formatter: DateFormatter,
+  toString: (start: string, end: string) => string,
+  timeZone: string,
+) {
+  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]
+    if (part.source === "shared" && part.type === "literal") {
+      separatorIndex = i
+    } else if (part.source === "endRange") {
+      break
+    }
+  }
+
+  let start = ""
+  let end = ""
+
+  for (let i = 0; i < parts.length; i++) {
+    if (i < separatorIndex) {
+      start += parts[i].value
+    } else if (i > separatorIndex) {
+      end += parts[i].value
+    }
+  }
+
+  return toString(start, end)
+}

package/src/format-selected-date.ts

@@ -0,0 +1,16 @@
+import { DateValue, isSameDay } from "@internationalized/date"
+import { formatRange } from "./format-range"
+import { getDayFormatter } from "./get-day-formatter"
+
+export function formatSelectedDate(startDate: DateValue, endDate: DateValue | null, locale: string, timeZone: string) {
+  let start = startDate
+  let end = endDate ?? startDate
+
+  let formatter = getDayFormatter(locale, timeZone)
+
+  if (isSameDay(start, end)) {
+    return formatter.format(start.toDate(timeZone))
+  }
+
+  return formatRange(start, end, formatter, (start, end) => `${start} – ${end}`, timeZone)
+}

package/src/format-visible-range.ts

@@ -0,0 +1,26 @@
+import { DateValue, endOfMonth, isSameDay, startOfMonth } from "@internationalized/date"
+import { getDayFormatter } from "./get-day-formatter"
+import { getMonthFormatter } from "./get-month-formatter"
+
+export function formatVisibleRange(startDate: DateValue, endDate: DateValue | null, locale: string, timeZone: string) {
+  const start = startDate
+  const end = endDate ?? startDate
+
+  const dayFormatter = getDayFormatter(locale, timeZone)
+
+  if (!isSameDay(start, startOfMonth(start))) {
+    return dayFormatter.formatRange(start.toDate(timeZone), end.toDate(timeZone))
+  }
+
+  const monthFormatter = getMonthFormatter(locale, timeZone)
+
+  if (isSameDay(end, endOfMonth(start))) {
+    return monthFormatter.format(start.toDate(timeZone))
+  }
+
+  if (isSameDay(end, endOfMonth(end))) {
+    return monthFormatter.formatRange(start.toDate(timeZone), end.toDate(timeZone))
+  }
+
+  return ""
+}

package/src/get-day-formatter.ts

@@ -0,0 +1,14 @@
+import { DateFormatter, toCalendarDateTime, today } from "@internationalized/date"
+import { getEraFormat } from "./get-era-format"
+
+export function getDayFormatter(locale: string, timeZone: string) {
+  const date = toCalendarDateTime(today(timeZone))
+  return new DateFormatter(locale, {
+    weekday: "long",
+    month: "long",
+    year: "numeric",
+    day: "numeric",
+    era: getEraFormat(date),
+    timeZone,
+  })
+}

package/src/get-decade-range.ts

@@ -0,0 +1,12 @@
+export function getDecadeRange(year: number) {
+  const computedYear = year - (year % 10) - 1
+
+  const years: number[] = []
+
+  for (let i = 0; i < 12; i += 1) {
+    const value = computedYear + i
+    years.push(value)
+  }
+
+  return years
+}

package/src/get-end-of-week.ts

@@ -0,0 +1,6 @@
+import type { DateValue } from "@internationalized/date"
+import { getStartOfWeek } from "./get-start-of-week"
+
+export function getEndOfWeek(date: DateValue, locale: string, firstDayOfWeek: number = 0) {
+  return getStartOfWeek(date, locale, firstDayOfWeek).add({ days: 6 })
+}

package/src/get-era-format.ts

@@ -0,0 +1,5 @@
+import type { DateValue } from "@internationalized/date"
+
+export function getEraFormat(date: DateValue | undefined): "short" | undefined {
+  return date?.calendar.identifier === "gregory" && date.era === "BC" ? "short" : undefined
+}

package/src/get-month-days.ts

@@ -0,0 +1,23 @@
+import { DateValue, getWeeksInMonth, isSameDay } from "@internationalized/date"
+import { getStartOfWeek } from "./get-start-of-week"
+
+export function getDaysInWeek(weekIndex: number, from: DateValue, locale: string, firstDayOfWeek?: number) {
+  const weekDate = from.add({ weeks: weekIndex })
+  const dates: DateValue[] = []
+  let date = getStartOfWeek(weekDate, locale, firstDayOfWeek)
+  while (dates.length < 7) {
+    dates.push(date)
+    let nextDate = date.add({ days: 1 })
+    if (isSameDay(date, nextDate)) {
+      break
+    }
+    date = nextDate
+  }
+  return dates
+}
+
+export function getMonthDays(from: DateValue, locale: string, numOfWeeks?: number, firstDayOfWeek?: number) {
+  const monthWeeks = getWeeksInMonth(from, locale)
+  const weeks = [...new Array(numOfWeeks ?? monthWeeks).keys()]
+  return weeks.map((week) => getDaysInWeek(week, from, locale, firstDayOfWeek))
+}

package/src/get-month-formatter.ts

@@ -0,0 +1,13 @@
+import { today, toCalendarDate, DateFormatter } from "@internationalized/date"
+import { getEraFormat } from "./get-era-format"
+
+export function getMonthFormatter(locale: string, timeZone: string) {
+  const date = toCalendarDate(today(timeZone))
+  return new DateFormatter(locale, {
+    month: "long",
+    year: "numeric",
+    era: getEraFormat(date),
+    calendar: date?.calendar.identifier,
+    timeZone: timeZone,
+  })
+}

package/src/get-month-names.ts

@@ -0,0 +1,9 @@
+export function getMonthNames(locale: string, format: Intl.DateTimeFormatOptions["month"] = "long") {
+  const date = new Date(2021, 0, 1)
+  const monthNames: string[] = []
+  for (let i = 0; i < 12; i++) {
+    monthNames.push(date.toLocaleString(locale, { month: format }))
+    date.setMonth(date.getMonth() + 1)
+  }
+  return monthNames
+}

package/src/get-start-of-week.ts

@@ -0,0 +1,7 @@
+import { DateValue, getDayOfWeek } from "@internationalized/date"
+
+export function getStartOfWeek(date: DateValue, locale: string, firstDayOfWeek: number = 0) {
+  const day = getDayOfWeek(date, locale)
+  const diff = (day - firstDayOfWeek + 7) % 7
+  return date.subtract({ days: diff })
+}

package/src/get-week-days.ts

@@ -0,0 +1,10 @@
+import type { DateValue } from "@internationalized/date"
+import { getWeekdayFormats } from "./get-weekday-formats"
+import { getStartOfWeek } from "./get-start-of-week"
+
+export function getWeekDays(date: DateValue, startOfWeekProp: number | undefined, timeZone: string, locale: string) {
+  const firstDayOfWeek = getStartOfWeek(date, locale, startOfWeekProp)
+  const weeks = [...new Array(7).keys()]
+  const format = getWeekdayFormats(locale, timeZone)
+  return weeks.map((index) => format(firstDayOfWeek.add({ days: index })))
+}

package/src/get-weekday-formats.ts

@@ -0,0 +1,16 @@
+import { DateValue, DateFormatter } from "@internationalized/date"
+
+export function getWeekdayFormats(locale: string, timeZone: string) {
+  const longFormat = new DateFormatter(locale, { weekday: "long", timeZone })
+  const shortFormat = new DateFormatter(locale, { weekday: "short", timeZone })
+  const narrowFormat = new DateFormatter(locale, { weekday: "narrow", timeZone })
+  return <T extends DateValue | Date>(value: T) => {
+    const date = value instanceof Date ? value : value.toDate(timeZone)
+    return {
+      value,
+      short: shortFormat.format(date),
+      long: longFormat.format(date),
+      narrow: narrowFormat.format(date),
+    }
+  }
+}

package/src/get-year-range.ts

@@ -0,0 +1,14 @@
+export interface YearsRange {
+  from: number
+  to: number
+}
+
+export function getYearsRange(range: YearsRange) {
+  const years: number[] = []
+
+  for (let year = range.from; year <= range.to; year += 1) {
+    years.push(year)
+  }
+
+  return years
+}

package/src/index.ts

@@ -0,0 +1,20 @@
+export * from "./align"
+export * from "./assertion"
+export * from "./constrain"
+export * from "./duration"
+export * from "./format-date"
+export * from "./format-range"
+export * from "./format-selected-date"
+export * from "./format-visible-range"
+export * from "./get-day-formatter"
+export * from "./get-decade-range"
+export * from "./get-month-days"
+export * from "./get-month-formatter"
+export * from "./get-month-names"
+export * from "./get-week-days"
+export * from "./get-weekday-formats"
+export * from "./get-year-range"
+export * from "./mutation"
+export * from "./pagination"
+export * from "./parse-date"
+export type { DateAdjustFn, DateGranularity } from "./types"

package/src/mutation.ts

@@ -0,0 +1,60 @@
+import { Calendar, DateValue, getLocalTimeZone, toCalendar, toCalendarDateTime, today } from "@internationalized/date"
+import { constrainValue } from "./constrain"
+import type { DateAvailableFn } from "./types"
+
+export function getTodayDate(timeZone?: string) {
+  return today(timeZone ?? getLocalTimeZone())
+}
+
+export function getNextDay(date: DateValue) {
+  return date.add({ days: 1 })
+}
+
+export function getPreviousDay(date: DateValue) {
+  return date.subtract({ days: 1 })
+}
+
+export function setMonth(date: DateValue, month: number) {
+  return date.set({ month })
+}
+
+export function setYear(date: DateValue, year: number) {
+  return date.set({ year })
+}
+
+export function setCalendar(date: DateValue, calendar: Calendar) {
+  return toCalendar(toCalendarDateTime(date), calendar)
+}
+
+export function setDate(
+  date: DateValue,
+  startDate: DateValue,
+  isDateUnavailable: DateAvailableFn,
+  locale: string,
+  minValue: DateValue,
+  maxValue: DateValue,
+) {
+  let result: DateValue | undefined
+  result = constrainValue(date, minValue, maxValue)
+  result = getPreviousAvailableDate(date, startDate, locale, isDateUnavailable)
+  return result
+}
+
+export function getPreviousAvailableDate(
+  date: DateValue,
+  minValue: DateValue,
+  locale: string,
+  isDateUnavailable?: DateAvailableFn,
+) {
+  if (!isDateUnavailable) {
+    return date
+  }
+
+  while (date.compare(minValue) >= 0 && isDateUnavailable(date, locale)) {
+    date = date.subtract({ days: 1 })
+  }
+
+  if (date.compare(minValue) >= 0) {
+    return date
+  }
+}

package/src/pagination.ts

@@ -0,0 +1,285 @@
+import { DateDuration, DateValue, endOfMonth, endOfWeek, startOfMonth, startOfWeek } from "@internationalized/date"
+import { isDateInvalid } from "./assertion"
+import { alignEnd, alignStart, constrainStart, constrainValue } from "./constrain"
+import { getEndDate, getUnitDuration } from "./duration"
+
+export function getAdjustedDateFn(
+  visibleDuration: DateDuration,
+  locale: string,
+  minValue?: DateValue,
+  maxValue?: DateValue,
+) {
+  return function getDate(options: { startDate: DateValue; focusedDate: DateValue }) {
+    const { startDate, focusedDate } = options
+    const endDate = getEndDate(startDate, visibleDuration)
+
+    // If the focused date was moved to an invalid value, it can't be focused, so constrain it.
+    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),
+    }
+  }
+}
+
+/* -----------------------------------------------------------------------------
+ *  Get next and previous page (for date range)
+ * -----------------------------------------------------------------------------*/
+
+export function getNextPage(
+  focusedDate: DateValue,
+  startDate: DateValue,
+  visibleDuration: DateDuration,
+  locale: string,
+  minValue?: DateValue,
+  maxValue?: DateValue,
+) {
+  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,
+    ),
+  })
+}
+
+export function getPreviousPage(
+  focusedDate: DateValue,
+  startDate: DateValue,
+  visibleDuration: DateDuration,
+  locale: string,
+  minValue?: DateValue,
+  maxValue?: DateValue,
+) {
+  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,
+    ),
+  })
+}
+
+/* -----------------------------------------------------------------------------
+ * Get the next and previous row (for date range)
+ * -----------------------------------------------------------------------------*/
+
+export function getNextRow(
+  focusedDate: DateValue,
+  startDate: DateValue,
+  visibleDuration: DateDuration,
+  locale: string,
+  minValue?: DateValue,
+  maxValue?: DateValue,
+) {
+  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,
+    })
+  }
+}
+
+export function getPreviousRow(
+  focusedDate: DateValue,
+  startDate: DateValue,
+  visibleDuration: DateDuration,
+  locale: string,
+  minValue?: DateValue,
+  maxValue?: DateValue,
+) {
+  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,
+    })
+  }
+}
+
+/* -----------------------------------------------------------------------------
+ * Get start and end date for a date section
+ * -----------------------------------------------------------------------------*/
+
+export function getSectionStart(
+  focusedDate: DateValue,
+  startDate: DateValue,
+  visibleDuration: DateDuration,
+  locale: string,
+  minValue?: DateValue,
+  maxValue?: DateValue,
+) {
+  const adjust = getAdjustedDateFn(visibleDuration, locale, minValue, maxValue)
+
+  if (visibleDuration.days) {
+    return adjust({
+      focusedDate: startDate,
+      startDate,
+    })
+  }
+
+  if (visibleDuration.weeks) {
+    return adjust({
+      focusedDate: startOfWeek(focusedDate, locale),
+      startDate,
+    })
+  }
+
+  if (visibleDuration.months || visibleDuration.years) {
+    return adjust({
+      focusedDate: startOfMonth(focusedDate),
+      startDate,
+    })
+  }
+}
+
+export function getSectionEnd(
+  focusedDate: DateValue,
+  startDate: DateValue,
+  visibleDuration: DateDuration,
+  locale: string,
+  minValue?: DateValue,
+  maxValue?: DateValue,
+) {
+  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({
+      //@ts-expect-error - endOfWeek is loosely typed
+      focusedDate: endOfWeek(focusedDate, locale),
+      startDate,
+    })
+  }
+
+  if (visibleDuration.months || visibleDuration.years) {
+    return adjust({
+      focusedDate: endOfMonth(focusedDate),
+      startDate,
+    })
+  }
+}
+
+export function getNextSection(
+  focusedDate: DateValue,
+  startDate: DateValue,
+  larger: boolean,
+  visibleDuration: DateDuration,
+  locale: string,
+  minValue?: DateValue,
+  maxValue?: DateValue,
+) {
+  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,
+    })
+  }
+}
+
+export function getPreviousSection(
+  focusedDate: DateValue,
+  startDate: DateValue,
+  larger: boolean,
+  visibleDuration: DateDuration,
+  locale: string,
+  minValue?: DateValue,
+  maxValue?: DateValue,
+) {
+  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,
+    })
+  }
+}

package/src/parse-date.ts

@@ -0,0 +1,45 @@
+import { CalendarDateTime, DateFormatter } from "@internationalized/date"
+
+export function parseDateString(date: string, locale: string, timeZone: string) {
+  const regex = createRegex(locale, timeZone)
+  const { year, month, day } = extract(regex, date) ?? {}
+
+  if (year != null && year.length === 4 && month != null && +month <= 12 && day != null && +day <= 31) {
+    return new CalendarDateTime(+year, +month, +day)
+  }
+
+  const time = Date.parse(date)
+  if (!isNaN(time)) {
+    const date = new Date(time)
+    return new CalendarDateTime(date.getFullYear(), date.getMonth() + 1, date.getDate())
+  }
+}
+
+function createRegex(locale: string, timeZone: string) {
+  const formatter = new DateFormatter(locale, { day: "numeric", month: "numeric", year: "numeric", timeZone })
+  const parts = formatter.formatToParts(new Date(2000, 11, 25))
+  return parts.map(({ type, value }) => (type === "literal" ? value : `((?!=<${type}>)\\d+)`)).join("")
+}
+
+function extract(pattern: string | RegExp, str: string) {
+  const matches = str.match(pattern)
+  return pattern
+    .toString()
+    .match(/<(.+?)>/g)
+    ?.map((group) => {
+      const groupMatches = group.match(/<(.+)>/)
+      if (!groupMatches || groupMatches.length <= 0) {
+        return null
+      }
+      return group.match(/<(.+)>/)?.[1]
+    })
+    .reduce((acc, curr, index) => {
+      if (!curr) return acc
+      if (matches && matches.length > index) {
+        acc[curr] = matches[index + 1]
+      } else {
+        acc[curr] = null
+      }
+      return acc
+    }, {} as { year: string; month: string; day: string })
+}

package/src/types.ts

@@ -0,0 +1,14 @@
+import type { DateFormatter, DateValue } from "@internationalized/date"
+
+export type DateGranularity = "day" | "hour" | "minute" | "second" | "year" | "month"
+export type DateAlignment = "start" | "end" | "center"
+
+export type GetFormatterFn = (options: Intl.DateTimeFormatOptions) => DateFormatter
+export type DateAvailableFn = (date: DateValue, locale: string) => boolean
+export type GetPlaceholderFn = (options: { field: string; locale: string }) => string
+export type DateAdjustFn = (options: { startDate: DateValue; focusedDate: DateValue }) => {
+  startDate: DateValue
+  focusedDate: DateValue
+  endDate: DateValue
+}
+export type DateFormatOptions = Intl.ResolvedDateTimeFormatOptions