@zag-js/date-utils 0.70.0 → 0.72.0

package/src/pagination.ts

@@ -1,301 +0,0 @@
-import {
-  type DateDuration,
-  type 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 interface AdjustDateParams {
-  startDate: DateValue
-  focusedDate: DateValue
-}
-
-export interface AdjustDateReturn extends AdjustDateParams {
-  endDate: DateValue
-}
-
-export function getAdjustedDateFn(
-  visibleDuration: DateDuration,
-  locale: string,
-  minValue?: DateValue,
-  maxValue?: DateValue,
-) {
-  return function getDate(options: AdjustDateParams): AdjustDateReturn {
-    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),
-        focusedDate: constrainValue(focusedDate, minValue, maxValue),
-        endDate,
-      }
-    }
-
-    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

@@ -1,73 +0,0 @@
-import { CalendarDate, DateFormatter, type DateValue } from "@internationalized/date"
-import { normalizeYear } from "./normalize-year"
-
-const isValidYear = (year: string | null | undefined): year is string => year != null && year.length === 4
-const isValidMonth = (month: string | null | undefined): month is string => month != null && parseFloat(month) <= 12
-const isValidDay = (day: string | null | undefined): day is string => day != null && parseFloat(day) <= 31
-
-export function parseDateString(date: string, locale: string, timeZone: string): DateValue | undefined {
-  const regex = createRegex(locale, timeZone)
-
-  let { year, month, day } = extract(regex, date) ?? {}
-
-  const hasMatch = year != null || month != null || day != null
-
-  if (hasMatch) {
-    const curr = new Date()
-    year ||= curr.getFullYear().toString()
-    month ||= (curr.getMonth() + 1).toString()
-    day ||= curr.getDate().toString()
-  }
-
-  if (!isValidYear(year)) {
-    year = normalizeYear(year)
-  }
-
-  if (isValidYear(year) && isValidMonth(month) && isValidDay(day)) {
-    return new CalendarDate(+year, +month, +day)
-  }
-
-  // We should never get here, but just in case
-  const time = Date.parse(date)
-  if (!isNaN(time)) {
-    const date = new Date(time)
-    return new CalendarDate(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("")
-}
-
-interface DateParts {
-  year: string | null
-  month: string | null
-  day: string | null
-}
-
-type DatePart = keyof DateParts
-
-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 as DatePart] = matches[index + 1]
-      } else {
-        acc[curr as DatePart] = null
-      }
-      return acc
-    }, {} as DateParts)
-}

package/src/preset.ts

@@ -1,63 +0,0 @@
-import {
-  endOfMonth,
-  endOfWeek,
-  endOfYear,
-  now,
-  startOfMonth,
-  startOfWeek,
-  startOfYear,
-  type DateValue,
-} from "@internationalized/date"
-
-export type DateRangePreset =
-  | "thisWeek"
-  | "lastWeek"
-  | "thisMonth"
-  | "lastMonth"
-  | "thisQuarter"
-  | "lastQuarter"
-  | "thisYear"
-  | "lastYear"
-  | "last3Days"
-  | "last7Days"
-  | "last14Days"
-  | "last30Days"
-  | "last90Days"
-
-export function getDateRangePreset(preset: DateRangePreset, locale: string, timeZone: string): [DateValue, DateValue] {
-  const today = now(timeZone)
-
-  switch (preset) {
-    case "thisWeek":
-      return [startOfWeek(today, locale), endOfWeek(today, locale)]
-    case "thisMonth":
-      return [startOfMonth(today), today]
-    case "thisQuarter":
-      return [startOfMonth(today).add({ months: -today.month % 3 }), today]
-    case "thisYear":
-      return [startOfYear(today), today]
-    case "last3Days":
-      return [today.add({ days: -2 }), today]
-    case "last7Days":
-      return [today.add({ days: -6 }), today]
-    case "last14Days":
-      return [today.add({ days: -13 }), today]
-    case "last30Days":
-      return [today.add({ days: -29 }), today]
-    case "last90Days":
-      return [today.add({ days: -89 }), today]
-    case "lastMonth":
-      return [startOfMonth(today.add({ months: -1 })), endOfMonth(today.add({ months: -1 }))]
-    case "lastQuarter":
-      return [
-        startOfMonth(today.add({ months: (-today.month % 3) - 3 })),
-        endOfMonth(today.add({ months: (-today.month % 3) - 1 })),
-      ]
-    case "lastWeek":
-      return [startOfWeek(today, locale).add({ weeks: -1 }), endOfWeek(today, locale).add({ weeks: -1 })]
-    case "lastYear":
-      return [startOfYear(today.add({ years: -1 })), endOfYear(today.add({ years: -1 }))]
-    default:
-      throw new Error(`Invalid date range preset: ${preset}`)
-  }
-}

package/src/types.ts

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