@cerberus-design/react 0.25.0-rc.7 → 0.25.1-rc.1

package/dist/node_modules/.pnpm/@internationalized_date@3.10.1/node_modules/@internationalized/date/src/conversion.js

@@ -0,0 +1,186 @@
+'use client';
+import { CalendarDate, ZonedDateTime, CalendarDateTime } from './CalendarDate.js';
+import { constrain } from './manipulation.js';
+import { getExtendedYear, GregorianCalendar } from './calendars/GregorianCalendar.js';
+import { getLocalTimeZone, isEqualCalendar } from './queries.js';
+
+function epochFromDate(date) {
+  date = toCalendar(date, new GregorianCalendar());
+  let year = getExtendedYear(date.era, date.year);
+  return epochFromParts(year, date.month, date.day, date.hour, date.minute, date.second, date.millisecond);
+}
+function epochFromParts(year, month, day, hour, minute, second, millisecond) {
+  let date = /* @__PURE__ */ new Date();
+  date.setUTCHours(hour, minute, second, millisecond);
+  date.setUTCFullYear(year, month - 1, day);
+  return date.getTime();
+}
+function getTimeZoneOffset(ms, timeZone) {
+  if (timeZone === "UTC") {
+    return 0;
+  }
+  if (ms > 0 && timeZone === getLocalTimeZone()) {
+    return new Date(ms).getTimezoneOffset() * -60 * 1e3;
+  }
+  let { year, month, day, hour, minute, second } = getTimeZoneParts(ms, timeZone);
+  let utc = epochFromParts(year, month, day, hour, minute, second, 0);
+  return utc - Math.floor(ms / 1e3) * 1e3;
+}
+const formattersByTimeZone = /* @__PURE__ */ new Map();
+function getTimeZoneParts(ms, timeZone) {
+  let formatter = formattersByTimeZone.get(timeZone);
+  if (!formatter) {
+    formatter = new Intl.DateTimeFormat("en-US", {
+      timeZone,
+      hour12: false,
+      era: "short",
+      year: "numeric",
+      month: "numeric",
+      day: "numeric",
+      hour: "numeric",
+      minute: "numeric",
+      second: "numeric"
+    });
+    formattersByTimeZone.set(timeZone, formatter);
+  }
+  let parts = formatter.formatToParts(new Date(ms));
+  let namedParts = {};
+  for (let part of parts) {
+    if (part.type !== "literal") {
+      namedParts[part.type] = part.value;
+    }
+  }
+  return {
+    // Firefox returns B instead of BC... https://bugzilla.mozilla.org/show_bug.cgi?id=1752253
+    year: namedParts.era === "BC" || namedParts.era === "B" ? -namedParts.year + 1 : +namedParts.year,
+    month: +namedParts.month,
+    day: +namedParts.day,
+    hour: namedParts.hour === "24" ? 0 : +namedParts.hour,
+    // bugs.chromium.org/p/chromium/issues/detail?id=1045791
+    minute: +namedParts.minute,
+    second: +namedParts.second
+  };
+}
+const DAYMILLIS = 864e5;
+function getValidWallTimes(date, timeZone, earlier, later) {
+  let found = earlier === later ? [earlier] : [earlier, later];
+  return found.filter((absolute) => isValidWallTime(date, timeZone, absolute));
+}
+function isValidWallTime(date, timeZone, absolute) {
+  let parts = getTimeZoneParts(absolute, timeZone);
+  return date.year === parts.year && date.month === parts.month && date.day === parts.day && date.hour === parts.hour && date.minute === parts.minute && date.second === parts.second;
+}
+function toAbsolute(date, timeZone, disambiguation = "compatible") {
+  let dateTime = toCalendarDateTime(date);
+  if (timeZone === "UTC") {
+    return epochFromDate(dateTime);
+  }
+  if (timeZone === getLocalTimeZone() && disambiguation === "compatible") {
+    dateTime = toCalendar(dateTime, new GregorianCalendar());
+    let date2 = /* @__PURE__ */ new Date();
+    let year = getExtendedYear(dateTime.era, dateTime.year);
+    date2.setFullYear(year, dateTime.month - 1, dateTime.day);
+    date2.setHours(dateTime.hour, dateTime.minute, dateTime.second, dateTime.millisecond);
+    return date2.getTime();
+  }
+  let ms = epochFromDate(dateTime);
+  let offsetBefore = getTimeZoneOffset(ms - DAYMILLIS, timeZone);
+  let offsetAfter = getTimeZoneOffset(ms + DAYMILLIS, timeZone);
+  let valid = getValidWallTimes(dateTime, timeZone, ms - offsetBefore, ms - offsetAfter);
+  if (valid.length === 1) {
+    return valid[0];
+  }
+  if (valid.length > 1) {
+    switch (disambiguation) {
+      // 'compatible' means 'earlier' for "fall back" transitions
+      case "compatible":
+      case "earlier":
+        return valid[0];
+      case "later":
+        return valid[valid.length - 1];
+      case "reject":
+        throw new RangeError("Multiple possible absolute times found");
+    }
+  }
+  switch (disambiguation) {
+    case "earlier":
+      return Math.min(ms - offsetBefore, ms - offsetAfter);
+    // 'compatible' means 'later' for "spring forward" transitions
+    case "compatible":
+    case "later":
+      return Math.max(ms - offsetBefore, ms - offsetAfter);
+    case "reject":
+      throw new RangeError("No such absolute time found");
+  }
+}
+function toDate(dateTime, timeZone, disambiguation = "compatible") {
+  return new Date(toAbsolute(dateTime, timeZone, disambiguation));
+}
+function fromAbsolute(ms, timeZone) {
+  let offset = getTimeZoneOffset(ms, timeZone);
+  let date = new Date(ms + offset);
+  let year = date.getUTCFullYear();
+  let month = date.getUTCMonth() + 1;
+  let day = date.getUTCDate();
+  let hour = date.getUTCHours();
+  let minute = date.getUTCMinutes();
+  let second = date.getUTCSeconds();
+  let millisecond = date.getUTCMilliseconds();
+  return new ZonedDateTime(year < 1 ? "BC" : "AD", year < 1 ? -year + 1 : year, month, day, timeZone, offset, hour, minute, second, millisecond);
+}
+function toCalendarDate(dateTime) {
+  return new CalendarDate(dateTime.calendar, dateTime.era, dateTime.year, dateTime.month, dateTime.day);
+}
+function toCalendarDateTime(date, time) {
+  let hour = 0, minute = 0, second = 0, millisecond = 0;
+  if ("timeZone" in date) {
+    ({ hour, minute, second, millisecond } = date);
+  } else if ("hour" in date && true) {
+    return date;
+  }
+  return new CalendarDateTime(
+    date.calendar,
+    date.era,
+    date.year,
+    date.month,
+    date.day,
+    hour,
+    minute,
+    second,
+    millisecond
+  );
+}
+function toCalendar(date, calendar) {
+  if (isEqualCalendar(date.calendar, calendar)) {
+    return date;
+  }
+  let calendarDate = calendar.fromJulianDay(date.calendar.toJulianDay(date));
+  let copy = date.copy();
+  copy.calendar = calendar;
+  copy.era = calendarDate.era;
+  copy.year = calendarDate.year;
+  copy.month = calendarDate.month;
+  copy.day = calendarDate.day;
+  constrain(copy);
+  return copy;
+}
+function toZoned(date, timeZone, disambiguation) {
+  if (date instanceof ZonedDateTime) {
+    if (date.timeZone === timeZone) {
+      return date;
+    }
+    return toTimeZone(date, timeZone);
+  }
+  let ms = toAbsolute(date, timeZone, disambiguation);
+  return fromAbsolute(ms, timeZone);
+}
+function zonedToDate(date) {
+  let ms = epochFromDate(date) - date.offset;
+  return new Date(ms);
+}
+function toTimeZone(date, timeZone) {
+  let ms = epochFromDate(date) - date.offset;
+  return toCalendar(fromAbsolute(ms, timeZone), date.calendar);
+}
+
+export { epochFromDate, fromAbsolute, getTimeZoneOffset, toAbsolute, toCalendar, toCalendarDate, toCalendarDateTime, toDate, toTimeZone, toZoned, zonedToDate };

package/dist/node_modules/.pnpm/@internationalized_date@3.10.1/node_modules/@internationalized/date/src/manipulation.cjs

@@ -0,0 +1,352 @@
+'use client';
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const conversion = require('./conversion.cjs');
+const GregorianCalendar = require('./calendars/GregorianCalendar.cjs');
+
+const ONE_HOUR = 36e5;
+function add(date, duration) {
+  let mutableDate = date.copy();
+  let days = "hour" in mutableDate ? addTimeFields(mutableDate, duration) : 0;
+  addYears(mutableDate, duration.years || 0);
+  if (mutableDate.calendar.balanceYearMonth) {
+    mutableDate.calendar.balanceYearMonth(mutableDate, date);
+  }
+  mutableDate.month += duration.months || 0;
+  balanceYearMonth(mutableDate);
+  constrainMonthDay(mutableDate);
+  mutableDate.day += (duration.weeks || 0) * 7;
+  mutableDate.day += duration.days || 0;
+  mutableDate.day += days;
+  balanceDay(mutableDate);
+  if (mutableDate.calendar.balanceDate) {
+    mutableDate.calendar.balanceDate(mutableDate);
+  }
+  if (mutableDate.year < 1) {
+    mutableDate.year = 1;
+    mutableDate.month = 1;
+    mutableDate.day = 1;
+  }
+  let maxYear = mutableDate.calendar.getYearsInEra(mutableDate);
+  if (mutableDate.year > maxYear) {
+    let isInverseEra = mutableDate.calendar.isInverseEra?.(mutableDate);
+    mutableDate.year = maxYear;
+    mutableDate.month = isInverseEra ? 1 : mutableDate.calendar.getMonthsInYear(mutableDate);
+    mutableDate.day = isInverseEra ? 1 : mutableDate.calendar.getDaysInMonth(mutableDate);
+  }
+  if (mutableDate.month < 1) {
+    mutableDate.month = 1;
+    mutableDate.day = 1;
+  }
+  let maxMonth = mutableDate.calendar.getMonthsInYear(mutableDate);
+  if (mutableDate.month > maxMonth) {
+    mutableDate.month = maxMonth;
+    mutableDate.day = mutableDate.calendar.getDaysInMonth(mutableDate);
+  }
+  mutableDate.day = Math.max(1, Math.min(mutableDate.calendar.getDaysInMonth(mutableDate), mutableDate.day));
+  return mutableDate;
+}
+function addYears(date, years) {
+  if (date.calendar.isInverseEra?.(date)) {
+    years = -years;
+  }
+  date.year += years;
+}
+function balanceYearMonth(date) {
+  while (date.month < 1) {
+    addYears(date, -1);
+    date.month += date.calendar.getMonthsInYear(date);
+  }
+  let monthsInYear = 0;
+  while (date.month > (monthsInYear = date.calendar.getMonthsInYear(date))) {
+    date.month -= monthsInYear;
+    addYears(date, 1);
+  }
+}
+function balanceDay(date) {
+  while (date.day < 1) {
+    date.month--;
+    balanceYearMonth(date);
+    date.day += date.calendar.getDaysInMonth(date);
+  }
+  while (date.day > date.calendar.getDaysInMonth(date)) {
+    date.day -= date.calendar.getDaysInMonth(date);
+    date.month++;
+    balanceYearMonth(date);
+  }
+}
+function constrainMonthDay(date) {
+  date.month = Math.max(1, Math.min(date.calendar.getMonthsInYear(date), date.month));
+  date.day = Math.max(1, Math.min(date.calendar.getDaysInMonth(date), date.day));
+}
+function constrain(date) {
+  if (date.calendar.constrainDate) {
+    date.calendar.constrainDate(date);
+  }
+  date.year = Math.max(1, Math.min(date.calendar.getYearsInEra(date), date.year));
+  constrainMonthDay(date);
+}
+function invertDuration(duration) {
+  let inverseDuration = {};
+  for (let key in duration) {
+    if (typeof duration[key] === "number") {
+      inverseDuration[key] = -duration[key];
+    }
+  }
+  return inverseDuration;
+}
+function subtract(date, duration) {
+  return add(date, invertDuration(duration));
+}
+function set(date, fields) {
+  let mutableDate = date.copy();
+  if (fields.era != null) {
+    mutableDate.era = fields.era;
+  }
+  if (fields.year != null) {
+    mutableDate.year = fields.year;
+  }
+  if (fields.month != null) {
+    mutableDate.month = fields.month;
+  }
+  if (fields.day != null) {
+    mutableDate.day = fields.day;
+  }
+  constrain(mutableDate);
+  return mutableDate;
+}
+function setTime(value, fields) {
+  let mutableValue = value.copy();
+  if (fields.hour != null) {
+    mutableValue.hour = fields.hour;
+  }
+  if (fields.minute != null) {
+    mutableValue.minute = fields.minute;
+  }
+  if (fields.second != null) {
+    mutableValue.second = fields.second;
+  }
+  if (fields.millisecond != null) {
+    mutableValue.millisecond = fields.millisecond;
+  }
+  constrainTime(mutableValue);
+  return mutableValue;
+}
+function balanceTime(time) {
+  time.second += Math.floor(time.millisecond / 1e3);
+  time.millisecond = nonNegativeMod(time.millisecond, 1e3);
+  time.minute += Math.floor(time.second / 60);
+  time.second = nonNegativeMod(time.second, 60);
+  time.hour += Math.floor(time.minute / 60);
+  time.minute = nonNegativeMod(time.minute, 60);
+  let days = Math.floor(time.hour / 24);
+  time.hour = nonNegativeMod(time.hour, 24);
+  return days;
+}
+function constrainTime(time) {
+  time.millisecond = Math.max(0, Math.min(time.millisecond, 1e3));
+  time.second = Math.max(0, Math.min(time.second, 59));
+  time.minute = Math.max(0, Math.min(time.minute, 59));
+  time.hour = Math.max(0, Math.min(time.hour, 23));
+}
+function nonNegativeMod(a, b) {
+  let result = a % b;
+  if (result < 0) {
+    result += b;
+  }
+  return result;
+}
+function addTimeFields(time, duration) {
+  time.hour += duration.hours || 0;
+  time.minute += duration.minutes || 0;
+  time.second += duration.seconds || 0;
+  time.millisecond += duration.milliseconds || 0;
+  return balanceTime(time);
+}
+function cycleDate(value, field, amount, options) {
+  let mutable = value.copy();
+  switch (field) {
+    case "era": {
+      let eras = value.calendar.getEras();
+      let eraIndex = eras.indexOf(value.era);
+      if (eraIndex < 0) {
+        throw new Error("Invalid era: " + value.era);
+      }
+      eraIndex = cycleValue(eraIndex, amount, 0, eras.length - 1, options?.round);
+      mutable.era = eras[eraIndex];
+      constrain(mutable);
+      break;
+    }
+    case "year": {
+      if (mutable.calendar.isInverseEra?.(mutable)) {
+        amount = -amount;
+      }
+      mutable.year = cycleValue(value.year, amount, -Infinity, 9999, options?.round);
+      if (mutable.year === -Infinity) {
+        mutable.year = 1;
+      }
+      if (mutable.calendar.balanceYearMonth) {
+        mutable.calendar.balanceYearMonth(mutable, value);
+      }
+      break;
+    }
+    case "month":
+      mutable.month = cycleValue(value.month, amount, 1, value.calendar.getMonthsInYear(value), options?.round);
+      break;
+    case "day":
+      mutable.day = cycleValue(value.day, amount, 1, value.calendar.getDaysInMonth(value), options?.round);
+      break;
+    default:
+      throw new Error("Unsupported field " + field);
+  }
+  if (value.calendar.balanceDate) {
+    value.calendar.balanceDate(mutable);
+  }
+  constrain(mutable);
+  return mutable;
+}
+function cycleTime(value, field, amount, options) {
+  let mutable = value.copy();
+  switch (field) {
+    case "hour": {
+      let hours = value.hour;
+      let min = 0;
+      let max = 23;
+      if (options?.hourCycle === 12) {
+        let isPM = hours >= 12;
+        min = isPM ? 12 : 0;
+        max = isPM ? 23 : 11;
+      }
+      mutable.hour = cycleValue(hours, amount, min, max, options?.round);
+      break;
+    }
+    case "minute":
+      mutable.minute = cycleValue(value.minute, amount, 0, 59, options?.round);
+      break;
+    case "second":
+      mutable.second = cycleValue(value.second, amount, 0, 59, options?.round);
+      break;
+    case "millisecond":
+      mutable.millisecond = cycleValue(value.millisecond, amount, 0, 999, options?.round);
+      break;
+    default:
+      throw new Error("Unsupported field " + field);
+  }
+  return mutable;
+}
+function cycleValue(value, amount, min, max, round = false) {
+  if (round) {
+    value += Math.sign(amount);
+    if (value < min) {
+      value = max;
+    }
+    let div = Math.abs(amount);
+    if (amount > 0) {
+      value = Math.ceil(value / div) * div;
+    } else {
+      value = Math.floor(value / div) * div;
+    }
+    if (value > max) {
+      value = min;
+    }
+  } else {
+    value += amount;
+    if (value < min) {
+      value = max - (min - value - 1);
+    } else if (value > max) {
+      value = min + (value - max - 1);
+    }
+  }
+  return value;
+}
+function addZoned(dateTime, duration) {
+  let ms;
+  if (duration.years != null && duration.years !== 0 || duration.months != null && duration.months !== 0 || duration.weeks != null && duration.weeks !== 0 || duration.days != null && duration.days !== 0) {
+    let res2 = add(conversion.toCalendarDateTime(dateTime), {
+      years: duration.years,
+      months: duration.months,
+      weeks: duration.weeks,
+      days: duration.days
+    });
+    ms = conversion.toAbsolute(res2, dateTime.timeZone);
+  } else {
+    ms = conversion.epochFromDate(dateTime) - dateTime.offset;
+  }
+  ms += duration.milliseconds || 0;
+  ms += (duration.seconds || 0) * 1e3;
+  ms += (duration.minutes || 0) * 60 * 1e3;
+  ms += (duration.hours || 0) * 60 * 60 * 1e3;
+  let res = conversion.fromAbsolute(ms, dateTime.timeZone);
+  return conversion.toCalendar(res, dateTime.calendar);
+}
+function subtractZoned(dateTime, duration) {
+  return addZoned(dateTime, invertDuration(duration));
+}
+function cycleZoned(dateTime, field, amount, options) {
+  switch (field) {
+    case "hour": {
+      let min = 0;
+      let max = 23;
+      if (options?.hourCycle === 12) {
+        let isPM = dateTime.hour >= 12;
+        min = isPM ? 12 : 0;
+        max = isPM ? 23 : 11;
+      }
+      let plainDateTime = conversion.toCalendarDateTime(dateTime);
+      let minDate = conversion.toCalendar(setTime(plainDateTime, { hour: min }), new GregorianCalendar.GregorianCalendar());
+      let minAbsolute = [conversion.toAbsolute(minDate, dateTime.timeZone, "earlier"), conversion.toAbsolute(minDate, dateTime.timeZone, "later")].filter((ms2) => conversion.fromAbsolute(ms2, dateTime.timeZone).day === minDate.day)[0];
+      let maxDate = conversion.toCalendar(setTime(plainDateTime, { hour: max }), new GregorianCalendar.GregorianCalendar());
+      let maxAbsolute = [conversion.toAbsolute(maxDate, dateTime.timeZone, "earlier"), conversion.toAbsolute(maxDate, dateTime.timeZone, "later")].filter((ms2) => conversion.fromAbsolute(ms2, dateTime.timeZone).day === maxDate.day).pop();
+      let ms = conversion.epochFromDate(dateTime) - dateTime.offset;
+      let hours = Math.floor(ms / ONE_HOUR);
+      let remainder = ms % ONE_HOUR;
+      ms = cycleValue(
+        hours,
+        amount,
+        Math.floor(minAbsolute / ONE_HOUR),
+        Math.floor(maxAbsolute / ONE_HOUR),
+        options?.round
+      ) * ONE_HOUR + remainder;
+      return conversion.toCalendar(conversion.fromAbsolute(ms, dateTime.timeZone), dateTime.calendar);
+    }
+    case "minute":
+    case "second":
+    case "millisecond":
+      return cycleTime(dateTime, field, amount, options);
+    case "era":
+    case "year":
+    case "month":
+    case "day": {
+      let res = cycleDate(conversion.toCalendarDateTime(dateTime), field, amount, options);
+      let ms = conversion.toAbsolute(res, dateTime.timeZone);
+      return conversion.toCalendar(conversion.fromAbsolute(ms, dateTime.timeZone), dateTime.calendar);
+    }
+    default:
+      throw new Error("Unsupported field " + field);
+  }
+}
+function setZoned(dateTime, fields, disambiguation) {
+  let plainDateTime = conversion.toCalendarDateTime(dateTime);
+  let res = setTime(set(plainDateTime, fields), fields);
+  if (res.compare(plainDateTime) === 0) {
+    return dateTime;
+  }
+  let ms = conversion.toAbsolute(res, dateTime.timeZone, disambiguation);
+  return conversion.toCalendar(conversion.fromAbsolute(ms, dateTime.timeZone), dateTime.calendar);
+}
+
+exports.add = add;
+exports.addZoned = addZoned;
+exports.constrain = constrain;
+exports.constrainTime = constrainTime;
+exports.cycleDate = cycleDate;
+exports.cycleTime = cycleTime;
+exports.cycleZoned = cycleZoned;
+exports.invertDuration = invertDuration;
+exports.set = set;
+exports.setTime = setTime;
+exports.setZoned = setZoned;
+exports.subtract = subtract;
+exports.subtractZoned = subtractZoned;