@zag-js/date-utils 0.1.2 → 0.1.4

package/dist/index.js

@@ -20,8 +20,6 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
-  SEGMENT_PAGE_STEP: () => SEGMENT_PAGE_STEP,
-  addSegment: () => addSegment,
   alignCenter: () => alignCenter,
   alignDate: () => alignDate,
   alignEnd: () => alignEnd,
@@ -29,15 +27,18 @@ __export(src_exports, {
   alignStartDate: () => alignStartDate,
   constrainStart: () => constrainStart,
   constrainValue: () => constrainValue,
-  createPlaceholderDate: () => createPlaceholderDate,
+  formatDate: () => formatDate,
   formatRange: () => formatRange,
   formatSelectedDate: () => formatSelectedDate,
   formatVisibleRange: () => formatVisibleRange,
   getAdjustedDateFn: () => getAdjustedDateFn,
-  getAllSegments: () => getAllSegments,
-  getDatesInWeek: () => getDatesInWeek,
+  getDayFormatter: () => getDayFormatter,
+  getDaysInWeek: () => getDaysInWeek,
+  getDecadeRange: () => getDecadeRange,
   getEndDate: () => getEndDate,
-  getMonthDates: () => getMonthDates,
+  getMonthDays: () => getMonthDays,
+  getMonthFormatter: () => getMonthFormatter,
+  getMonthNames: () => getMonthNames,
   getNextDay: () => getNextDay,
   getNextPage: () => getNextPage,
   getNextRow: () => getNextRow,
@@ -49,13 +50,10 @@ __export(src_exports, {
   getPreviousSection: () => getPreviousSection,
   getSectionEnd: () => getSectionEnd,
   getSectionStart: () => getSectionStart,
-  getSegmentLimits: () => getSegmentLimits,
-  getSegmentPageStep: () => getSegmentPageStep,
-  getSegments: () => getSegments,
   getTodayDate: () => getTodayDate,
-  getTodayPlaceholderDate: () => getTodayPlaceholderDate,
   getUnitDuration: () => getUnitDuration,
-  getWeekDates: () => getWeekDates,
+  getWeekDays: () => getWeekDays,
+  getWeekdayFormats: () => getWeekdayFormats,
   getYearsRange: () => getYearsRange,
   isDateDisabled: () => isDateDisabled,
   isDateEqual: () => isDateEqual,
@@ -64,12 +62,11 @@ __export(src_exports, {
   isDateUnavailable: () => isDateUnavailable,
   isNextVisibleRangeInvalid: () => isNextVisibleRangeInvalid,
   isPreviousVisibleRangeInvalid: () => isPreviousVisibleRangeInvalid,
-  isSegmentEditable: () => isSegmentEditable,
   isTodayDate: () => isTodayDate,
+  parseDateString: () => parseDateString,
   setCalendar: () => setCalendar,
   setDate: () => setDate,
   setMonth: () => setMonth,
-  setSegment: () => setSegment,
   setYear: () => setYear
 });
 module.exports = __toCommonJS(src_exports);
@@ -206,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));
@@ -231,114 +280,153 @@ function formatRange(startDate, endDate, formatter, toString, timeZone) {
 }
 
 // src/format-selected-date.ts
-var import_date3 = require("@internationalized/date");
+var import_date5 = require("@internationalized/date");
+
+// src/get-day-formatter.ts
+var import_date4 = require("@internationalized/date");
 
-// src/get-formatter.ts
+// src/get-era-format.ts
 function getEraFormat(date) {
   return date?.calendar.identifier === "gregory" && date.era === "BC" ? "short" : void 0;
 }
-function getDateFormatter(startDate, endDate, getDateFormatter2, timeZone) {
-  let start = startDate;
-  let end = endDate ?? startDate;
-  let era = getEraFormat(start) || getEraFormat(end);
-  return getDateFormatter2({
+
+// src/get-day-formatter.ts
+function getDayFormatter(locale, timeZone) {
+  const date = (0, import_date4.toCalendarDate)((0, import_date4.today)(timeZone));
+  return new import_date4.DateFormatter(locale, {
     weekday: "long",
     month: "long",
     year: "numeric",
     day: "numeric",
-    era,
-    timeZone
-  });
-}
-function getMonthFormatter(startDate, endDate, getDateFormatter2, timeZone) {
-  let start = startDate;
-  let end = endDate ?? startDate;
-  let era = getEraFormat(start) || getEraFormat(end);
-  return getDateFormatter2({
-    month: "long",
-    year: "numeric",
-    era,
-    calendar: start?.calendar.identifier,
+    era: getEraFormat(date),
     timeZone
   });
 }
 
 // src/format-selected-date.ts
-function formatSelectedDate(startDate, endDate, getFormatter, isSelectingRange, timeZone) {
+function formatSelectedDate(startDate, endDate, locale, timeZone) {
   let start = startDate;
   let end = endDate ?? startDate;
-  let formatter = getDateFormatter(start, end, getFormatter, timeZone);
-  if (isSelectingRange || start == null || end == null) {
-    return "";
-  }
-  if ((0, import_date3.isSameDay)(start, end)) {
+  let formatter = getDayFormatter(locale, timeZone);
+  if ((0, import_date5.isSameDay)(start, end)) {
     return formatter.format(start.toDate(timeZone));
   }
   return formatRange(start, end, formatter, (start2, end2) => `${start2} \u2013 ${end2}`, timeZone);
 }
 
 // src/format-visible-range.ts
-var import_date4 = require("@internationalized/date");
-function formatVisibleRange(startDate, endDate, getFormatter, isAria, timeZone) {
-  if (!startDate)
-    return "";
-  let start = startDate;
-  let end = endDate ?? startDate;
-  let monthFormatter = getMonthFormatter(start, end, getFormatter, timeZone);
-  let dateFormatter = getDateFormatter(start, end, getFormatter, timeZone);
-  if (!(0, import_date4.isSameDay)(start, (0, import_date4.startOfMonth)(start))) {
-    return isAria ? formatRange(start, end, dateFormatter, (start2, end2) => `${start2} \u2013 ${end2}`, timeZone) : dateFormatter.formatRange(start.toDate(timeZone), end.toDate(timeZone));
-  }
-  if ((0, import_date4.isSameDay)(end, (0, import_date4.endOfMonth)(start))) {
+var import_date7 = require("@internationalized/date");
+
+// src/get-month-formatter.ts
+var import_date6 = require("@internationalized/date");
+function getMonthFormatter(locale, timeZone) {
+  const date = (0, import_date6.toCalendarDate)((0, import_date6.today)(timeZone));
+  return new import_date6.DateFormatter(locale, {
+    month: "long",
+    year: "numeric",
+    era: getEraFormat(date),
+    calendar: date?.calendar.identifier,
+    timeZone
+  });
+}
+
+// src/format-visible-range.ts
+function formatVisibleRange(startDate, endDate, locale, timeZone) {
+  const start = startDate;
+  const end = endDate ?? startDate;
+  const dayFormatter = getDayFormatter(locale, timeZone);
+  if (!(0, import_date7.isSameDay)(start, (0, import_date7.startOfMonth)(start))) {
+    return dayFormatter.formatRange(start.toDate(timeZone), end.toDate(timeZone));
+  }
+  const monthFormatter = getMonthFormatter(locale, timeZone);
+  if ((0, import_date7.isSameDay)(end, (0, import_date7.endOfMonth)(start))) {
     return monthFormatter.format(start.toDate(timeZone));
   }
-  if ((0, import_date4.isSameDay)(end, (0, import_date4.endOfMonth)(end))) {
-    return isAria ? formatRange(start, end, monthFormatter, (start2, end2) => `${start2} \u2013 ${end2}`, timeZone) : monthFormatter.formatRange(start.toDate(timeZone), end.toDate(timeZone));
+  if ((0, import_date7.isSameDay)(end, (0, import_date7.endOfMonth)(end))) {
+    return monthFormatter.formatRange(start.toDate(timeZone), end.toDate(timeZone));
   }
+  return "";
 }
 
-// src/get-month-dates.ts
-var import_date6 = require("@internationalized/date");
-
-// src/get-week-dates.ts
-var import_date5 = require("@internationalized/date");
-function getDatesInWeek(weekIndex, fromDate, locale) {
-  let date = fromDate.add({ weeks: weekIndex });
-  let dates = [];
-  date = (0, import_date5.startOfWeek)(date, locale);
-  let dayOfWeek = (0, import_date5.getDayOfWeek)(date, locale);
-  for (let i = 0; i < dayOfWeek; i++) {
-    dates.push(null);
+// src/get-decade-range.ts
+function getDecadeRange(year) {
+  const computedYear = year - year % 10 - 1;
+  const years = [];
+  for (let i = 0; i < 12; i += 1) {
+    const value = computedYear + i;
+    years.push(value);
   }
+  return years;
+}
+
+// src/get-month-days.ts
+var import_date9 = require("@internationalized/date");
+
+// src/get-start-of-week.ts
+var import_date8 = require("@internationalized/date");
+function getStartOfWeek(date, locale, firstDayOfWeek = 0) {
+  const day = (0, import_date8.getDayOfWeek)(date, locale);
+  const diff = (day - firstDayOfWeek + 7) % 7;
+  return date.subtract({ days: diff });
+}
+
+// src/get-month-days.ts
+function getDaysInWeek(weekIndex, from, locale, firstDayOfWeek) {
+  const weekDate = from.add({ weeks: weekIndex });
+  const dates = [];
+  let date = getStartOfWeek(weekDate, locale, firstDayOfWeek);
   while (dates.length < 7) {
     dates.push(date);
     let nextDate = date.add({ days: 1 });
-    if ((0, import_date5.isSameDay)(date, nextDate)) {
+    if ((0, import_date9.isSameDay)(date, nextDate)) {
       break;
     }
     date = nextDate;
   }
-  while (dates.length < 7) {
-    dates.push(null);
-  }
   return dates;
 }
-function getWeekDates(fromDate, timeZone, locale) {
-  let weekStart = (0, import_date5.startOfWeek)(fromDate, locale);
-  let weekArr = [...new Array(7).keys()];
-  return weekArr.map((index) => {
-    return weekStart.add({ days: index }).toDate(timeZone);
+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);
   });
 }
 
-// src/get-month-dates.ts
-function getMonthDates(startDate, duration, locale) {
-  let weeksInMonth = (0, import_date6.getWeeksInMonth)(startDate, locale);
-  let numOfWeeks = duration.weeks ?? weeksInMonth;
-  let weekArr = [...new Array(numOfWeeks).keys()];
-  return weekArr.map((index) => {
-    return getDatesInWeek(index, startDate, locale);
-  });
+// src/get-month-names.ts
+function getMonthNames(locale, format = "long") {
+  const date = new Date(2021, 0, 1);
+  const monthNames = [];
+  for (let i = 0; i < 12; i++) {
+    monthNames.push(date.toLocaleString(locale, { month: format }));
+    date.setMonth(date.getMonth() + 1);
+  }
+  return monthNames;
+}
+
+// src/get-weekday-formats.ts
+var import_date10 = require("@internationalized/date");
+function getWeekdayFormats(locale, timeZone) {
+  const longFormat = new import_date10.DateFormatter(locale, { weekday: "long", timeZone });
+  const shortFormat = new import_date10.DateFormatter(locale, { weekday: "short", timeZone });
+  const narrowFormat = new import_date10.DateFormatter(locale, { weekday: "narrow", timeZone });
+  return (value) => {
+    const date = value instanceof Date ? value : value.toDate(timeZone);
+    return {
+      value,
+      short: shortFormat.format(date),
+      long: longFormat.format(date),
+      narrow: narrowFormat.format(date)
+    };
+  };
+}
+
+// src/get-week-days.ts
+function getWeekDays(date, startOfWeekProp, timeZone, locale) {
+  const firstDayOfWeek = getStartOfWeek(date, locale, startOfWeekProp);
+  const weeks = [...new Array(7).keys()];
+  const format = getWeekdayFormats(locale, timeZone);
+  return weeks.map((index) => format(firstDayOfWeek.add({ days: index })));
 }
 
 // src/get-year-range.ts
@@ -351,9 +439,9 @@ function getYearsRange(range) {
 }
 
 // src/mutation.ts
-var import_date7 = require("@internationalized/date");
+var import_date11 = require("@internationalized/date");
 function getTodayDate(timezone) {
-  return (0, import_date7.today)(timezone);
+  return (0, import_date11.today)(timezone);
 }
 function getNextDay(date) {
   return date.add({ days: 1 });
@@ -368,7 +456,7 @@ function setYear(date, year) {
   return date.set({ year });
 }
 function setCalendar(date, calendar) {
-  return (0, import_date7.toCalendar)((0, import_date7.toCalendarDate)(date), calendar);
+  return (0, import_date11.toCalendar)((0, import_date11.toCalendarDate)(date), calendar);
 }
 function setDate(date, startDate, isDateUnavailable2, minValue, maxValue) {
   let result;
@@ -389,7 +477,7 @@ function getPreviousAvailableDate(date, minValue, isDateUnavailable2) {
 }
 
 // src/pagination.ts
-var import_date8 = require("@internationalized/date");
+var import_date12 = require("@internationalized/date");
 function getAdjustedDateFn(visibleDuration, locale, minValue, maxValue) {
   return function getDate(options) {
     const { startDate, focusedDate } = options;
@@ -480,13 +568,13 @@ function getSectionStart(focusedDate, startDate, visibleDuration, locale, minVal
   }
   if (visibleDuration.weeks) {
     return adjust({
-      focusedDate: (0, import_date8.startOfWeek)(focusedDate, locale),
+      focusedDate: (0, import_date12.startOfWeek)(focusedDate, locale),
       startDate
     });
   }
   if (visibleDuration.months || visibleDuration.years) {
     return adjust({
-      focusedDate: (0, import_date8.startOfMonth)(focusedDate),
+      focusedDate: (0, import_date12.startOfMonth)(focusedDate),
       startDate
     });
   }
@@ -502,13 +590,13 @@ function getSectionEnd(focusedDate, startDate, visibleDuration, locale, minValue
   }
   if (visibleDuration.weeks) {
     return adjust({
-      focusedDate: (0, import_date8.endOfWeek)(focusedDate, locale),
+      focusedDate: (0, import_date12.endOfWeek)(focusedDate, locale),
       startDate
     });
   }
   if (visibleDuration.months || visibleDuration.years) {
     return adjust({
-      focusedDate: (0, import_date8.endOfMonth)(focusedDate),
+      focusedDate: (0, import_date12.endOfMonth)(focusedDate),
       startDate
     });
   }
@@ -562,217 +650,46 @@ function getPreviousSection(focusedDate, startDate, larger, visibleDuration, loc
   }
 }
 
-// src/placeholder.ts
-var import_date9 = require("@internationalized/date");
-function getTodayPlaceholderDate(timeZone) {
-  return (0, import_date9.now)(timeZone).set({
-    hour: 0,
-    minute: 0,
-    second: 0,
-    millisecond: 0
-  });
-}
-function createPlaceholderDate(granularity, timeZone) {
-  let date = getTodayPlaceholderDate(timeZone);
-  if (granularity === "year" || granularity === "month" || granularity === "day") {
-    return (0, import_date9.toCalendarDate)(date);
-  }
-  return date;
-}
-
-// src/segment-constants.ts
-var EDITABLE_SEGMENTS = {
-  year: true,
-  month: true,
-  day: true,
-  hour: true,
-  minute: true,
-  second: true,
-  dayPeriod: true,
-  era: true
-};
-var SEGMENT_PAGE_STEP = {
-  year: 5,
-  month: 2,
-  day: 7,
-  hour: 2,
-  minute: 15,
-  second: 15
-};
-function isSegmentEditable(segment) {
-  return EDITABLE_SEGMENTS[segment];
-}
-function getSegmentPageStep(segment) {
-  return SEGMENT_PAGE_STEP[segment] ?? 1;
-}
-
-// src/segment-limit.ts
-var import_date10 = require("@internationalized/date");
-function getSegmentLimits(date, type, options) {
-  switch (type) {
-    case "era": {
-      let eras = date.calendar.getEras();
-      return {
-        value: eras.indexOf(date.era),
-        min: 0,
-        max: eras.length - 1
-      };
-    }
-    case "year":
-      return {
-        value: date.year,
-        min: 1,
-        max: date.calendar.getYearsInEra(date)
-      };
-    case "month":
-      return {
-        value: date.month,
-        min: (0, import_date10.getMinimumMonthInYear)(date),
-        max: date.calendar.getMonthsInYear(date)
-      };
-    case "day":
-      return {
-        value: date.day,
-        min: (0, import_date10.getMinimumDayInMonth)(date),
-        max: date.calendar.getDaysInMonth(date)
-      };
-  }
-  if ("hour" in date) {
-    switch (type) {
-      case "dayPeriod":
-        return {
-          value: date.hour >= 12 ? 12 : 0,
-          min: 0,
-          max: 12
-        };
-      case "hour":
-        if (options?.hour12) {
-          let isPM = date.hour >= 12;
-          return {
-            value: date.hour,
-            min: isPM ? 12 : 0,
-            max: isPM ? 23 : 11
-          };
-        }
-        return {
-          value: date.hour,
-          min: 0,
-          max: 23
-        };
-      case "minute":
-        return {
-          value: date.minute,
-          min: 0,
-          max: 59
-        };
-      case "second":
-        return {
-          value: date.second,
-          min: 0,
-          max: 59
-        };
-    }
-  }
-  return {
-    value: -1,
-    min: -1,
-    max: -1
-  };
-}
-
-// src/segment-mutation.ts
-function addSegment(date, part, amount, options) {
-  switch (part) {
-    case "era":
-    case "year":
-    case "month":
-    case "day":
-      return date.cycle(part, amount, { round: part === "year" });
-  }
-  if ("hour" in date) {
-    switch (part) {
-      case "dayPeriod": {
-        let hours = date.hour;
-        let isPM = hours >= 12;
-        return date.set({ hour: isPM ? hours - 12 : hours + 12 });
-      }
-      case "hour":
-      case "minute":
-      case "second":
-        return date.cycle(part, amount, {
-          round: part !== "hour",
-          hourCycle: options?.hour12 ? 12 : 24
-        });
+// 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.CalendarDate(+year, +month, +day);
+  }
+  const time = Date.parse(date);
+  if (!isNaN(time)) {
+    const date2 = new Date(time);
+    return new import_date13.CalendarDate(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 date;
-}
-function setSegment(date, part, value, options) {
-  switch (part) {
-    case "day":
-    case "month":
-    case "year":
-    case "era":
-      return date.set({ [part]: value });
-  }
-  if ("hour" in date) {
-    switch (part) {
-      case "dayPeriod": {
-        let hours = date.hour;
-        let wasPM = hours >= 12;
-        let isPM = value >= 12;
-        return isPM === wasPM ? date : date.set({ hour: wasPM ? hours - 12 : hours + 12 });
-      }
-      case "hour":
-        if (options?.hour12) {
-          let hours = date.hour;
-          let wasPM = hours >= 12;
-          if (!wasPM && value === 12) {
-            value = 0;
-          }
-          if (wasPM && value < 12) {
-            value += 12;
-          }
-        }
-      case "minute":
-      case "second":
-        return date.set({ [part]: value });
+    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 date;
-}
-
-// src/segment-parts.ts
-function getAllSegments(segments) {
-  return segments.filter((segment) => isSegmentEditable(segment.type)).reduce((acc, segment) => (acc[segment.type] = true, acc), {});
-}
-function getPlaceholder(options) {
-  const placeholder = { day: "dd", month: "mm", year: "yyyy" };
-  return placeholder[options.field];
-}
-function getSegments(date, validSegments, formatter, timeZone) {
-  const dateValue = date || getTodayPlaceholderDate(timeZone);
-  const segments = formatter.formatToParts(dateValue.toDate(timeZone));
-  return segments.map((segment) => {
-    let isEditable = isSegmentEditable(segment.type);
-    if (segment.type === "era")
-      isEditable = false;
-    let isPlaceholder = isSegmentEditable(segment.type) && !validSegments[segment.type];
-    let placeholder = isSegmentEditable(segment.type) ? getPlaceholder({ field: segment.type }) : null;
-    return {
-      type: segment.type,
-      text: isPlaceholder ? placeholder : segment.value,
-      ...getSegmentLimits(dateValue, segment.type, formatter.resolvedOptions()),
-      isPlaceholder: !!isPlaceholder,
-      placeholder,
-      isEditable: !!isEditable
-    };
-  });
+    return acc;
+  }, {});
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  SEGMENT_PAGE_STEP,
-  addSegment,
   alignCenter,
   alignDate,
   alignEnd,
@@ -780,15 +697,18 @@ function getSegments(date, validSegments, formatter, timeZone) {
   alignStartDate,
   constrainStart,
   constrainValue,
-  createPlaceholderDate,
+  formatDate,
   formatRange,
   formatSelectedDate,
   formatVisibleRange,
   getAdjustedDateFn,
-  getAllSegments,
-  getDatesInWeek,
+  getDayFormatter,
+  getDaysInWeek,
+  getDecadeRange,
   getEndDate,
-  getMonthDates,
+  getMonthDays,
+  getMonthFormatter,
+  getMonthNames,
   getNextDay,
   getNextPage,
   getNextRow,
@@ -800,13 +720,10 @@ function getSegments(date, validSegments, formatter, timeZone) {
   getPreviousSection,
   getSectionEnd,
   getSectionStart,
-  getSegmentLimits,
-  getSegmentPageStep,
-  getSegments,
   getTodayDate,
-  getTodayPlaceholderDate,
   getUnitDuration,
-  getWeekDates,
+  getWeekDays,
+  getWeekdayFormats,
   getYearsRange,
   isDateDisabled,
   isDateEqual,
@@ -815,11 +732,10 @@ function getSegments(date, validSegments, formatter, timeZone) {
   isDateUnavailable,
   isNextVisibleRangeInvalid,
   isPreviousVisibleRangeInvalid,
-  isSegmentEditable,
   isTodayDate,
+  parseDateString,
   setCalendar,
   setDate,
   setMonth,
-  setSegment,
   setYear
 });