@zag-js/date-utils 0.0.0-dev-20230107115230

package/dist/index.js

@@ -0,0 +1,656 @@
+"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/index.ts
+var src_exports = {};
+__export(src_exports, {
+  SEGMENT_PAGE_STEP: () => SEGMENT_PAGE_STEP,
+  addSegment: () => addSegment,
+  alignCenter: () => alignCenter,
+  alignDate: () => alignDate,
+  alignEnd: () => alignEnd,
+  alignStart: () => alignStart,
+  alignStartDate: () => alignStartDate,
+  clampDate: () => clampDate,
+  constrainStart: () => constrainStart,
+  constrainValue: () => constrainValue,
+  formatRange: () => formatRange,
+  formatSelectedDate: () => formatSelectedDate,
+  getDatesInWeek: () => getDatesInWeek,
+  getEndDate: () => getEndDate,
+  getMonthDates: () => getMonthDates,
+  getNextDay: () => getNextDay,
+  getNextPage: () => getNextPage,
+  getNextRow: () => getNextRow,
+  getNextSection: () => getNextSection,
+  getPreviousDay: () => getPreviousDay,
+  getPreviousPage: () => getPreviousPage,
+  getPreviousRow: () => getPreviousRow,
+  getPreviousSection: () => getPreviousSection,
+  getSectionEnd: () => getSectionEnd,
+  getSectionStart: () => getSectionStart,
+  getSegmentLimits: () => getSegmentLimits,
+  getTodayDate: () => getTodayDate,
+  getUnitDuration: () => getUnitDuration,
+  getWeekDates: () => getWeekDates,
+  getYearsRange: () => getYearsRange,
+  isDateDisabled: () => isDateDisabled,
+  isDateEqual: () => isDateEqual,
+  isDateInvalid: () => isDateInvalid,
+  isDateOutsideVisibleRange: () => isDateOutsideVisibleRange,
+  isDateUnavailable: () => isDateUnavailable,
+  isNextVisibleRangeInvalid: () => isNextVisibleRangeInvalid,
+  isPreviousVisibleRangeInvalid: () => isPreviousVisibleRangeInvalid,
+  isSegmentEditable: () => isSegmentEditable,
+  isTodayDate: () => isTodayDate,
+  setCalendar: () => setCalendar,
+  setDate: () => setDate,
+  setMonth: () => setMonth,
+  setSegment: () => setSegment,
+  setYear: () => setYear
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/constrain.ts
+var import_date = require("@internationalized/date");
+function alignCenter(ctx, date) {
+  const { duration } = ctx;
+  let halfDuration = {};
+  for (let key in duration) {
+    halfDuration[key] = Math.floor(duration[key] / 2);
+    if (halfDuration[key] > 0 && duration[key] % 2 === 0) {
+      halfDuration[key]--;
+    }
+  }
+  let aligned = alignStart(ctx, date).subtract(halfDuration);
+  return constrainStart(ctx, date, aligned);
+}
+function alignStart(ctx, date) {
+  let { locale, duration } = ctx;
+  let aligned = date;
+  if (duration.years) {
+    aligned = (0, import_date.startOfYear)(date);
+  } else if (duration.months) {
+    aligned = (0, import_date.startOfMonth)(date);
+  } else if (duration.weeks) {
+    aligned = (0, import_date.startOfWeek)(date, locale);
+  }
+  return constrainStart(ctx, date, aligned);
+}
+function alignEnd(ctx, date) {
+  const { duration } = ctx;
+  let d = { ...duration };
+  if (d.days) {
+    d.days--;
+  } else if (d.weeks) {
+    d.weeks--;
+  } else if (d.months) {
+    d.months--;
+  } else if (d.years) {
+    d.years--;
+  }
+  let aligned = alignStart(ctx, date).subtract(d);
+  return constrainStart(ctx, date, aligned);
+}
+function constrainValue(ctx, date) {
+  let { min, max } = ctx;
+  if (min) {
+    date = (0, import_date.maxDate)(date, (0, import_date.toCalendarDate)(min));
+  }
+  if (max) {
+    date = (0, import_date.minDate)(date, (0, import_date.toCalendarDate)(max));
+  }
+  return date;
+}
+function constrainStart(ctx, date, aligned) {
+  let { min, max } = ctx;
+  if (min && date.compare(min) >= 0) {
+    aligned = (0, import_date.maxDate)(aligned, alignStart(ctx, (0, import_date.toCalendarDate)(min)));
+  }
+  if (max && date.compare(max) <= 0) {
+    aligned = (0, import_date.minDate)(aligned, alignEnd(ctx, (0, import_date.toCalendarDate)(max)));
+  }
+  return aligned;
+}
+
+// src/align.ts
+function alignDate(ctx, date, alignment) {
+  switch (alignment) {
+    case "start":
+      return alignStart(ctx, date);
+    case "end":
+      return alignEnd(ctx, date);
+    case "center":
+    default:
+      return alignCenter(ctx, date);
+  }
+}
+function alignStartDate(ctx, focusedDate, startDate, endDate) {
+  if (focusedDate.compare(startDate) < 0) {
+    return alignEnd(ctx, focusedDate);
+  }
+  if (focusedDate.compare(endDate) > 0) {
+    return alignStart(ctx, focusedDate);
+  }
+  return startDate;
+}
+
+// src/assertion.ts
+var import_date2 = require("@internationalized/date");
+function isTodayDate(date, timezone) {
+  return (0, import_date2.isToday)(date, timezone);
+}
+function isDateEqual(dateA, dateB) {
+  return dateB != null && (0, import_date2.isSameDay)(dateA, dateB);
+}
+function isDateInvalid(ctx, date) {
+  return ctx.min != null && date.compare(ctx.min) < 0 || ctx.max != null && date.compare(ctx.max) > 0;
+}
+function isDateDisabled(ctx, date, startDate, endDate) {
+  return date.compare(startDate) < 0 || date.compare(endDate) > 0 || isDateInvalid(ctx, date);
+}
+function isDateUnavailable(ctx, date) {
+  var _a;
+  if (!date) {
+    return false;
+  }
+  if ((_a = ctx.isUnavailable) == null ? void 0 : _a.call(ctx, date)) {
+    return true;
+  }
+  return isDateInvalid(ctx, date);
+}
+function isDateOutsideVisibleRange(date, startDate, endDate) {
+  return date.compare(startDate) < 0 || date.compare(endDate) > 0;
+}
+function isPreviousVisibleRangeInvalid(ctx, startDate) {
+  let prev = startDate.subtract({ days: 1 });
+  return (0, import_date2.isSameDay)(prev, startDate) || isDateInvalid(ctx, prev);
+}
+function isNextVisibleRangeInvalid(ctx, endDate) {
+  let next = endDate.add({ days: 1 });
+  return (0, import_date2.isSameDay)(next, endDate) || isDateInvalid(ctx, next);
+}
+
+// src/duration.ts
+function getUnitDuration(duration) {
+  let d = { ...duration };
+  for (let key in d) {
+    d[key] = 1;
+  }
+  return d;
+}
+function getEndDate(startDate, duration) {
+  let d = { ...duration };
+  if (d.days) {
+    d.days--;
+  } else {
+    d.days = -1;
+  }
+  return startDate.add(d);
+}
+
+// src/format-range.ts
+function formatRange(ctx, formatter) {
+  let parts = formatter.formatRangeToParts(ctx.start.toDate(ctx.timeZone), ctx.end.toDate(ctx.timeZone));
+  let separatorIndex = -1;
+  for (let i = 0; i < parts.length; i++) {
+    let part = parts[i];
+    if (part.source === "shared" && part.type === "literal") {
+      separatorIndex = i;
+    } else if (part.source === "endRange") {
+      break;
+    }
+  }
+  let start = "";
+  let end = "";
+  for (let i = 0; i < parts.length; i++) {
+    if (i < separatorIndex) {
+      start += parts[i].value;
+    } else if (i > separatorIndex) {
+      end += parts[i].value;
+    }
+  }
+  return ctx.toString(start, end);
+}
+
+// src/format-selected-date.ts
+var import_date3 = require("@internationalized/date");
+
+// src/get-era-format.ts
+function getEraFormat(date) {
+  return (date == null ? void 0 : date.calendar.identifier) === "gregory" && date.era === "BC" ? "short" : void 0;
+}
+
+// src/get-formatter.ts
+function getDateFormatter(ctx) {
+  const { start, end = start, getDateFormatter: getDateFormatter2, timeZone } = ctx;
+  let era = getEraFormat(start) || getEraFormat(end);
+  return getDateFormatter2({
+    weekday: "long",
+    month: "long",
+    year: "numeric",
+    day: "numeric",
+    era,
+    timeZone
+  });
+}
+
+// src/format-selected-date.ts
+function formatSelectedDate(ctx) {
+  const { start, end = start, timeZone } = ctx;
+  let formatter = getDateFormatter(ctx);
+  if (ctx.isSelectingRange || start == null || end == null) {
+    return "";
+  }
+  if ((0, import_date3.isSameDay)(start, end)) {
+    return formatter.format(start.toDate(timeZone));
+  }
+  return formatRange(ctx, formatter);
+}
+
+// src/get-week-dates.ts
+var import_date4 = require("@internationalized/date");
+function getDatesInWeek(weekIndex, fromDate, locale) {
+  let date = fromDate.add({ weeks: weekIndex });
+  let dates = [];
+  date = (0, import_date4.startOfWeek)(date, locale);
+  let dayOfWeek = (0, import_date4.getDayOfWeek)(date, locale);
+  for (let i = 0; i < dayOfWeek; i++) {
+    dates.push(null);
+  }
+  while (dates.length < 7) {
+    dates.push(date);
+    let nextDate = date.add({ days: 1 });
+    if ((0, import_date4.isSameDay)(date, nextDate)) {
+      break;
+    }
+    date = nextDate;
+  }
+  while (dates.length < 7) {
+    dates.push(null);
+  }
+  return dates;
+}
+function getWeekDates(timeZone, locale) {
+  let weekStart = (0, import_date4.startOfWeek)((0, import_date4.today)(timeZone), locale);
+  let weekArr = [...new Array(7).keys()];
+  return weekArr.map((index) => {
+    return weekStart.add({ days: index }).toDate(timeZone);
+  });
+}
+
+// src/get-month-dates.ts
+var import_date5 = require("@internationalized/date");
+function getMonthDates(startDate, duration, locale) {
+  var _a;
+  let weeksInMonth = (0, import_date5.getWeeksInMonth)(startDate, locale);
+  let numOfWeeks = (_a = duration.weeks) != null ? _a : weeksInMonth;
+  let weekArr = [...new Array(numOfWeeks).keys()];
+  return weekArr.map((index) => {
+    return getDatesInWeek(index, startDate, locale);
+  });
+}
+
+// src/get-year-range.ts
+function getYearsRange(range) {
+  const years = [];
+  for (let year = range.from; year <= range.to; year += 1) {
+    years.push(year);
+  }
+  return years;
+}
+
+// src/mutation.ts
+var import_date6 = require("@internationalized/date");
+function clampDate(ctx, date) {
+  return constrainValue(ctx, date);
+}
+function getTodayDate(timezone) {
+  return (0, import_date6.today)(timezone);
+}
+function getNextDay(date) {
+  return date.add({ days: 1 });
+}
+function getPreviousDay(date) {
+  return date.subtract({ days: 1 });
+}
+function setMonth(date, month) {
+  return date.set({ month });
+}
+function setYear(date, year) {
+  return date.set({ year });
+}
+function setCalendar(date, calendar) {
+  return (0, import_date6.toCalendar)((0, import_date6.toCalendarDate)(date), calendar);
+}
+function setDate(ctx, date, nextDate, startDate) {
+  let result;
+  result = clampDate(ctx, nextDate);
+  result = getPreviousAvailableDate(ctx, nextDate, startDate);
+  if (!result)
+    return;
+  result = (0, import_date6.toCalendar)(result, (date == null ? void 0 : date.calendar) || new import_date6.GregorianCalendar());
+  if (date && "hour" in date) {
+    return date.set(result);
+  }
+  return result;
+}
+function getPreviousAvailableDate(ctx, date, min) {
+  const minValue = min != null ? min : ctx.min;
+  if (!isDateUnavailable(ctx, date) || !minValue) {
+    return date;
+  }
+  while (date.compare(minValue) >= 0 && isDateUnavailable(ctx, date)) {
+    date = date.subtract({ days: 1 });
+  }
+  if (date.compare(minValue) >= 0) {
+    return date;
+  }
+}
+
+// src/pagination.ts
+var import_date7 = require("@internationalized/date");
+function getNextPage(ctx, date, startDate) {
+  const start = startDate.add(ctx.duration);
+  return {
+    startDate: alignStart(ctx, constrainStart(ctx, date, start)),
+    focusedDate: constrainValue(ctx, date.add(ctx.duration))
+  };
+}
+function getPreviousPage(ctx, date, startDate) {
+  const start = startDate.subtract(ctx.duration);
+  return {
+    startDate: alignStart(ctx, constrainStart(ctx, date, start)),
+    focusedDate: constrainValue(ctx, date.subtract(ctx.duration))
+  };
+}
+function getSectionStart(ctx, date, startDate) {
+  const d = ctx.duration;
+  if (d.days) {
+    return startDate;
+  }
+  if (d.weeks) {
+    return (0, import_date7.startOfWeek)(date, ctx.locale);
+  }
+  if (d.months || d.years) {
+    return (0, import_date7.startOfMonth)(date);
+  }
+}
+function getSectionEnd(ctx, date, endDate) {
+  const d = ctx.duration;
+  if (d.days) {
+    return endDate;
+  }
+  if (d.weeks) {
+    return (0, import_date7.endOfWeek)(date, ctx.locale);
+  }
+  if (d.months || d.years) {
+    return (0, import_date7.endOfMonth)(date);
+  }
+}
+function getNextSection(ctx, date, larger) {
+  const d = ctx.duration;
+  const unitDuration = getUnitDuration(ctx.duration);
+  if (!larger && !d.days) {
+    return date.add(unitDuration);
+  }
+  if (d.days) {
+    return date.add(d);
+  }
+  if (d.weeks) {
+    return date.add({ months: 1 });
+  }
+  if (d.months || d.years) {
+    return date.add({ years: 1 });
+  }
+}
+function getPreviousSection(ctx, date, larger) {
+  const d = ctx.duration;
+  const unitDuration = getUnitDuration(ctx.duration);
+  if (!larger && !d.days) {
+    return date.subtract(unitDuration);
+  }
+  if (d.days) {
+    return date.subtract(ctx.duration);
+  }
+  if (d.weeks) {
+    return date.subtract({ months: 1 });
+  }
+  if (d.months || d.years) {
+    return date.subtract({ years: 1 });
+  }
+}
+function getNextRow(ctx, date, startDate) {
+  const d = ctx.duration;
+  if (d.days) {
+    return getNextPage(ctx, date, startDate);
+  }
+  if (d.weeks || d.months || d.years) {
+    return date.add({ weeks: 1 });
+  }
+}
+function getPreviousRow(ctx, date, startDate) {
+  const d = ctx.duration;
+  if (d.days) {
+    return getPreviousPage(ctx, date, startDate);
+  }
+  if (d.weeks || d.months || d.years) {
+    return date.subtract({ weeks: 1 });
+  }
+}
+
+// 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];
+}
+
+// src/segment-limit.ts
+var import_date8 = 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_date8.getMinimumMonthInYear)(date),
+        max: date.calendar.getMonthsInYear(date)
+      };
+    case "day":
+      return {
+        value: date.day,
+        min: (0, import_date8.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 {};
+}
+
+// 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
+        });
+    }
+  }
+}
+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 });
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SEGMENT_PAGE_STEP,
+  addSegment,
+  alignCenter,
+  alignDate,
+  alignEnd,
+  alignStart,
+  alignStartDate,
+  clampDate,
+  constrainStart,
+  constrainValue,
+  formatRange,
+  formatSelectedDate,
+  getDatesInWeek,
+  getEndDate,
+  getMonthDates,
+  getNextDay,
+  getNextPage,
+  getNextRow,
+  getNextSection,
+  getPreviousDay,
+  getPreviousPage,
+  getPreviousRow,
+  getPreviousSection,
+  getSectionEnd,
+  getSectionStart,
+  getSegmentLimits,
+  getTodayDate,
+  getUnitDuration,
+  getWeekDates,
+  getYearsRange,
+  isDateDisabled,
+  isDateEqual,
+  isDateInvalid,
+  isDateOutsideVisibleRange,
+  isDateUnavailable,
+  isNextVisibleRangeInvalid,
+  isPreviousVisibleRangeInvalid,
+  isSegmentEditable,
+  isTodayDate,
+  setCalendar,
+  setDate,
+  setMonth,
+  setSegment,
+  setYear
+});