@cerberus-design/react 0.22.0 → 0.23.0

package/dist/node_modules/.pnpm/@zag-js_date-utils@1.24.2_@internationalized_date@3.9.0/node_modules/@zag-js/date-utils/dist/index.cjs

@@ -0,0 +1,485 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const conversion = require('../../../../../@internationalized_date@3.9.0/node_modules/@internationalized/date/src/conversion.cjs');
+const queries = require('../../../../../@internationalized_date@3.9.0/node_modules/@internationalized/date/src/queries.cjs');
+const CalendarDate = require('../../../../../@internationalized_date@3.9.0/node_modules/@internationalized/date/src/CalendarDate.cjs');
+const DateFormatter = require('../../../../../@internationalized_date@3.9.0/node_modules/@internationalized/date/src/DateFormatter.cjs');
+
+// src/constrain.ts
+function alignCenter(date, duration, locale, min, max) {
+  const halfDuration = {};
+  for (let prop in duration) {
+    const key = prop;
+    const value = duration[key];
+    if (value == null) continue;
+    halfDuration[key] = Math.floor(value / 2);
+    if (halfDuration[key] > 0 && value % 2 === 0) {
+      halfDuration[key]--;
+    }
+  }
+  const aligned = alignStart(date, duration, locale).subtract(halfDuration);
+  return constrainStart(date, aligned, duration, locale, min, max);
+}
+function alignStart(date, duration, locale, min, max) {
+  let aligned = date;
+  if (duration.years) {
+    aligned = queries.startOfYear(date);
+  } else if (duration.months) {
+    aligned = queries.startOfMonth(date);
+  } else if (duration.weeks) {
+    aligned = queries.startOfWeek(date, locale);
+  }
+  return constrainStart(date, aligned, duration, locale, min, max);
+}
+function alignEnd(date, duration, locale, min, max) {
+  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(date, duration, locale).subtract(d);
+  return constrainStart(date, aligned, duration, locale, min, max);
+}
+function constrainStart(date, aligned, duration, locale, min, max) {
+  if (min && date.compare(min) >= 0) {
+    aligned = queries.maxDate(aligned, alignStart(conversion.toCalendarDate(min), duration, locale));
+  }
+  if (max && date.compare(max) <= 0) {
+    aligned = queries.minDate(aligned, alignEnd(conversion.toCalendarDate(max), duration, locale));
+  }
+  return aligned;
+}
+function constrainValue(date, minValue, maxValue) {
+  let constrainedDate = conversion.toCalendarDate(date);
+  if (minValue) {
+    constrainedDate = queries.maxDate(constrainedDate, conversion.toCalendarDate(minValue));
+  }
+  if (maxValue) {
+    constrainedDate = queries.minDate(constrainedDate, conversion.toCalendarDate(maxValue));
+  }
+  return constrainedDate;
+}
+
+// src/align.ts
+function alignDate(date, alignment, duration, locale, min, max) {
+  switch (alignment) {
+    case "start":
+      return alignStart(date, duration, locale, min, max);
+    case "end":
+      return alignEnd(date, duration, locale, min, max);
+    case "center":
+    default:
+      return alignCenter(date, duration, locale, min, max);
+  }
+}
+function isDateEqual(dateA, dateB) {
+  return dateB != null && queries.isSameDay(dateA, dateB);
+}
+function isDateUnavailable(date, isUnavailable, locale, minValue, maxValue) {
+  if (!date) return false;
+  if (isUnavailable?.(date, locale)) return true;
+  return isDateOutsideRange(date, minValue, maxValue);
+}
+function isDateOutsideRange(date, startDate, endDate) {
+  return startDate != null && date.compare(startDate) < 0 || endDate != null && date.compare(endDate) > 0;
+}
+function isPreviousRangeInvalid(startDate, minValue, maxValue) {
+  const prevDate = startDate.subtract({ days: 1 });
+  return queries.isSameDay(prevDate, startDate) || isDateOutsideRange(prevDate, minValue, maxValue);
+}
+function isNextRangeInvalid(endDate, minValue, maxValue) {
+  const nextDate = endDate.add({ days: 1 });
+  return queries.isSameDay(nextDate, endDate) || isDateOutsideRange(nextDate, minValue, maxValue);
+}
+
+// src/duration.ts
+function getUnitDuration(duration) {
+  let clone = { ...duration };
+  for (let key in clone) clone[key] = 1;
+  return clone;
+}
+function getEndDate(startDate, duration) {
+  let clone = { ...duration };
+  if (clone.days) clone.days--;
+  else clone.days = -1;
+  return startDate.add(clone);
+}
+
+// src/get-era-format.ts
+function getEraFormat(date) {
+  return date?.calendar.identifier === "gregory" && date.era === "BC" ? "short" : void 0;
+}
+
+// src/formatter.ts
+function getDayFormatter(locale, timeZone) {
+  const date = conversion.toCalendarDateTime(queries.today(timeZone));
+  return new DateFormatter.DateFormatter(locale, {
+    weekday: "long",
+    month: "long",
+    year: "numeric",
+    day: "numeric",
+    era: getEraFormat(date),
+    timeZone
+  });
+}
+function getMonthFormatter(locale, timeZone) {
+  const date = queries.today(timeZone);
+  return new DateFormatter.DateFormatter(locale, {
+    month: "long",
+    year: "numeric",
+    era: getEraFormat(date),
+    calendar: date?.calendar.identifier,
+    timeZone
+  });
+}
+
+// src/format.ts
+function formatRange(startDate, endDate, formatter, toString, timeZone) {
+  let parts = formatter.formatRangeToParts(startDate.toDate(timeZone), endDate.toDate(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 toString(start, end);
+}
+function formatSelectedDate(startDate, endDate, locale, timeZone) {
+  let start = startDate;
+  let end = startDate;
+  let formatter = getDayFormatter(locale, timeZone);
+  if (queries.isSameDay(start, end)) {
+    return formatter.format(start.toDate(timeZone));
+  }
+  return formatRange(start, end, formatter, (start2, end2) => `${start2} \u2013 ${end2}`, timeZone);
+}
+var daysOfTheWeek = ["sun", "mon", "tue", "wed", "thu", "fri", "sat"];
+function normalizeFirstDayOfWeek(firstDayOfWeek) {
+  return firstDayOfWeek != null ? daysOfTheWeek[firstDayOfWeek] : void 0;
+}
+function getStartOfWeek(date, locale, firstDayOfWeek) {
+  const firstDay = normalizeFirstDayOfWeek(firstDayOfWeek);
+  return queries.startOfWeek(date, locale, firstDay);
+}
+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 (queries.isSameDay(date, nextDate)) break;
+    date = nextDate;
+  }
+  return dates;
+}
+function getMonthDays(from, locale, numOfWeeks, firstDayOfWeek) {
+  const firstDay = normalizeFirstDayOfWeek(firstDayOfWeek);
+  const monthWeeks = numOfWeeks ?? queries.getWeeksInMonth(from, locale, firstDay);
+  const weeks = [...new Array(monthWeeks).keys()];
+  return weeks.map((week) => getDaysInWeek(week, from, locale, firstDayOfWeek));
+}
+function getWeekdayFormats(locale, timeZone) {
+  const longFormat = new DateFormatter.DateFormatter(locale, { weekday: "long", timeZone });
+  const shortFormat = new DateFormatter.DateFormatter(locale, { weekday: "short", timeZone });
+  const narrowFormat = new DateFormatter.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)
+    };
+  };
+}
+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 })));
+}
+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/date-year.ts
+function getYearsRange(range) {
+  const years = [];
+  for (let year = range.from; year <= range.to; year += 1) years.push(year);
+  return years;
+}
+var FUTURE_YEAR_COERCION = 10;
+function normalizeYear(year) {
+  if (!year) return;
+  if (year.length === 3) return year.padEnd(4, "0");
+  if (year.length === 2) {
+    const currentYear = (/* @__PURE__ */ new Date()).getFullYear();
+    const currentCentury = Math.floor(currentYear / 100) * 100;
+    const twoDigitYear = parseInt(year.slice(-2), 10);
+    const fullYear = currentCentury + twoDigitYear;
+    return fullYear > currentYear + FUTURE_YEAR_COERCION ? (fullYear - 100).toString() : fullYear.toString();
+  }
+  return year;
+}
+function getDecadeRange(year, opts) {
+  const chunkSize = opts?.strict ? 10 : 12;
+  const computedYear = year - year % 10;
+  const years = [];
+  for (let i = 0; i < chunkSize; i += 1) {
+    const value = computedYear + i;
+    years.push(value);
+  }
+  return years;
+}
+function getTodayDate(timeZone) {
+  return queries.today(timeZone ?? queries.getLocalTimeZone());
+}
+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 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
+    });
+  }
+}
+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.CalendarDate(+year, +month, +day);
+  }
+  const time = Date.parse(date);
+  if (!isNaN(time)) {
+    const date2 = new Date(time);
+    return new CalendarDate.CalendarDate(date2.getFullYear(), date2.getMonth() + 1, date2.getDate());
+  }
+}
+function createRegex(locale, timeZone) {
+  const formatter = new DateFormatter.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;
+  }, {});
+}
+function getDateRangePreset(preset, locale, timeZone) {
+  const today3 = conversion.toCalendarDate(queries.now(timeZone));
+  switch (preset) {
+    case "thisWeek":
+      return [queries.startOfWeek(today3, locale), queries.endOfWeek(today3, locale)];
+    case "thisMonth":
+      return [queries.startOfMonth(today3), today3];
+    case "thisQuarter":
+      return [queries.startOfMonth(today3).add({ months: -((today3.month - 1) % 3) }), today3];
+    case "thisYear":
+      return [queries.startOfYear(today3), today3];
+    case "last3Days":
+      return [today3.add({ days: -2 }), today3];
+    case "last7Days":
+      return [today3.add({ days: -6 }), today3];
+    case "last14Days":
+      return [today3.add({ days: -13 }), today3];
+    case "last30Days":
+      return [today3.add({ days: -29 }), today3];
+    case "last90Days":
+      return [today3.add({ days: -89 }), today3];
+    case "lastMonth":
+      return [queries.startOfMonth(today3.add({ months: -1 })), queries.endOfMonth(today3.add({ months: -1 }))];
+    case "lastQuarter":
+      return [
+        queries.startOfMonth(today3.add({ months: -((today3.month - 1) % 3) - 3 })),
+        queries.endOfMonth(today3.add({ months: -((today3.month - 1) % 3) - 1 }))
+      ];
+    case "lastWeek":
+      return [queries.startOfWeek(today3, locale).add({ weeks: -1 }), queries.endOfWeek(today3, locale).add({ weeks: -1 })];
+    case "lastYear":
+      return [queries.startOfYear(today3.add({ years: -1 })), queries.endOfYear(today3.add({ years: -1 }))];
+    default:
+      throw new Error(`Invalid date range preset: ${preset}`);
+  }
+}
+
+exports.alignCenter = alignCenter;
+exports.alignDate = alignDate;
+exports.alignEnd = alignEnd;
+exports.alignStart = alignStart;
+exports.constrainStart = constrainStart;
+exports.constrainValue = constrainValue;
+exports.formatRange = formatRange;
+exports.formatSelectedDate = formatSelectedDate;
+exports.getAdjustedDateFn = getAdjustedDateFn;
+exports.getDateRangePreset = getDateRangePreset;
+exports.getDayFormatter = getDayFormatter;
+exports.getDaysInWeek = getDaysInWeek;
+exports.getDecadeRange = getDecadeRange;
+exports.getEndDate = getEndDate;
+exports.getMonthDays = getMonthDays;
+exports.getMonthFormatter = getMonthFormatter;
+exports.getMonthNames = getMonthNames;
+exports.getNextPage = getNextPage;
+exports.getNextSection = getNextSection;
+exports.getPreviousPage = getPreviousPage;
+exports.getPreviousSection = getPreviousSection;
+exports.getStartOfWeek = getStartOfWeek;
+exports.getTodayDate = getTodayDate;
+exports.getUnitDuration = getUnitDuration;
+exports.getWeekDays = getWeekDays;
+exports.getWeekdayFormats = getWeekdayFormats;
+exports.getYearsRange = getYearsRange;
+exports.isDateEqual = isDateEqual;
+exports.isDateOutsideRange = isDateOutsideRange;
+exports.isDateUnavailable = isDateUnavailable;
+exports.isNextRangeInvalid = isNextRangeInvalid;
+exports.isPreviousRangeInvalid = isPreviousRangeInvalid;
+exports.normalizeYear = normalizeYear;
+exports.parseDateString = parseDateString;