@zag-js/date-utils 0.1.3 → 0.5.0

package/dist/index.js

@@ -27,6 +27,7 @@ __export(src_exports, {
   alignStartDate: () => alignStartDate,
   constrainStart: () => constrainStart,
   constrainValue: () => constrainValue,
+  formatDate: () => formatDate,
   formatRange: () => formatRange,
   formatSelectedDate: () => formatSelectedDate,
   formatVisibleRange: () => formatVisibleRange,
@@ -163,11 +164,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);
@@ -184,20 +185,6 @@ function isNextVisibleRangeInvalid(endDate, minValue, maxValue) {
   return (0, import_date2.isSameDay)(nextDate, endDate) || isDateInvalid(nextDate, minValue, maxValue);
 }
 
-// src/conversion.ts
-var import_date3 = require("@internationalized/date");
-function parseDateString(value) {
-  try {
-    const date = new Date(value);
-    date.setMinutes(1e3);
-    if (isNaN(date.getTime()))
-      return;
-    const [dateWithoutTime] = date.toISOString().split("T");
-    return (0, import_date3.parseDate)(dateWithoutTime);
-  } catch {
-  }
-}
-
 // src/duration.ts
 function getUnitDuration(duration) {
   let d = { ...duration };
@@ -216,6 +203,58 @@ function getEndDate(startDate, duration) {
   return startDate.add(d);
 }
 
+// src/format-date.ts
+var import_date3 = 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_date3.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;
+}
+
 // src/format-range.ts
 function formatRange(startDate, endDate, formatter, toString, timeZone) {
   let parts = formatter.formatRangeToParts(startDate.toDate(timeZone), endDate.toDate(timeZone));
@@ -253,7 +292,7 @@ function getEraFormat(date) {
 
 // src/get-day-formatter.ts
 function getDayFormatter(locale, timeZone) {
-  const date = (0, import_date4.toCalendarDate)((0, import_date4.today)(timeZone));
+  const date = (0, import_date4.toCalendarDateTime)((0, import_date4.today)(timeZone));
   return new import_date4.DateFormatter(locale, {
     weekday: "long",
     month: "long",
@@ -349,9 +388,7 @@ function getDaysInWeek(weekIndex, from, locale, firstDayOfWeek) {
 function getMonthDays(from, locale, numOfWeeks, firstDayOfWeek) {
   const monthWeeks = (0, import_date9.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));
 }
 
 // src/get-month-names.ts
@@ -401,8 +438,8 @@ function getYearsRange(range) {
 
 // src/mutation.ts
 var import_date11 = require("@internationalized/date");
-function getTodayDate(timezone) {
-  return (0, import_date11.today)(timezone);
+function getTodayDate(timeZone) {
+  return (0, import_date11.today)(timeZone ?? (0, import_date11.getLocalTimeZone)());
 }
 function getNextDay(date) {
   return date.add({ days: 1 });
@@ -417,19 +454,19 @@ function setYear(date, year) {
   return date.set({ year });
 }
 function setCalendar(date, calendar) {
-  return (0, import_date11.toCalendar)((0, import_date11.toCalendarDate)(date), calendar);
+  return (0, import_date11.toCalendar)((0, import_date11.toCalendarDateTime)(date), calendar);
 }
-function setDate(date, startDate, isDateUnavailable2, minValue, maxValue) {
+function setDate(date, startDate, isDateUnavailable2, locale, minValue, maxValue) {
   let result;
   result = constrainValue(date, minValue, maxValue);
-  result = getPreviousAvailableDate(date, startDate, isDateUnavailable2);
+  result = getPreviousAvailableDate(date, startDate, locale, isDateUnavailable2);
   return result;
 }
-function getPreviousAvailableDate(date, minValue, isDateUnavailable2) {
+function getPreviousAvailableDate(date, minValue, locale, isDateUnavailable2) {
   if (!isDateUnavailable2) {
     return date;
   }
-  while (date.compare(minValue) >= 0 && isDateUnavailable2(date)) {
+  while (date.compare(minValue) >= 0 && isDateUnavailable2(date, locale)) {
     date = date.subtract({ days: 1 });
   }
   if (date.compare(minValue) >= 0) {
@@ -551,6 +588,7 @@ function getSectionEnd(focusedDate, startDate, visibleDuration, locale, minValue
   }
   if (visibleDuration.weeks) {
     return adjust({
+      //@ts-expect-error - endOfWeek is loosely typed
       focusedDate: (0, import_date12.endOfWeek)(focusedDate, locale),
       startDate
     });
@@ -610,6 +648,45 @@ function getPreviousSection(focusedDate, startDate, larger, visibleDuration, loc
     });
   }
 }
+
+// src/parse-date.ts
+var import_date13 = require("@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 import_date13.CalendarDateTime(+year, +month, +day);
+  }
+  const time = Date.parse(date);
+  if (!isNaN(time)) {
+    const date2 = new Date(time);
+    return new import_date13.CalendarDateTime(date2.getFullYear(), date2.getMonth() + 1, date2.getDate());
+  }
+}
+function createRegex(locale, timeZone) {
+  const formatter = new import_date13.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;
+  }, {});
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   alignCenter,
@@ -619,6 +696,7 @@ function getPreviousSection(focusedDate, startDate, larger, visibleDuration, loc
   alignStartDate,
   constrainStart,
   constrainValue,
+  formatDate,
   formatRange,
   formatSelectedDate,
   formatVisibleRange,

package/dist/index.mjs

@@ -16,7 +16,7 @@ import {
   setDate,
   setMonth,
   setYear
-} from "./chunk-ZZPZ2BFS.mjs";
+} from "./chunk-6FNTXW54.mjs";
 import {
   getAdjustedDateFn,
   getNextPage,
@@ -27,14 +27,17 @@ import {
   getPreviousSection,
   getSectionEnd,
   getSectionStart
-} from "./chunk-VTFZA34K.mjs";
+} from "./chunk-POBWDZPE.mjs";
+import {
+  parseDateString
+} from "./chunk-WQYMLJUJ.mjs";
 import {
   getDecadeRange
 } from "./chunk-G4VVKINZ.mjs";
 import {
   getDaysInWeek,
   getMonthDays
-} from "./chunk-KFJ757ZA.mjs";
+} from "./chunk-NV7UFBMY.mjs";
 import {
   getMonthNames
 } from "./chunk-5HGHDJ3L.mjs";
@@ -52,7 +55,7 @@ import {
   isNextVisibleRangeInvalid,
   isPreviousVisibleRangeInvalid,
   isTodayDate
-} from "./chunk-H4CAPQVS.mjs";
+} from "./chunk-HLAN6TUA.mjs";
 import {
   alignCenter,
   alignEnd,
@@ -60,28 +63,28 @@ import {
   constrainStart,
   constrainValue
 } from "./chunk-MGPXEJO4.mjs";
-import {
-  parseDateString
-} from "./chunk-UHOBXAHP.mjs";
 import {
   getEndDate,
   getUnitDuration
 } from "./chunk-ZSLC7OI2.mjs";
+import {
+  formatDate
+} from "./chunk-KBGJA6NB.mjs";
 import {
   formatSelectedDate
-} from "./chunk-LQAXQPWP.mjs";
+} from "./chunk-6LXTZHZP.mjs";
 import {
   formatRange
 } from "./chunk-HKHGJ6WS.mjs";
 import {
   formatVisibleRange
-} from "./chunk-CAYCTIEJ.mjs";
+} from "./chunk-KQVWH4YA.mjs";
 import {
   getMonthFormatter
 } from "./chunk-LGEGBP3O.mjs";
 import {
   getDayFormatter
-} from "./chunk-ODG5YF5H.mjs";
+} from "./chunk-FJKH6IJZ.mjs";
 import "./chunk-KN3YMOSL.mjs";
 export {
   alignCenter,
@@ -91,6 +94,7 @@ export {
   alignStartDate,
   constrainStart,
   constrainValue,
+  formatDate,
   formatRange,
   formatSelectedDate,
   formatVisibleRange,

package/dist/mutation.d.ts

@@ -1,13 +1,14 @@
-import { CalendarDate, Calendar, DateValue } from '@internationalized/date';
+import * as _internationalized_date from '@internationalized/date';
+import { DateValue, Calendar } from '@internationalized/date';
 import { DateAvailableFn } from './types.js';
 
-declare function getTodayDate(timezone: string): CalendarDate;
-declare function getNextDay(date: CalendarDate): CalendarDate;
-declare function getPreviousDay(date: CalendarDate): CalendarDate;
-declare function setMonth(date: CalendarDate, month: number): CalendarDate;
-declare function setYear(date: CalendarDate, year: number): CalendarDate;
-declare function setCalendar(date: CalendarDate, calendar: Calendar): CalendarDate;
-declare function setDate(date: CalendarDate, startDate: CalendarDate, isDateUnavailable: DateAvailableFn, minValue: CalendarDate, maxValue: CalendarDate): CalendarDate | undefined;
-declare function getPreviousAvailableDate(date: CalendarDate, minValue: DateValue, isDateUnavailable?: DateAvailableFn): CalendarDate | undefined;
+declare function getTodayDate(timeZone?: string): _internationalized_date.CalendarDate;
+declare function getNextDay(date: DateValue): _internationalized_date.CalendarDate | _internationalized_date.CalendarDateTime | _internationalized_date.ZonedDateTime;
+declare function getPreviousDay(date: DateValue): _internationalized_date.CalendarDate | _internationalized_date.CalendarDateTime | _internationalized_date.ZonedDateTime;
+declare function setMonth(date: DateValue, month: number): _internationalized_date.CalendarDate | _internationalized_date.CalendarDateTime | _internationalized_date.ZonedDateTime;
+declare function setYear(date: DateValue, year: number): _internationalized_date.CalendarDate | _internationalized_date.CalendarDateTime | _internationalized_date.ZonedDateTime;
+declare function setCalendar(date: DateValue, calendar: Calendar): _internationalized_date.CalendarDateTime;
+declare function setDate(date: DateValue, startDate: DateValue, isDateUnavailable: DateAvailableFn, locale: string, minValue: DateValue, maxValue: DateValue): DateValue | undefined;
+declare function getPreviousAvailableDate(date: DateValue, minValue: DateValue, locale: string, isDateUnavailable?: DateAvailableFn): DateValue | undefined;
 
 export { getNextDay, getPreviousAvailableDate, getPreviousDay, getTodayDate, setCalendar, setDate, setMonth, setYear };

package/dist/mutation.js

@@ -45,8 +45,8 @@ function constrainValue(date, minValue, maxValue) {
 }
 
 // src/mutation.ts
-function getTodayDate(timezone) {
-  return (0, import_date2.today)(timezone);
+function getTodayDate(timeZone) {
+  return (0, import_date2.today)(timeZone ?? (0, import_date2.getLocalTimeZone)());
 }
 function getNextDay(date) {
   return date.add({ days: 1 });
@@ -61,19 +61,19 @@ function setYear(date, year) {
   return date.set({ year });
 }
 function setCalendar(date, calendar) {
-  return (0, import_date2.toCalendar)((0, import_date2.toCalendarDate)(date), calendar);
+  return (0, import_date2.toCalendar)((0, import_date2.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/mutation.mjs

@@ -7,7 +7,7 @@ import {
   setDate,
   setMonth,
   setYear
-} from "./chunk-ZZPZ2BFS.mjs";
+} from "./chunk-6FNTXW54.mjs";
 import "./chunk-MGPXEJO4.mjs";
 export {
   getNextDay,

package/dist/pagination.d.ts

@@ -1,52 +1,53 @@
-import { DateDuration, CalendarDate } from '@internationalized/date';
+import * as _internationalized_date from '@internationalized/date';
+import { DateDuration, DateValue } from '@internationalized/date';
 
-declare function getAdjustedDateFn(visibleDuration: DateDuration, locale: string, minValue?: CalendarDate, maxValue?: CalendarDate): (options: {
-    startDate: CalendarDate;
-    focusedDate: CalendarDate;
+declare function getAdjustedDateFn(visibleDuration: DateDuration, locale: string, minValue?: DateValue, maxValue?: DateValue): (options: {
+    startDate: DateValue;
+    focusedDate: DateValue;
 }) => {
-    startDate: CalendarDate;
-    focusedDate: CalendarDate;
-    endDate: CalendarDate;
+    startDate: DateValue;
+    focusedDate: DateValue;
+    endDate: _internationalized_date.CalendarDate | _internationalized_date.CalendarDateTime | _internationalized_date.ZonedDateTime;
 };
-declare function getNextPage(focusedDate: CalendarDate, startDate: CalendarDate, visibleDuration: DateDuration, locale: string, minValue?: CalendarDate, maxValue?: CalendarDate): {
-    startDate: CalendarDate;
-    focusedDate: CalendarDate;
-    endDate: CalendarDate;
+declare function getNextPage(focusedDate: DateValue, startDate: DateValue, visibleDuration: DateDuration, locale: string, minValue?: DateValue, maxValue?: DateValue): {
+    startDate: DateValue;
+    focusedDate: DateValue;
+    endDate: _internationalized_date.CalendarDate | _internationalized_date.CalendarDateTime | _internationalized_date.ZonedDateTime;
 };
-declare function getPreviousPage(focusedDate: CalendarDate, startDate: CalendarDate, visibleDuration: DateDuration, locale: string, minValue?: CalendarDate, maxValue?: CalendarDate): {
-    startDate: CalendarDate;
-    focusedDate: CalendarDate;
-    endDate: CalendarDate;
+declare function getPreviousPage(focusedDate: DateValue, startDate: DateValue, visibleDuration: DateDuration, locale: string, minValue?: DateValue, maxValue?: DateValue): {
+    startDate: DateValue;
+    focusedDate: DateValue;
+    endDate: _internationalized_date.CalendarDate | _internationalized_date.CalendarDateTime | _internationalized_date.ZonedDateTime;
 };
-declare function getNextRow(focusedDate: CalendarDate, startDate: CalendarDate, visibleDuration: DateDuration, locale: string, minValue?: CalendarDate, maxValue?: CalendarDate): {
-    startDate: CalendarDate;
-    focusedDate: CalendarDate;
-    endDate: CalendarDate;
+declare function getNextRow(focusedDate: DateValue, startDate: DateValue, visibleDuration: DateDuration, locale: string, minValue?: DateValue, maxValue?: DateValue): {
+    startDate: DateValue;
+    focusedDate: DateValue;
+    endDate: _internationalized_date.CalendarDate | _internationalized_date.CalendarDateTime | _internationalized_date.ZonedDateTime;
 } | undefined;
-declare function getPreviousRow(focusedDate: CalendarDate, startDate: CalendarDate, visibleDuration: DateDuration, locale: string, minValue?: CalendarDate, maxValue?: CalendarDate): {
-    startDate: CalendarDate;
-    focusedDate: CalendarDate;
-    endDate: CalendarDate;
+declare function getPreviousRow(focusedDate: DateValue, startDate: DateValue, visibleDuration: DateDuration, locale: string, minValue?: DateValue, maxValue?: DateValue): {
+    startDate: DateValue;
+    focusedDate: DateValue;
+    endDate: _internationalized_date.CalendarDate | _internationalized_date.CalendarDateTime | _internationalized_date.ZonedDateTime;
 } | undefined;
-declare function getSectionStart(focusedDate: CalendarDate, startDate: CalendarDate, visibleDuration: DateDuration, locale: string, minValue?: CalendarDate, maxValue?: CalendarDate): {
-    startDate: CalendarDate;
-    focusedDate: CalendarDate;
-    endDate: CalendarDate;
+declare function getSectionStart(focusedDate: DateValue, startDate: DateValue, visibleDuration: DateDuration, locale: string, minValue?: DateValue, maxValue?: DateValue): {
+    startDate: DateValue;
+    focusedDate: DateValue;
+    endDate: _internationalized_date.CalendarDate | _internationalized_date.CalendarDateTime | _internationalized_date.ZonedDateTime;
 } | undefined;
-declare function getSectionEnd(focusedDate: CalendarDate, startDate: CalendarDate, visibleDuration: DateDuration, locale: string, minValue?: CalendarDate, maxValue?: CalendarDate): {
-    startDate: CalendarDate;
-    focusedDate: CalendarDate;
-    endDate: CalendarDate;
+declare function getSectionEnd(focusedDate: DateValue, startDate: DateValue, visibleDuration: DateDuration, locale: string, minValue?: DateValue, maxValue?: DateValue): {
+    startDate: DateValue;
+    focusedDate: DateValue;
+    endDate: _internationalized_date.CalendarDate | _internationalized_date.CalendarDateTime | _internationalized_date.ZonedDateTime;
 } | undefined;
-declare function getNextSection(focusedDate: CalendarDate, startDate: CalendarDate, larger: boolean, visibleDuration: DateDuration, locale: string, minValue?: CalendarDate, maxValue?: CalendarDate): {
-    startDate: CalendarDate;
-    focusedDate: CalendarDate;
-    endDate: CalendarDate;
+declare function getNextSection(focusedDate: DateValue, startDate: DateValue, larger: boolean, visibleDuration: DateDuration, locale: string, minValue?: DateValue, maxValue?: DateValue): {
+    startDate: DateValue;
+    focusedDate: DateValue;
+    endDate: _internationalized_date.CalendarDate | _internationalized_date.CalendarDateTime | _internationalized_date.ZonedDateTime;
 } | undefined;
-declare function getPreviousSection(focusedDate: CalendarDate, startDate: CalendarDate, larger: boolean, visibleDuration: DateDuration, locale: string, minValue?: CalendarDate, maxValue?: CalendarDate): {
-    startDate: CalendarDate;
-    focusedDate: CalendarDate;
-    endDate: CalendarDate;
+declare function getPreviousSection(focusedDate: DateValue, startDate: DateValue, larger: boolean, visibleDuration: DateDuration, locale: string, minValue?: DateValue, maxValue?: DateValue): {
+    startDate: DateValue;
+    focusedDate: DateValue;
+    endDate: _internationalized_date.CalendarDate | _internationalized_date.CalendarDateTime | _internationalized_date.ZonedDateTime;
 } | undefined;
 
 export { getAdjustedDateFn, getNextPage, getNextRow, getNextSection, getPreviousPage, getPreviousRow, getPreviousSection, getSectionEnd, getSectionStart };

package/dist/pagination.js

@@ -216,6 +216,7 @@ function getSectionEnd(focusedDate, startDate, visibleDuration, locale, minValue
   }
   if (visibleDuration.weeks) {
     return adjust({
+      //@ts-expect-error - endOfWeek is loosely typed
       focusedDate: (0, import_date3.endOfWeek)(focusedDate, locale),
       startDate
     });

package/dist/pagination.mjs

@@ -8,8 +8,8 @@ import {
   getPreviousSection,
   getSectionEnd,
   getSectionStart
-} from "./chunk-VTFZA34K.mjs";
-import "./chunk-H4CAPQVS.mjs";
+} from "./chunk-POBWDZPE.mjs";
+import "./chunk-HLAN6TUA.mjs";
 import "./chunk-MGPXEJO4.mjs";
 import "./chunk-ZSLC7OI2.mjs";
 export {

package/dist/parse-date.d.ts

@@ -0,0 +1,5 @@
+import { CalendarDateTime } from '@internationalized/date';
+
+declare function parseDateString(date: string, locale: string, timeZone: string): CalendarDateTime | undefined;
+
+export { parseDateString };

package/dist/parse-date.js

@@ -0,0 +1,66 @@
+"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/parse-date.ts
+var parse_date_exports = {};
+__export(parse_date_exports, {
+  parseDateString: () => parseDateString
+});
+module.exports = __toCommonJS(parse_date_exports);
+var import_date = require("@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 import_date.CalendarDateTime(+year, +month, +day);
+  }
+  const time = Date.parse(date);
+  if (!isNaN(time)) {
+    const date2 = new Date(time);
+    return new import_date.CalendarDateTime(date2.getFullYear(), date2.getMonth() + 1, date2.getDate());
+  }
+}
+function createRegex(locale, timeZone) {
+  const formatter = new import_date.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;
+  }, {});
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  parseDateString
+});

package/dist/{conversion.mjs → parse-date.mjs}

@@ -1,6 +1,6 @@
 import {
   parseDateString
-} from "./chunk-UHOBXAHP.mjs";
+} from "./chunk-WQYMLJUJ.mjs";
 export {
   parseDateString
 };

package/dist/types.d.ts

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zag-js/date-utils",
-  "version": "0.1.3",
+  "version": "0.5.0",
   "description": "Date utilities for zag.js",
   "keywords": [
     "js",

package/dist/chunk-UHOBXAHP.mjs

@@ -1,17 +0,0 @@
-// src/conversion.ts
-import { parseDate } from "@internationalized/date";
-function parseDateString(value) {
-  try {
-    const date = new Date(value);
-    date.setMinutes(1e3);
-    if (isNaN(date.getTime()))
-      return;
-    const [dateWithoutTime] = date.toISOString().split("T");
-    return parseDate(dateWithoutTime);
-  } catch {
-  }
-}
-
-export {
-  parseDateString
-};

package/dist/conversion.d.ts

@@ -1,5 +0,0 @@
-import * as _internationalized_date from '@internationalized/date';
-
-declare function parseDateString(value: string): _internationalized_date.CalendarDate | undefined;
-
-export { parseDateString };