@zag-js/date-utils 0.1.3 → 0.5.0

package/dist/align.d.ts

@@ -1,7 +1,7 @@
-import { CalendarDate, DateDuration, DateValue } from '@internationalized/date';
+import { DateValue, DateDuration } from '@internationalized/date';
 import { DateAlignment } from './types.js';
 
-declare function alignDate(date: CalendarDate, alignment: DateAlignment, duration: DateDuration, locale: string, min?: DateValue | undefined, max?: DateValue | undefined): CalendarDate;
-declare function alignStartDate(date: CalendarDate, startDate: CalendarDate, endDate: CalendarDate, duration: DateDuration, locale: string, min?: DateValue | undefined, max?: DateValue | undefined): CalendarDate;
+declare function alignDate(date: DateValue, alignment: DateAlignment, duration: DateDuration, locale: string, min?: DateValue | undefined, max?: DateValue | undefined): DateValue;
+declare function alignStartDate(date: DateValue, startDate: DateValue, endDate: DateValue, duration: DateDuration, locale: string, min?: DateValue | undefined, max?: DateValue | undefined): DateValue;
 
 export { alignDate, alignStartDate };

package/dist/assertion.d.ts

@@ -1,13 +1,13 @@
-import { CalendarDate, DateValue } from '@internationalized/date';
+import { DateValue } from '@internationalized/date';
 import { DateAvailableFn } from './types.js';
 
-declare function isTodayDate(date: CalendarDate, timeZone: string): boolean;
-declare function isDateEqual(dateA: CalendarDate, dateB?: CalendarDate | null): boolean;
+declare function isTodayDate(date: DateValue, timeZone: string): boolean;
+declare function isDateEqual(dateA: DateValue, dateB?: DateValue | null): boolean;
 declare function isDateInvalid(date: DateValue, minValue?: DateValue | null, maxValue?: DateValue | null): boolean;
 declare function isDateDisabled(date: DateValue, startDate: DateValue, endDate: DateValue, minValue?: DateValue | null, maxValue?: DateValue | null): boolean;
-declare function isDateUnavailable(date: DateValue | null, isUnavailable: DateAvailableFn | undefined, minValue?: DateValue | null, maxValue?: DateValue | null): boolean;
-declare function isDateOutsideVisibleRange(date: CalendarDate, startDate: CalendarDate, endDate: CalendarDate): boolean;
-declare function isPreviousVisibleRangeInvalid(startDate: CalendarDate, minValue?: DateValue | null, maxValue?: DateValue | null): boolean;
-declare function isNextVisibleRangeInvalid(endDate: CalendarDate, minValue?: DateValue | null, maxValue?: DateValue | null): boolean;
+declare function isDateUnavailable(date: DateValue | null, isUnavailable: DateAvailableFn | undefined, locale: string, minValue?: DateValue | null, maxValue?: DateValue | null): boolean;
+declare function isDateOutsideVisibleRange(date: DateValue, startDate: DateValue, endDate: DateValue): boolean;
+declare function isPreviousVisibleRangeInvalid(startDate: DateValue, minValue?: DateValue | null, maxValue?: DateValue | null): boolean;
+declare function isNextVisibleRangeInvalid(endDate: DateValue, minValue?: DateValue | null, maxValue?: DateValue | null): boolean;
 
 export { isDateDisabled, isDateEqual, isDateInvalid, isDateOutsideVisibleRange, isDateUnavailable, isNextVisibleRangeInvalid, isPreviousVisibleRangeInvalid, isTodayDate };

package/dist/assertion.js

@@ -43,11 +43,11 @@ function isDateInvalid(date, minValue, maxValue) {
 function isDateDisabled(date, startDate, endDate, minValue, maxValue) {
   return date.compare(startDate) < 0 || date.compare(endDate) > 0 || isDateInvalid(date, minValue, maxValue);
 }
-function isDateUnavailable(date, isUnavailable, minValue, maxValue) {
+function isDateUnavailable(date, isUnavailable, locale, minValue, maxValue) {
   if (!date) {
     return false;
   }
-  if (isUnavailable?.(date)) {
+  if (isUnavailable?.(date, locale)) {
     return true;
   }
   return isDateInvalid(date, minValue, maxValue);

package/dist/assertion.mjs

@@ -7,7 +7,7 @@ import {
   isNextVisibleRangeInvalid,
   isPreviousVisibleRangeInvalid,
   isTodayDate
-} from "./chunk-H4CAPQVS.mjs";
+} from "./chunk-HLAN6TUA.mjs";
 export {
   isDateDisabled,
   isDateEqual,

package/dist/{chunk-ZZPZ2BFS.mjs → chunk-6FNTXW54.mjs}

@@ -3,9 +3,9 @@ import {
 } from "./chunk-MGPXEJO4.mjs";
 
 // src/mutation.ts
-import { toCalendar, toCalendarDate, today } from "@internationalized/date";
-function getTodayDate(timezone) {
-  return today(timezone);
+import { getLocalTimeZone, toCalendar, toCalendarDateTime, today } from "@internationalized/date";
+function getTodayDate(timeZone) {
+  return today(timeZone ?? getLocalTimeZone());
 }
 function getNextDay(date) {
   return date.add({ days: 1 });
@@ -20,19 +20,19 @@ function setYear(date, year) {
   return date.set({ year });
 }
 function setCalendar(date, calendar) {
-  return toCalendar(toCalendarDate(date), calendar);
+  return toCalendar(toCalendarDateTime(date), calendar);
 }
-function setDate(date, startDate, isDateUnavailable, minValue, maxValue) {
+function setDate(date, startDate, isDateUnavailable, locale, minValue, maxValue) {
   let result;
   result = constrainValue(date, minValue, maxValue);
-  result = getPreviousAvailableDate(date, startDate, isDateUnavailable);
+  result = getPreviousAvailableDate(date, startDate, locale, isDateUnavailable);
   return result;
 }
-function getPreviousAvailableDate(date, minValue, isDateUnavailable) {
+function getPreviousAvailableDate(date, minValue, locale, isDateUnavailable) {
   if (!isDateUnavailable) {
     return date;
   }
-  while (date.compare(minValue) >= 0 && isDateUnavailable(date)) {
+  while (date.compare(minValue) >= 0 && isDateUnavailable(date, locale)) {
     date = date.subtract({ days: 1 });
   }
   if (date.compare(minValue) >= 0) {

package/dist/{chunk-LQAXQPWP.mjs → chunk-6LXTZHZP.mjs}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-HKHGJ6WS.mjs";
 import {
   getDayFormatter
-} from "./chunk-ODG5YF5H.mjs";
+} from "./chunk-FJKH6IJZ.mjs";
 
 // src/format-selected-date.ts
 import { isSameDay } from "@internationalized/date";

package/dist/{chunk-ODG5YF5H.mjs → chunk-FJKH6IJZ.mjs}

@@ -3,9 +3,9 @@ import {
 } from "./chunk-KN3YMOSL.mjs";
 
 // src/get-day-formatter.ts
-import { DateFormatter, toCalendarDate, today } from "@internationalized/date";
+import { DateFormatter, toCalendarDateTime, today } from "@internationalized/date";
 function getDayFormatter(locale, timeZone) {
-  const date = toCalendarDate(today(timeZone));
+  const date = toCalendarDateTime(today(timeZone));
   return new DateFormatter(locale, {
     weekday: "long",
     month: "long",

package/dist/{chunk-H4CAPQVS.mjs → chunk-HLAN6TUA.mjs}

@@ -12,11 +12,11 @@ function isDateInvalid(date, minValue, maxValue) {
 function isDateDisabled(date, startDate, endDate, minValue, maxValue) {
   return date.compare(startDate) < 0 || date.compare(endDate) > 0 || isDateInvalid(date, minValue, maxValue);
 }
-function isDateUnavailable(date, isUnavailable, minValue, maxValue) {
+function isDateUnavailable(date, isUnavailable, locale, minValue, maxValue) {
   if (!date) {
     return false;
   }
-  if (isUnavailable?.(date)) {
+  if (isUnavailable?.(date, locale)) {
     return true;
   }
   return isDateInvalid(date, minValue, maxValue);

package/dist/chunk-KBGJA6NB.mjs

@@ -0,0 +1,55 @@
+// src/format-date.ts
+import { toCalendarDateTime } from "@internationalized/date";
+function createRegEx(sign) {
+  let symbols = "\\s|\\.|-|/|\\\\|,|\\$|\\!|\\?|:|;";
+  return new RegExp("(^|>|" + symbols + ")(" + sign + ")($|<|" + symbols + ")", "g");
+}
+function formatDate(value, formatString, locale, timeZone = "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;
+}
+
+export {
+  formatDate
+};

package/dist/{chunk-CAYCTIEJ.mjs → chunk-KQVWH4YA.mjs}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-LGEGBP3O.mjs";
 import {
   getDayFormatter
-} from "./chunk-ODG5YF5H.mjs";
+} from "./chunk-FJKH6IJZ.mjs";
 
 // src/format-visible-range.ts
 import { endOfMonth, isSameDay, startOfMonth } from "@internationalized/date";

package/dist/{chunk-KFJ757ZA.mjs → chunk-NV7UFBMY.mjs}

@@ -21,9 +21,7 @@ function getDaysInWeek(weekIndex, from, locale, firstDayOfWeek) {
 function getMonthDays(from, locale, numOfWeeks, firstDayOfWeek) {
   const monthWeeks = getWeeksInMonth(from, locale);
   const weeks = [...new Array(numOfWeeks ?? monthWeeks).keys()];
-  return weeks.map((week) => {
-    return getDaysInWeek(week, from, locale, firstDayOfWeek);
-  });
+  return weeks.map((week) => getDaysInWeek(week, from, locale, firstDayOfWeek));
 }
 
 export {

package/dist/{chunk-VTFZA34K.mjs → chunk-POBWDZPE.mjs}

@@ -1,6 +1,6 @@
 import {
   isDateInvalid
-} from "./chunk-H4CAPQVS.mjs";
+} from "./chunk-HLAN6TUA.mjs";
 import {
   alignEnd,
   alignStart,
@@ -126,6 +126,7 @@ function getSectionEnd(focusedDate, startDate, visibleDuration, locale, minValue
   }
   if (visibleDuration.weeks) {
     return adjust({
+      //@ts-expect-error - endOfWeek is loosely typed
       focusedDate: endOfWeek(focusedDate, locale),
       startDate
     });

package/dist/chunk-WQYMLJUJ.mjs

@@ -0,0 +1,42 @@
+// src/parse-date.ts
+import { CalendarDateTime, DateFormatter } from "@internationalized/date";
+function parseDateString(date, locale, timeZone) {
+  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 date2 = new Date(time);
+    return new CalendarDateTime(date2.getFullYear(), date2.getMonth() + 1, date2.getDate());
+  }
+}
+function createRegex(locale, timeZone) {
+  const formatter = new DateFormatter(locale, { day: "numeric", month: "numeric", year: "numeric", timeZone });
+  const parts = formatter.formatToParts(new Date(2e3, 11, 25));
+  return parts.map(({ type, value }) => type === "literal" ? value : `((?!=<${type}>)\\d+)`).join("");
+}
+function extract(pattern, str) {
+  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;
+  }, {});
+}
+
+export {
+  parseDateString
+};

package/dist/constrain.d.ts

@@ -1,9 +1,9 @@
-import { CalendarDate, DateDuration, DateValue } from '@internationalized/date';
+import { DateValue, DateDuration } from '@internationalized/date';
 
-declare function alignCenter(date: CalendarDate, duration: DateDuration, locale: string, min?: DateValue, max?: DateValue): CalendarDate;
-declare function alignStart(date: CalendarDate, duration: DateDuration, locale: string, min?: DateValue, max?: DateValue): CalendarDate;
-declare function alignEnd(date: CalendarDate, duration: DateDuration, locale: string, min?: DateValue, max?: DateValue): CalendarDate;
-declare function constrainStart(date: CalendarDate, aligned: CalendarDate, duration: DateDuration, locale: string, min?: DateValue, max?: DateValue): CalendarDate;
-declare function constrainValue(date: CalendarDate, minValue?: DateValue, maxValue?: DateValue): CalendarDate;
+declare function alignCenter(date: DateValue, duration: DateDuration, locale: string, min?: DateValue, max?: DateValue): DateValue;
+declare function alignStart(date: DateValue, duration: DateDuration, locale: string, min?: DateValue, max?: DateValue): DateValue;
+declare function alignEnd(date: DateValue, duration: DateDuration, locale: string, min?: DateValue, max?: DateValue): DateValue;
+declare function constrainStart(date: DateValue, aligned: DateValue, duration: DateDuration, locale: string, min?: DateValue, max?: DateValue): DateValue;
+declare function constrainValue(date: DateValue, minValue?: DateValue, maxValue?: DateValue): DateValue;
 
 export { alignCenter, alignEnd, alignStart, constrainStart, constrainValue };

package/dist/duration.d.ts

@@ -1,4 +1,5 @@
-import { DateDuration, CalendarDate } from '@internationalized/date';
+import * as _internationalized_date from '@internationalized/date';
+import { DateDuration, DateValue } from '@internationalized/date';
 
 declare function getUnitDuration(duration: DateDuration): {
     years?: number | undefined;
@@ -6,6 +7,6 @@ declare function getUnitDuration(duration: DateDuration): {
     weeks?: number | undefined;
     days?: number | undefined;
 };
-declare function getEndDate(startDate: CalendarDate, duration: DateDuration): CalendarDate;
+declare function getEndDate(startDate: DateValue, duration: DateDuration): _internationalized_date.CalendarDate | _internationalized_date.CalendarDateTime | _internationalized_date.ZonedDateTime;
 
 export { getEndDate, getUnitDuration };

package/dist/format-date.d.ts

@@ -0,0 +1,9 @@
+import { DateValue } from '@internationalized/date';
+
+/**
+ * Formats a date using the given format string as defined in:
+ * https://www.unicode.org/reports/tr35/tr35-dates.html#Date_Field_Symbol_Table
+ */
+declare function formatDate(value: DateValue, formatString: string, locale: string, timeZone?: string): string;
+
+export { formatDate };

package/dist/format-date.js

@@ -0,0 +1,79 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/format-date.ts
+var format_date_exports = {};
+__export(format_date_exports, {
+  formatDate: () => formatDate
+});
+module.exports = __toCommonJS(format_date_exports);
+var import_date = require("@internationalized/date");
+function createRegEx(sign) {
+  let symbols = "\\s|\\.|-|/|\\\\|,|\\$|\\!|\\?|:|;";
+  return new RegExp("(^|>|" + symbols + ")(" + sign + ")($|<|" + symbols + ")", "g");
+}
+function formatDate(value, formatString, locale, timeZone = "UTC") {
+  const datetime = (0, import_date.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;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  formatDate
+});

package/dist/format-date.mjs

@@ -0,0 +1,6 @@
+import {
+  formatDate
+} from "./chunk-KBGJA6NB.mjs";
+export {
+  formatDate
+};

package/dist/format-range.d.ts

@@ -1,5 +1,5 @@
-import { CalendarDate, DateFormatter } from '@internationalized/date';
+import { DateValue, DateFormatter } from '@internationalized/date';
 
-declare function formatRange(startDate: CalendarDate, endDate: CalendarDate, formatter: DateFormatter, toString: (start: string, end: string) => string, timeZone: string): string;
+declare function formatRange(startDate: DateValue, endDate: DateValue, formatter: DateFormatter, toString: (start: string, end: string) => string, timeZone: string): string;
 
 export { formatRange };

package/dist/format-selected-date.d.ts

@@ -1,5 +1,5 @@
-import { CalendarDate } from '@internationalized/date';
+import { DateValue } from '@internationalized/date';
 
-declare function formatSelectedDate(startDate: CalendarDate, endDate: CalendarDate | null, locale: string, timeZone: string): string;
+declare function formatSelectedDate(startDate: DateValue, endDate: DateValue | null, locale: string, timeZone: string): string;
 
 export { formatSelectedDate };

package/dist/format-selected-date.js

@@ -59,7 +59,7 @@ function getEraFormat(date) {
 
 // src/get-day-formatter.ts
 function getDayFormatter(locale, timeZone) {
-  const date = (0, import_date.toCalendarDate)((0, import_date.today)(timeZone));
+  const date = (0, import_date.toCalendarDateTime)((0, import_date.today)(timeZone));
   return new import_date.DateFormatter(locale, {
     weekday: "long",
     month: "long",

package/dist/format-selected-date.mjs

@@ -1,8 +1,8 @@
 import {
   formatSelectedDate
-} from "./chunk-LQAXQPWP.mjs";
+} from "./chunk-6LXTZHZP.mjs";
 import "./chunk-HKHGJ6WS.mjs";
-import "./chunk-ODG5YF5H.mjs";
+import "./chunk-FJKH6IJZ.mjs";
 import "./chunk-KN3YMOSL.mjs";
 export {
   formatSelectedDate

package/dist/format-visible-range.d.ts

@@ -1,5 +1,5 @@
-import { CalendarDate } from '@internationalized/date';
+import { DateValue } from '@internationalized/date';
 
-declare function formatVisibleRange(startDate: CalendarDate, endDate: CalendarDate | null, locale: string, timeZone: string): string;
+declare function formatVisibleRange(startDate: DateValue, endDate: DateValue | null, locale: string, timeZone: string): string;
 
 export { formatVisibleRange };

package/dist/format-visible-range.js

@@ -35,7 +35,7 @@ function getEraFormat(date) {
 
 // src/get-day-formatter.ts
 function getDayFormatter(locale, timeZone) {
-  const date = (0, import_date.toCalendarDate)((0, import_date.today)(timeZone));
+  const date = (0, import_date.toCalendarDateTime)((0, import_date.today)(timeZone));
   return new import_date.DateFormatter(locale, {
     weekday: "long",
     month: "long",

package/dist/format-visible-range.mjs

@@ -1,8 +1,8 @@
 import {
   formatVisibleRange
-} from "./chunk-CAYCTIEJ.mjs";
+} from "./chunk-KQVWH4YA.mjs";
 import "./chunk-LGEGBP3O.mjs";
-import "./chunk-ODG5YF5H.mjs";
+import "./chunk-FJKH6IJZ.mjs";
 import "./chunk-KN3YMOSL.mjs";
 export {
   formatVisibleRange

package/dist/get-day-formatter.js

@@ -32,7 +32,7 @@ function getEraFormat(date) {
 
 // src/get-day-formatter.ts
 function getDayFormatter(locale, timeZone) {
-  const date = (0, import_date.toCalendarDate)((0, import_date.today)(timeZone));
+  const date = (0, import_date.toCalendarDateTime)((0, import_date.today)(timeZone));
   return new import_date.DateFormatter(locale, {
     weekday: "long",
     month: "long",

package/dist/get-day-formatter.mjs

@@ -1,6 +1,6 @@
 import {
   getDayFormatter
-} from "./chunk-ODG5YF5H.mjs";
+} from "./chunk-FJKH6IJZ.mjs";
 import "./chunk-KN3YMOSL.mjs";
 export {
   getDayFormatter

package/dist/get-end-of-week.d.ts

@@ -1,5 +1,6 @@
-import { CalendarDate } from '@internationalized/date';
+import * as _internationalized_date from '@internationalized/date';
+import { DateValue } from '@internationalized/date';
 
-declare function getEndOfWeek(date: CalendarDate, locale: string, firstDayOfWeek?: number): CalendarDate;
+declare function getEndOfWeek(date: DateValue, locale: string, firstDayOfWeek?: number): _internationalized_date.CalendarDate | _internationalized_date.CalendarDateTime | _internationalized_date.ZonedDateTime;
 
 export { getEndOfWeek };

package/dist/get-era-format.d.ts

@@ -1,5 +1,5 @@
-import { CalendarDate } from '@internationalized/date';
+import { DateValue } from '@internationalized/date';
 
-declare function getEraFormat(date: CalendarDate | undefined): "short" | undefined;
+declare function getEraFormat(date: DateValue | undefined): "short" | undefined;
 
 export { getEraFormat };

package/dist/get-month-days.d.ts

@@ -1,6 +1,6 @@
-import { CalendarDate } from '@internationalized/date';
+import { DateValue } from '@internationalized/date';
 
-declare function getDaysInWeek(weekIndex: number, from: CalendarDate, locale: string, firstDayOfWeek?: number): (CalendarDate | null)[];
-declare function getMonthDays(from: CalendarDate, locale: string, numOfWeeks?: number, firstDayOfWeek?: number): (CalendarDate | null)[][];
+declare function getDaysInWeek(weekIndex: number, from: DateValue, locale: string, firstDayOfWeek?: number): (DateValue | null)[];
+declare function getMonthDays(from: DateValue, locale: string, numOfWeeks?: number, firstDayOfWeek?: number): (DateValue | null)[][];
 
 export { getDaysInWeek, getMonthDays };

package/dist/get-month-days.js

@@ -52,9 +52,7 @@ function getDaysInWeek(weekIndex, from, locale, firstDayOfWeek) {
 function getMonthDays(from, locale, numOfWeeks, firstDayOfWeek) {
   const monthWeeks = (0, import_date2.getWeeksInMonth)(from, locale);
   const weeks = [...new Array(numOfWeeks ?? monthWeeks).keys()];
-  return weeks.map((week) => {
-    return getDaysInWeek(week, from, locale, firstDayOfWeek);
-  });
+  return weeks.map((week) => getDaysInWeek(week, from, locale, firstDayOfWeek));
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/get-month-days.mjs

@@ -1,7 +1,7 @@
 import {
   getDaysInWeek,
   getMonthDays
-} from "./chunk-KFJ757ZA.mjs";
+} from "./chunk-NV7UFBMY.mjs";
 import "./chunk-SI75FOJ2.mjs";
 export {
   getDaysInWeek,

package/dist/get-start-of-week.d.ts

@@ -1,5 +1,6 @@
-import { CalendarDate } from '@internationalized/date';
+import * as _internationalized_date from '@internationalized/date';
+import { DateValue } from '@internationalized/date';
 
-declare function getStartOfWeek(date: CalendarDate, locale: string, firstDayOfWeek?: number): CalendarDate;
+declare function getStartOfWeek(date: DateValue, locale: string, firstDayOfWeek?: number): _internationalized_date.CalendarDate | _internationalized_date.CalendarDateTime | _internationalized_date.ZonedDateTime;
 
 export { getStartOfWeek };

package/dist/get-week-days.d.ts

@@ -1,7 +1,8 @@
-import { CalendarDate } from '@internationalized/date';
+import * as _internationalized_date from '@internationalized/date';
+import { DateValue } from '@internationalized/date';
 
-declare function getWeekDays(date: CalendarDate, startOfWeekProp: number | undefined, timeZone: string, locale: string): {
-    value: CalendarDate;
+declare function getWeekDays(date: DateValue, startOfWeekProp: number | undefined, timeZone: string, locale: string): {
+    value: _internationalized_date.CalendarDate | _internationalized_date.CalendarDateTime | _internationalized_date.ZonedDateTime;
     short: string;
     long: string;
     narrow: string;

package/dist/get-weekday-formats.d.ts

@@ -1,6 +1,6 @@
-import { CalendarDate } from '@internationalized/date';
+import { DateValue } from '@internationalized/date';
 
-declare function getWeekdayFormats(locale: string, timeZone: string): <T extends CalendarDate | Date>(value: T) => {
+declare function getWeekdayFormats(locale: string, timeZone: string): <T extends DateValue | Date>(value: T) => {
     value: T;
     short: string;
     long: string;

package/dist/index.d.ts

@@ -1,8 +1,8 @@
 export { alignDate, alignStartDate } from './align.js';
 export { isDateDisabled, isDateEqual, isDateInvalid, isDateOutsideVisibleRange, isDateUnavailable, isNextVisibleRangeInvalid, isPreviousVisibleRangeInvalid, isTodayDate } from './assertion.js';
 export { alignCenter, alignEnd, alignStart, constrainStart, constrainValue } from './constrain.js';
-export { parseDateString } from './conversion.js';
 export { getEndDate, getUnitDuration } from './duration.js';
+export { formatDate } from './format-date.js';
 export { formatRange } from './format-range.js';
 export { formatSelectedDate } from './format-selected-date.js';
 export { formatVisibleRange } from './format-visible-range.js';
@@ -16,5 +16,6 @@ export { getWeekdayFormats } from './get-weekday-formats.js';
 export { YearsRange, getYearsRange } from './get-year-range.js';
 export { getNextDay, getPreviousAvailableDate, getPreviousDay, getTodayDate, setCalendar, setDate, setMonth, setYear } from './mutation.js';
 export { getAdjustedDateFn, getNextPage, getNextRow, getNextSection, getPreviousPage, getPreviousRow, getPreviousSection, getSectionEnd, getSectionStart } from './pagination.js';
+export { parseDateString } from './parse-date.js';
 export { DateAdjustFn, DateGranularity } from './types.js';
 import '@internationalized/date';