@zag-js/date-utils 1.34.0 → 1.35.0

package/dist/mutation.mjs

@@ -0,0 +1,39 @@
+// src/mutation.ts
+import {
+  getLocalTimeZone,
+  toCalendar,
+  toCalendarDateTime,
+  today
+} from "@internationalized/date";
+import { constrainValue } from "./constrain.mjs";
+function getTodayDate(timeZone, calendar) {
+  const tod = today(timeZone ?? getLocalTimeZone());
+  if (calendar) return toCalendar(tod, calendar);
+  return tod;
+}
+function setCalendar(date, calendar) {
+  return toCalendar(toCalendarDateTime(date), calendar);
+}
+function setDate(date, startDate, isDateUnavailable, locale, minValue, maxValue) {
+  let result;
+  result = constrainValue(date, minValue, maxValue);
+  result = getPreviousAvailableDate(date, startDate, locale, isDateUnavailable);
+  return result;
+}
+function getPreviousAvailableDate(date, minValue, locale, isDateUnavailable) {
+  if (!isDateUnavailable) {
+    return date;
+  }
+  while (date.compare(minValue) >= 0 && isDateUnavailable(date, locale)) {
+    date = date.subtract({ days: 1 });
+  }
+  if (date.compare(minValue) >= 0) {
+    return date;
+  }
+}
+export {
+  getPreviousAvailableDate,
+  getTodayDate,
+  setCalendar,
+  setDate
+};

package/dist/pagination.d.mts

@@ -0,0 +1,21 @@
+import { DateDuration } from '@internationalized/date';
+import { DateValue } from './types.mjs';
+
+interface AdjustDateParams {
+    startDate: DateValue;
+    focusedDate: DateValue;
+}
+interface AdjustDateReturn extends AdjustDateParams {
+    endDate: DateValue;
+}
+declare function getAdjustedDateFn(visibleDuration: DateDuration, locale: string, minValue?: DateValue, maxValue?: DateValue): (options: AdjustDateParams) => AdjustDateReturn;
+declare function getNextPage(focusedDate: DateValue, startDate: DateValue, visibleDuration: DateDuration, locale: string, minValue?: DateValue, maxValue?: DateValue): AdjustDateReturn;
+declare function getPreviousPage(focusedDate: DateValue, startDate: DateValue, visibleDuration: DateDuration, locale: string, minValue?: DateValue, maxValue?: DateValue): AdjustDateReturn;
+declare function getNextRow(focusedDate: DateValue, startDate: DateValue, visibleDuration: DateDuration, locale: string, minValue?: DateValue, maxValue?: DateValue): AdjustDateReturn | undefined;
+declare function getPreviousRow(focusedDate: DateValue, startDate: DateValue, visibleDuration: DateDuration, locale: string, minValue?: DateValue, maxValue?: DateValue): AdjustDateReturn | undefined;
+declare function getSectionStart(focusedDate: DateValue, startDate: DateValue, visibleDuration: DateDuration, locale: string, minValue?: DateValue, maxValue?: DateValue): AdjustDateReturn | undefined;
+declare function getSectionEnd(focusedDate: DateValue, startDate: DateValue, visibleDuration: DateDuration, locale: string, minValue?: DateValue, maxValue?: DateValue): AdjustDateReturn | undefined;
+declare function getNextSection(focusedDate: DateValue, startDate: DateValue, larger: boolean, visibleDuration: DateDuration, locale: string, minValue?: DateValue, maxValue?: DateValue): AdjustDateReturn | undefined;
+declare function getPreviousSection(focusedDate: DateValue, startDate: DateValue, larger: boolean, visibleDuration: DateDuration, locale: string, minValue?: DateValue, maxValue?: DateValue): AdjustDateReturn | undefined;
+
+export { type AdjustDateParams, type AdjustDateReturn, getAdjustedDateFn, getNextPage, getNextRow, getNextSection, getPreviousPage, getPreviousRow, getPreviousSection, getSectionEnd, getSectionStart };

package/dist/pagination.d.ts

@@ -0,0 +1,21 @@
+import { DateDuration } from '@internationalized/date';
+import { DateValue } from './types.js';
+
+interface AdjustDateParams {
+    startDate: DateValue;
+    focusedDate: DateValue;
+}
+interface AdjustDateReturn extends AdjustDateParams {
+    endDate: DateValue;
+}
+declare function getAdjustedDateFn(visibleDuration: DateDuration, locale: string, minValue?: DateValue, maxValue?: DateValue): (options: AdjustDateParams) => AdjustDateReturn;
+declare function getNextPage(focusedDate: DateValue, startDate: DateValue, visibleDuration: DateDuration, locale: string, minValue?: DateValue, maxValue?: DateValue): AdjustDateReturn;
+declare function getPreviousPage(focusedDate: DateValue, startDate: DateValue, visibleDuration: DateDuration, locale: string, minValue?: DateValue, maxValue?: DateValue): AdjustDateReturn;
+declare function getNextRow(focusedDate: DateValue, startDate: DateValue, visibleDuration: DateDuration, locale: string, minValue?: DateValue, maxValue?: DateValue): AdjustDateReturn | undefined;
+declare function getPreviousRow(focusedDate: DateValue, startDate: DateValue, visibleDuration: DateDuration, locale: string, minValue?: DateValue, maxValue?: DateValue): AdjustDateReturn | undefined;
+declare function getSectionStart(focusedDate: DateValue, startDate: DateValue, visibleDuration: DateDuration, locale: string, minValue?: DateValue, maxValue?: DateValue): AdjustDateReturn | undefined;
+declare function getSectionEnd(focusedDate: DateValue, startDate: DateValue, visibleDuration: DateDuration, locale: string, minValue?: DateValue, maxValue?: DateValue): AdjustDateReturn | undefined;
+declare function getNextSection(focusedDate: DateValue, startDate: DateValue, larger: boolean, visibleDuration: DateDuration, locale: string, minValue?: DateValue, maxValue?: DateValue): AdjustDateReturn | undefined;
+declare function getPreviousSection(focusedDate: DateValue, startDate: DateValue, larger: boolean, visibleDuration: DateDuration, locale: string, minValue?: DateValue, maxValue?: DateValue): AdjustDateReturn | undefined;
+
+export { type AdjustDateParams, type AdjustDateReturn, getAdjustedDateFn, getNextPage, getNextRow, getNextSection, getPreviousPage, getPreviousRow, getPreviousSection, getSectionEnd, getSectionStart };

package/dist/pagination.js

@@ -0,0 +1,220 @@
+"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/pagination.ts
+var pagination_exports = {};
+__export(pagination_exports, {
+  getAdjustedDateFn: () => getAdjustedDateFn,
+  getNextPage: () => getNextPage,
+  getNextRow: () => getNextRow,
+  getNextSection: () => getNextSection,
+  getPreviousPage: () => getPreviousPage,
+  getPreviousRow: () => getPreviousRow,
+  getPreviousSection: () => getPreviousSection,
+  getSectionEnd: () => getSectionEnd,
+  getSectionStart: () => getSectionStart
+});
+module.exports = __toCommonJS(pagination_exports);
+var import_date = require("@internationalized/date");
+var import_assertion = require("./assertion.cjs");
+var import_constrain = require("./constrain.cjs");
+var import_duration = require("./duration.cjs");
+function getAdjustedDateFn(visibleDuration, locale, minValue, maxValue) {
+  return function getDate(options) {
+    const { startDate, focusedDate } = options;
+    const endDate = (0, import_duration.getEndDate)(startDate, visibleDuration);
+    if ((0, import_assertion.isDateOutsideRange)(focusedDate, minValue, maxValue)) {
+      return {
+        startDate,
+        focusedDate: (0, import_constrain.constrainValue)(focusedDate, minValue, maxValue),
+        endDate
+      };
+    }
+    if (focusedDate.compare(startDate) < 0) {
+      return {
+        startDate: (0, import_constrain.alignEnd)(focusedDate, visibleDuration, locale, minValue, maxValue),
+        focusedDate: (0, import_constrain.constrainValue)(focusedDate, minValue, maxValue),
+        endDate
+      };
+    }
+    if (focusedDate.compare(endDate) > 0) {
+      return {
+        startDate: (0, import_constrain.alignStart)(focusedDate, visibleDuration, locale, minValue, maxValue),
+        endDate,
+        focusedDate: (0, import_constrain.constrainValue)(focusedDate, minValue, maxValue)
+      };
+    }
+    return {
+      startDate,
+      endDate,
+      focusedDate: (0, import_constrain.constrainValue)(focusedDate, minValue, maxValue)
+    };
+  };
+}
+function getNextPage(focusedDate, startDate, visibleDuration, locale, minValue, maxValue) {
+  const adjust = getAdjustedDateFn(visibleDuration, locale, minValue, maxValue);
+  const start = startDate.add(visibleDuration);
+  return adjust({
+    focusedDate: focusedDate.add(visibleDuration),
+    startDate: (0, import_constrain.alignStart)(
+      (0, import_constrain.constrainStart)(focusedDate, start, visibleDuration, locale, minValue, maxValue),
+      visibleDuration,
+      locale
+    )
+  });
+}
+function getPreviousPage(focusedDate, startDate, visibleDuration, locale, minValue, maxValue) {
+  const adjust = getAdjustedDateFn(visibleDuration, locale, minValue, maxValue);
+  let start = startDate.subtract(visibleDuration);
+  return adjust({
+    focusedDate: focusedDate.subtract(visibleDuration),
+    startDate: (0, import_constrain.alignStart)(
+      (0, import_constrain.constrainStart)(focusedDate, start, visibleDuration, locale, minValue, maxValue),
+      visibleDuration,
+      locale
+    )
+  });
+}
+function getNextRow(focusedDate, startDate, visibleDuration, locale, minValue, maxValue) {
+  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
+    });
+  }
+}
+function getPreviousRow(focusedDate, startDate, visibleDuration, locale, minValue, maxValue) {
+  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
+    });
+  }
+}
+function getSectionStart(focusedDate, startDate, visibleDuration, locale, minValue, maxValue) {
+  const adjust = getAdjustedDateFn(visibleDuration, locale, minValue, maxValue);
+  if (visibleDuration.days) {
+    return adjust({
+      focusedDate: startDate,
+      startDate
+    });
+  }
+  if (visibleDuration.weeks) {
+    return adjust({
+      focusedDate: (0, import_date.startOfWeek)(focusedDate, locale),
+      startDate
+    });
+  }
+  if (visibleDuration.months || visibleDuration.years) {
+    return adjust({
+      focusedDate: (0, import_date.startOfMonth)(focusedDate),
+      startDate
+    });
+  }
+}
+function getSectionEnd(focusedDate, startDate, visibleDuration, locale, minValue, maxValue) {
+  const adjust = getAdjustedDateFn(visibleDuration, locale, minValue, maxValue);
+  const endDate = (0, import_duration.getEndDate)(startDate, visibleDuration);
+  if (visibleDuration.days) {
+    return adjust({
+      focusedDate: endDate,
+      startDate
+    });
+  }
+  if (visibleDuration.weeks) {
+    return adjust({
+      focusedDate: (0, import_date.endOfWeek)(focusedDate, locale),
+      startDate
+    });
+  }
+  if (visibleDuration.months || visibleDuration.years) {
+    return adjust({
+      focusedDate: (0, import_date.endOfMonth)(focusedDate),
+      startDate
+    });
+  }
+}
+function getNextSection(focusedDate, startDate, larger, visibleDuration, locale, minValue, maxValue) {
+  const adjust = getAdjustedDateFn(visibleDuration, locale, minValue, maxValue);
+  if (!larger && !visibleDuration.days) {
+    return adjust({
+      focusedDate: focusedDate.add((0, import_duration.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
+    });
+  }
+}
+function getPreviousSection(focusedDate, startDate, larger, visibleDuration, locale, minValue, maxValue) {
+  const adjust = getAdjustedDateFn(visibleDuration, locale, minValue, maxValue);
+  if (!larger && !visibleDuration.days) {
+    return adjust({
+      focusedDate: focusedDate.subtract((0, import_duration.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
+    });
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getAdjustedDateFn,
+  getNextPage,
+  getNextRow,
+  getNextSection,
+  getPreviousPage,
+  getPreviousRow,
+  getPreviousSection,
+  getSectionEnd,
+  getSectionStart
+});

package/dist/pagination.mjs

@@ -0,0 +1,187 @@
+// src/pagination.ts
+import { endOfMonth, endOfWeek, startOfMonth, startOfWeek } from "@internationalized/date";
+import { isDateOutsideRange } from "./assertion.mjs";
+import { alignEnd, alignStart, constrainStart, constrainValue } from "./constrain.mjs";
+import { getEndDate, getUnitDuration } from "./duration.mjs";
+function getAdjustedDateFn(visibleDuration, locale, minValue, maxValue) {
+  return function getDate(options) {
+    const { startDate, focusedDate } = options;
+    const endDate = getEndDate(startDate, visibleDuration);
+    if (isDateOutsideRange(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)
+    };
+  };
+}
+function getNextPage(focusedDate, startDate, visibleDuration, locale, minValue, maxValue) {
+  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
+    )
+  });
+}
+function getPreviousPage(focusedDate, startDate, visibleDuration, locale, minValue, maxValue) {
+  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
+    )
+  });
+}
+function getNextRow(focusedDate, startDate, visibleDuration, locale, minValue, maxValue) {
+  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
+    });
+  }
+}
+function getPreviousRow(focusedDate, startDate, visibleDuration, locale, minValue, maxValue) {
+  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
+    });
+  }
+}
+function getSectionStart(focusedDate, startDate, visibleDuration, locale, minValue, maxValue) {
+  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
+    });
+  }
+}
+function getSectionEnd(focusedDate, startDate, visibleDuration, locale, minValue, maxValue) {
+  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({
+      focusedDate: endOfWeek(focusedDate, locale),
+      startDate
+    });
+  }
+  if (visibleDuration.months || visibleDuration.years) {
+    return adjust({
+      focusedDate: endOfMonth(focusedDate),
+      startDate
+    });
+  }
+}
+function getNextSection(focusedDate, startDate, larger, visibleDuration, locale, minValue, maxValue) {
+  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
+    });
+  }
+}
+function getPreviousSection(focusedDate, startDate, larger, visibleDuration, locale, minValue, maxValue) {
+  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
+    });
+  }
+}
+export {
+  getAdjustedDateFn,
+  getNextPage,
+  getNextRow,
+  getNextSection,
+  getPreviousPage,
+  getPreviousRow,
+  getPreviousSection,
+  getSectionEnd,
+  getSectionStart
+};

package/dist/parse-date.d.mts

@@ -0,0 +1,6 @@
+import { DateValue } from './types.mjs';
+import '@internationalized/date';
+
+declare function parseDateString(date: string, locale: string, timeZone: string): DateValue | undefined;
+
+export { parseDateString };

package/dist/parse-date.d.ts

@@ -0,0 +1,6 @@
+import { DateValue } from './types.js';
+import '@internationalized/date';
+
+declare function parseDateString(date: string, locale: string, timeZone: string): DateValue | undefined;
+
+export { parseDateString };

package/dist/parse-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/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");
+var import_date_year = require("./date-year.cjs");
+var isValidYear = (year) => year != null && year.length === 4;
+var isValidMonth = (month) => month != null && parseFloat(month) <= 12;
+var isValidDay = (day) => day != null && parseFloat(day) <= 31;
+function parseDateString(date, locale, timeZone) {
+  const regex = createRegex(locale, timeZone);
+  let { year, month, day } = extract(regex, date) ?? {};
+  const hasMatch = year != null || month != null || day != null;
+  if (hasMatch) {
+    const curr = /* @__PURE__ */ new Date();
+    year || (year = curr.getFullYear().toString());
+    month || (month = (curr.getMonth() + 1).toString());
+    day || (day = curr.getDate().toString());
+  }
+  if (!isValidYear(year)) {
+    year = (0, import_date_year.normalizeYear)(year);
+  }
+  if (isValidYear(year) && isValidMonth(month) && isValidDay(day)) {
+    return new import_date.CalendarDate(+year, +month, +day);
+  }
+  const time = Date.parse(date);
+  if (!isNaN(time)) {
+    const date2 = new Date(time);
+    return new import_date.CalendarDate(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/parse-date.mjs

@@ -0,0 +1,54 @@
+// src/parse-date.ts
+import { CalendarDate, DateFormatter } from "@internationalized/date";
+import { normalizeYear } from "./date-year.mjs";
+var isValidYear = (year) => year != null && year.length === 4;
+var isValidMonth = (month) => month != null && parseFloat(month) <= 12;
+var isValidDay = (day) => day != null && parseFloat(day) <= 31;
+function parseDateString(date, locale, timeZone) {
+  const regex = createRegex(locale, timeZone);
+  let { year, month, day } = extract(regex, date) ?? {};
+  const hasMatch = year != null || month != null || day != null;
+  if (hasMatch) {
+    const curr = /* @__PURE__ */ new Date();
+    year || (year = curr.getFullYear().toString());
+    month || (month = (curr.getMonth() + 1).toString());
+    day || (day = curr.getDate().toString());
+  }
+  if (!isValidYear(year)) {
+    year = normalizeYear(year);
+  }
+  if (isValidYear(year) && isValidMonth(month) && isValidDay(day)) {
+    return new CalendarDate(+year, +month, +day);
+  }
+  const time = Date.parse(date);
+  if (!isNaN(time)) {
+    const date2 = new Date(time);
+    return new CalendarDate(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/preset.d.mts

@@ -0,0 +1,6 @@
+import { DateValue } from '@internationalized/date';
+import { DateRangePreset } from './types.mjs';
+
+declare function getDateRangePreset(preset: DateRangePreset, locale: string, timeZone: string): [DateValue, DateValue];
+
+export { getDateRangePreset };

package/dist/preset.d.ts

@@ -0,0 +1,6 @@
+import { DateValue } from '@internationalized/date';
+import { DateRangePreset } from './types.js';
+
+declare function getDateRangePreset(preset: DateRangePreset, locale: string, timeZone: string): [DateValue, DateValue];
+
+export { getDateRangePreset };