@zag-js/date-utils 0.70.0 → 0.71.0

package/src/assertion.ts

@@ -1,62 +0,0 @@
-import { type 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 isDateOutsideVisibleRange(date, startDate, endDate) || 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

@@ -1,117 +0,0 @@
-import {
-  type DateDuration,
-  type 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 {
-  const halfDuration: DateDuration = {}
-
-  for (let prop in duration) {
-    const key = prop as keyof DateDuration
-
-    const value = duration[key]
-    if (value == null) continue
-
-    halfDuration[key] = Math.floor(value / 2)
-
-    if (halfDuration[key] > 0 && value % 2 === 0) {
-      halfDuration[key]--
-    }
-  }
-
-  const 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

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

package/src/format-range.ts

@@ -1,35 +0,0 @@
-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

@@ -1,16 +0,0 @@
-import { type 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

@@ -1,26 +0,0 @@
-import { type 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

@@ -1,14 +0,0 @@
-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

@@ -1,12 +0,0 @@
-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

@@ -1,6 +0,0 @@
-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

@@ -1,5 +0,0 @@
-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

@@ -1,33 +0,0 @@
-import { type DateValue, getWeeksInMonth, isSameDay, getDayOfWeek, startOfMonth } 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 getCustomWeeksInMonth(from: DateValue, locale: string, firstDayOfWeek?: number) {
-  if (firstDayOfWeek == null) {
-    return getWeeksInMonth(from, locale)
-  }
-  const paddingDays = (getDayOfWeek(startOfMonth(from), locale) - firstDayOfWeek + 7) % 7
-
-  return Math.ceil((paddingDays + from.calendar.getDaysInMonth(from)) / 7)
-}
-
-export function getMonthDays(from: DateValue, locale: string, numOfWeeks?: number, firstDayOfWeek?: number) {
-  const monthWeeks = numOfWeeks ?? getCustomWeeksInMonth(from, locale, firstDayOfWeek)
-
-  const weeks = [...new Array(monthWeeks).keys()]
-  return weeks.map((week) => getDaysInWeek(week, from, locale, firstDayOfWeek))
-}

package/src/get-month-formatter.ts

@@ -1,13 +0,0 @@
-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

@@ -1,9 +0,0 @@
-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

@@ -1,14 +0,0 @@
-import { type DateValue, getDayOfWeek, startOfWeek } from "@internationalized/date"
-
-export function getStartOfWeek(date: DateValue, locale: string, firstDayOfWeek?: number) {
-  // If firstDayOfWeek is provided, use it; otherwise, use the locale's default
-  if (firstDayOfWeek !== undefined) {
-    // Adjust the date to the specified first day of the week
-    const currentDayOfWeek = getDayOfWeek(date, locale)
-    const daysToSubtract = (currentDayOfWeek - firstDayOfWeek + 7) % 7
-    return date.subtract({ days: daysToSubtract })
-  }
-
-  // Use the built-in startOfWeek function for locale-specific behavior
-  return startOfWeek(date, locale)
-}

package/src/get-week-days.ts

@@ -1,10 +0,0 @@
-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

@@ -1,16 +0,0 @@
-import { type 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

@@ -1,14 +0,0 @@
-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

@@ -1,20 +0,0 @@
-export * from "./align"
-export * from "./assertion"
-export * from "./constrain"
-export * from "./duration"
-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 * from "./preset"
-export type { DateAdjustFn, DateGranularity } from "./types"

package/src/mutation.ts

@@ -1,67 +0,0 @@
-import {
-  type Calendar,
-  type 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/normalize-year.ts

@@ -1,20 +0,0 @@
-const FUTURE_YEAR_COERCION = 10
-
-export function normalizeYear(year: string | null | undefined) {
-  if (!year) return
-
-  if (year.length === 3) {
-    return year.padEnd(4, "0")
-  }
-
-  if (year.length === 2) {
-    const currentYear = new Date().getFullYear()
-    const currentCentury = Math.floor(currentYear / 100) * 100
-    const twoDigitYear = parseInt(year.slice(-2), 10)
-
-    const fullYear = currentCentury + twoDigitYear
-    return fullYear > currentYear + FUTURE_YEAR_COERCION ? (fullYear - 100).toString() : fullYear.toString()
-  }
-
-  return year
-}