trud-calendar-core 0.1.4 → 1.0.0

package/dist/index.cjs

@@ -7,6 +7,8 @@ var DEFAULT_LABELS = {
   week: "Week",
   day: "Day",
   agenda: "Agenda",
+  year: "Year",
+  timeline: "Timeline",
   allDay: "all-day",
   noEvents: "No events in this period",
   more: (n) => `+${n} more`
@@ -19,9 +21,10 @@ var DEFAULT_VIEW = "month";
 var HOURS_IN_DAY = 24;
 var MINUTES_IN_HOUR = 60;
 var MINUTES_IN_DAY = HOURS_IN_DAY * MINUTES_IN_HOUR;
-var VIEWS = ["month", "week", "day", "agenda"];
+var VIEWS = ["month", "week", "day", "agenda", "year", "timeline"];
 var DEFAULT_DAY_START_HOUR = 0;
 var DEFAULT_DAY_END_HOUR = 24;
+var DEFAULT_SNAP_DURATION = 15;
 
 // src/utils/date.ts
 function parseDate(iso) {
@@ -134,8 +137,29 @@ function getVisibleRange(date, view, weekStartsOn = 0) {
       return { start: date, end: date };
     case "agenda":
       return { start: date, end: addDays(date, 30) };
+    case "year": {
+      const d = parseDate(date);
+      const yearStart = `${d.getFullYear()}-01-01`;
+      const yearEnd = `${d.getFullYear()}-12-31`;
+      return { start: yearStart, end: yearEnd };
+    }
+    case "timeline":
+      return { start: date, end: date };
   }
 }
+function getISOWeekNumber(date) {
+  const d = parseDate(date);
+  const target = new Date(d.getFullYear(), d.getMonth(), d.getDate());
+  const dayNum = target.getDay() || 7;
+  target.setDate(target.getDate() + 4 - dayNum);
+  const yearStart = new Date(target.getFullYear(), 0, 1);
+  return Math.ceil(((target.getTime() - yearStart.getTime()) / 864e5 + 1) / 7);
+}
+function filterHiddenDays(days, hiddenDays) {
+  if (hiddenDays.length === 0) return days;
+  const hiddenSet = new Set(hiddenDays);
+  return days.filter((d) => !hiddenSet.has(parseDate(d).getDay()));
+}
 function getTimeOfDay(datetime) {
   const d = parseDate(datetime);
   return d.getHours() + d.getMinutes() / 60;
@@ -192,6 +216,15 @@ function formatToolbarTitle(date, view, locale = "en-US") {
       }).format(d);
     case "agenda":
       return getFormatter(locale, { month: "long", year: "numeric" }).format(d);
+    case "year":
+      return getFormatter(locale, { year: "numeric" }).format(d);
+    case "timeline":
+      return getFormatter(locale, {
+        weekday: "long",
+        month: "long",
+        day: "numeric",
+        year: "numeric"
+      }).format(d);
   }
 }
 function formatWeekdayShort(date, locale = "en-US") {
@@ -244,6 +277,10 @@ function navigateByView(date, view, direction) {
       return addDays(date, direction);
     case "agenda":
       return addMonths(date, direction);
+    case "year":
+      return addMonths(date, 12 * direction);
+    case "timeline":
+      return addDays(date, direction);
   }
 }
 function calendarReducer(state, action) {
@@ -276,6 +313,261 @@ function calendarReducer(state, action) {
   }
 }
 
+// src/utils/timezone.ts
+var WALL_RE = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})(?:\.\d+)?$/;
+var UTC_RE = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})(?:\.\d+)?Z$/;
+function pad2(n) {
+  return n < 10 ? `0${n}` : `${n}`;
+}
+function parseWall(wall) {
+  const m = WALL_RE.exec(wall);
+  if (!m) throw new RangeError(`Invalid wall-clock DateTimeString: ${wall}`);
+  return {
+    year: +m[1],
+    month: +m[2],
+    day: +m[3],
+    hour: +m[4],
+    minute: +m[5],
+    second: +m[6]
+  };
+}
+function formatWall(p) {
+  return `${p.year}-${pad2(p.month)}-${pad2(p.day)}T${pad2(p.hour)}:${pad2(p.minute)}:${pad2(p.second)}`;
+}
+function parseUtcMs(utc) {
+  if (UTC_RE.test(utc)) return Date.parse(utc);
+  if (WALL_RE.test(utc)) return Date.parse(`${utc}Z`);
+  throw new RangeError(`Invalid datetime string: ${utc}`);
+}
+function utcMsToIso(ms) {
+  return new Date(ms).toISOString().replace(/\.\d+Z$/, "Z");
+}
+var dtfCache = /* @__PURE__ */ new Map();
+function dtfFor(timeZone) {
+  let dtf = dtfCache.get(timeZone);
+  if (!dtf) {
+    dtf = new Intl.DateTimeFormat("en-US", {
+      timeZone,
+      year: "numeric",
+      month: "2-digit",
+      day: "2-digit",
+      hour: "2-digit",
+      minute: "2-digit",
+      second: "2-digit",
+      hour12: false,
+      hourCycle: "h23"
+    });
+    dtfCache.set(timeZone, dtf);
+  }
+  return dtf;
+}
+function partsAt(timeZone, utcMs) {
+  const parts = dtfFor(timeZone).formatToParts(new Date(utcMs));
+  const result = {};
+  for (const part of parts) {
+    switch (part.type) {
+      case "year":
+        result.year = +part.value;
+        break;
+      case "month":
+        result.month = +part.value;
+        break;
+      case "day":
+        result.day = +part.value;
+        break;
+      case "hour":
+        result.hour = +part.value % 24;
+        break;
+      case "minute":
+        result.minute = +part.value;
+        break;
+      case "second":
+        result.second = +part.value;
+        break;
+    }
+  }
+  return result;
+}
+function getBrowserTimeZone() {
+  try {
+    const tz = Intl.DateTimeFormat().resolvedOptions().timeZone;
+    if (typeof tz === "string" && tz.length > 0) return tz;
+  } catch {
+  }
+  return "UTC";
+}
+function eventWallToDisplay(eventWall, eventTimeZone, displayTimeZone) {
+  if (!eventTimeZone) return eventWall;
+  const target = displayTimeZone ?? getBrowserTimeZone();
+  if (eventTimeZone === target) return eventWall;
+  return convertWallTime(eventWall, eventTimeZone, target);
+}
+function displayWallToEvent(displayWall, eventTimeZone, displayTimeZone, options) {
+  if (!eventTimeZone) return displayWall;
+  const source = displayTimeZone ?? getBrowserTimeZone();
+  if (eventTimeZone === source) return displayWall;
+  return convertWallTime(displayWall, source, eventTimeZone, options);
+}
+var validTzCache = /* @__PURE__ */ new Map();
+function isValidTimeZone(timeZone) {
+  if (typeof timeZone !== "string" || timeZone.length === 0) return false;
+  const cached = validTzCache.get(timeZone);
+  if (cached !== void 0) return cached;
+  let ok;
+  try {
+    Intl.DateTimeFormat("en-US", { timeZone });
+    ok = true;
+  } catch {
+    ok = false;
+  }
+  validTzCache.set(timeZone, ok);
+  return ok;
+}
+var FALLBACK_TIMEZONES = Object.freeze([
+  "UTC",
+  "Africa/Cairo",
+  "Africa/Johannesburg",
+  "Africa/Lagos",
+  "Africa/Nairobi",
+  "America/Anchorage",
+  "America/Argentina/Buenos_Aires",
+  "America/Bogota",
+  "America/Caracas",
+  "America/Chicago",
+  "America/Denver",
+  "America/Halifax",
+  "America/Lima",
+  "America/Los_Angeles",
+  "America/Mexico_City",
+  "America/Montevideo",
+  "America/New_York",
+  "America/Phoenix",
+  "America/Santiago",
+  "America/Sao_Paulo",
+  "America/St_Johns",
+  "America/Toronto",
+  "America/Vancouver",
+  "Asia/Bangkok",
+  "Asia/Dubai",
+  "Asia/Hong_Kong",
+  "Asia/Jakarta",
+  "Asia/Jerusalem",
+  "Asia/Karachi",
+  "Asia/Kathmandu",
+  "Asia/Kolkata",
+  "Asia/Kuala_Lumpur",
+  "Asia/Manila",
+  "Asia/Riyadh",
+  "Asia/Seoul",
+  "Asia/Shanghai",
+  "Asia/Singapore",
+  "Asia/Taipei",
+  "Asia/Tehran",
+  "Asia/Tokyo",
+  "Atlantic/Azores",
+  "Atlantic/Cape_Verde",
+  "Atlantic/Reykjavik",
+  "Australia/Adelaide",
+  "Australia/Brisbane",
+  "Australia/Darwin",
+  "Australia/Melbourne",
+  "Australia/Perth",
+  "Australia/Sydney",
+  "Europe/Amsterdam",
+  "Europe/Athens",
+  "Europe/Berlin",
+  "Europe/Brussels",
+  "Europe/Bucharest",
+  "Europe/Budapest",
+  "Europe/Copenhagen",
+  "Europe/Dublin",
+  "Europe/Helsinki",
+  "Europe/Istanbul",
+  "Europe/Lisbon",
+  "Europe/London",
+  "Europe/Madrid",
+  "Europe/Moscow",
+  "Europe/Oslo",
+  "Europe/Paris",
+  "Europe/Prague",
+  "Europe/Rome",
+  "Europe/Stockholm",
+  "Europe/Vienna",
+  "Europe/Warsaw",
+  "Europe/Zurich",
+  "Pacific/Auckland",
+  "Pacific/Fiji",
+  "Pacific/Guam",
+  "Pacific/Honolulu",
+  "Pacific/Midway",
+  "Pacific/Pago_Pago",
+  "Pacific/Tongatapu"
+]);
+function listTimeZones() {
+  const fn = Intl.supportedValuesOf;
+  if (typeof fn === "function") {
+    try {
+      const values = fn("timeZone");
+      return values.includes("UTC") ? values.slice() : ["UTC", ...values];
+    } catch {
+    }
+  }
+  return FALLBACK_TIMEZONES.slice();
+}
+function getTimeZoneOffset(utcInstant, timeZone) {
+  const utcMs = parseUtcMs(utcInstant);
+  const wall = partsAt(timeZone, utcMs);
+  const wallAsUtcMs = Date.UTC(wall.year, wall.month - 1, wall.day, wall.hour, wall.minute, wall.second);
+  return Math.round((wallAsUtcMs - utcMs) / 6e4);
+}
+function wallTimeToUtc(wallTime, timeZone, options = {}) {
+  const ambiguous = options.ambiguous ?? "earlier";
+  const invalid = options.invalid ?? "shift";
+  const w = parseWall(wallTime);
+  const guessUtcMs = Date.UTC(w.year, w.month - 1, w.day, w.hour, w.minute, w.second);
+  const offsetBefore = getTimeZoneOffset(utcMsToIso(guessUtcMs - 12 * 36e5), timeZone);
+  const offsetAfter = getTimeZoneOffset(utcMsToIso(guessUtcMs + 12 * 36e5), timeZone);
+  const candidateBefore = guessUtcMs - offsetBefore * 6e4;
+  const candidateAfter = guessUtcMs - offsetAfter * 6e4;
+  const roundTripBefore = roundTripWall(candidateBefore, timeZone);
+  const roundTripAfter = roundTripWall(candidateAfter, timeZone);
+  const beforeMatches = wallEquals(roundTripBefore, w);
+  const afterMatches = wallEquals(roundTripAfter, w);
+  if (beforeMatches && afterMatches) {
+    if (candidateBefore === candidateAfter) {
+      return utcMsToIso(candidateBefore);
+    }
+    return utcMsToIso(ambiguous === "earlier" ? Math.min(candidateBefore, candidateAfter) : Math.max(candidateBefore, candidateAfter));
+  }
+  if (beforeMatches) return utcMsToIso(candidateBefore);
+  if (afterMatches) return utcMsToIso(candidateAfter);
+  if (invalid === "throw") {
+    throw new RangeError(`Wall time ${wallTime} does not exist in ${timeZone} (DST gap)`);
+  }
+  return utcMsToIso(Math.max(candidateBefore, candidateAfter));
+}
+function roundTripWall(utcMs, timeZone) {
+  return partsAt(timeZone, utcMs);
+}
+function wallEquals(a, b) {
+  return a.year === b.year && a.month === b.month && a.day === b.day && a.hour === b.hour && a.minute === b.minute && a.second === b.second;
+}
+function utcToWallTime(utcInstant, timeZone) {
+  return formatWall(partsAt(timeZone, parseUtcMs(utcInstant)));
+}
+function convertWallTime(wallTime, fromTimeZone, toTimeZone, options) {
+  if (fromTimeZone === toTimeZone) return wallTime;
+  const utc = wallTimeToUtc(wallTime, fromTimeZone, options);
+  return utcToWallTime(utc, toTimeZone);
+}
+function getTimeZoneAbbreviation(timeZone, atInstant) {
+  const utcMs = atInstant === void 0 ? Date.now() : parseUtcMs(atInstant);
+  const dtf = new Intl.DateTimeFormat("en-US", { timeZone, timeZoneName: "short" });
+  const parts = dtf.formatToParts(new Date(utcMs));
+  const tzPart = parts.find((p) => p.type === "timeZoneName");
+  return tzPart?.value ?? timeZone;
+}
+
 // src/utils/events.ts
 function sortEvents(events) {
   return [...events].sort((a, b) => {
@@ -300,14 +592,17 @@ function isMultiDayEvent(event) {
 function partitionEvents(events) {
   const allDay = [];
   const timed = [];
+  const background = [];
   for (const event of events) {
-    if (event.allDay || isMultiDayEvent(event)) {
+    if (event.display === "background") {
+      background.push(event);
+    } else if (event.allDay || isMultiDayEvent(event)) {
       allDay.push(event);
     } else {
       timed.push(event);
     }
   }
-  return { allDay, timed };
+  return { allDay, timed, background };
 }
 function segmentMultiDayEvent(event, rangeStart, rangeEnd) {
   const eventStartDate = event.start.slice(0, 10);
@@ -403,15 +698,17 @@ function assignColumns(group) {
   const totalColumns = columns.length;
   return result.map((r) => ({ ...r, totalColumns }));
 }
-function computeTimePositions(events, dayStartHour = 0, dayEndHour = 24) {
+function computeTimePositions(events, dayStartHour = 0, dayEndHour = 24, displayTimeZone) {
   const totalHours = dayEndHour - dayStartHour;
   const groups = buildOverlapGroups(events);
   const positioned = [];
   for (const group of groups) {
     const columns = assignColumns(group);
     for (const { event, column, totalColumns } of columns) {
-      const startTime = Math.max(getTimeOfDay(event.start), dayStartHour);
-      const endTime = Math.min(getTimeOfDay(event.end), dayEndHour);
+      const eventStart = displayTimeZone && event.timeZone ? eventWallToDisplay(event.start, event.timeZone, displayTimeZone) : event.start;
+      const eventEnd = displayTimeZone && event.timeZone ? eventWallToDisplay(event.end, event.timeZone, displayTimeZone) : event.end;
+      const startTime = Math.max(getTimeOfDay(eventStart), dayStartHour);
+      const endTime = Math.min(getTimeOfDay(eventEnd), dayEndHour);
       const top = (startTime - dayStartHour) / totalHours * 100;
       const height = Math.max((endTime - startTime) / totalHours * 100, 1);
       positioned.push({
@@ -465,9 +762,9 @@ function yPositionToFractionalHour(clientY, columnRect, dayStart, dayEnd) {
 function normalizeRange(a, b) {
   return a <= b ? { start: a, end: b } : { start: b, end: a };
 }
-function computeDropPosition(day, clientY, columnRect, dayStartHour, dayEndHour, durationMs) {
+function computeDropPosition(day, clientY, columnRect, dayStartHour, dayEndHour, durationMs, snapMinutes = 15) {
   const fractionalHour = yPositionToFractionalHour(clientY, columnRect, dayStartHour, dayEndHour);
-  const snapped = snapToIncrement(fractionalHour, 15);
+  const snapped = snapToIncrement(fractionalHour, snapMinutes);
   const clamped = Math.max(dayStartHour, Math.min(dayEndHour - durationMs / 36e5, snapped));
   const newStart = fractionalHourToDateTime(day, clamped);
   const newStartMs = new Date(newStart).getTime();
@@ -787,6 +1084,191 @@ function scrollToViewportRange(scrollTop, containerHeight, totalHeight, dayStart
   };
 }
 
+// src/utils/ical.ts
+function toICalDate(dateTime) {
+  return dateTime.replace(/[-:]/g, "").replace("T", "T");
+}
+function escapeICalText(text) {
+  return text.replace(/\\/g, "\\\\").replace(/;/g, "\\;").replace(/,/g, "\\,").replace(/\n/g, "\\n");
+}
+function eventsToICal(events, calendarName = "trud-calendar") {
+  const lines = [
+    "BEGIN:VCALENDAR",
+    "VERSION:2.0",
+    `PRODID:-//${calendarName}//EN`,
+    "CALSCALE:GREGORIAN",
+    "METHOD:PUBLISH"
+  ];
+  for (const event of events) {
+    lines.push("BEGIN:VEVENT");
+    lines.push(`UID:${event.id}`);
+    if (event.allDay) {
+      lines.push(`DTSTART;VALUE=DATE:${event.start.slice(0, 10).replace(/-/g, "")}`);
+      lines.push(`DTEND;VALUE=DATE:${event.end.slice(0, 10).replace(/-/g, "")}`);
+    } else {
+      lines.push(`DTSTART:${toICalDate(event.start)}`);
+      lines.push(`DTEND:${toICalDate(event.end)}`);
+    }
+    lines.push(`SUMMARY:${escapeICalText(event.title)}`);
+    if (event.recurrence) {
+      const parts = [`FREQ=${event.recurrence.freq.toUpperCase()}`];
+      if (event.recurrence.interval && event.recurrence.interval > 1) {
+        parts.push(`INTERVAL=${event.recurrence.interval}`);
+      }
+      if (event.recurrence.count) {
+        parts.push(`COUNT=${event.recurrence.count}`);
+      }
+      if (event.recurrence.until) {
+        parts.push(`UNTIL=${event.recurrence.until.replace(/-/g, "")}T235959`);
+      }
+      if (event.recurrence.byDay && event.recurrence.byDay.length > 0) {
+        parts.push(`BYDAY=${event.recurrence.byDay.join(",")}`);
+      }
+      if (event.recurrence.byMonthDay && event.recurrence.byMonthDay.length > 0) {
+        parts.push(`BYMONTHDAY=${event.recurrence.byMonthDay.join(",")}`);
+      }
+      if (event.recurrence.bySetPos) {
+        parts.push(`BYSETPOS=${event.recurrence.bySetPos}`);
+      }
+      lines.push(`RRULE:${parts.join(";")}`);
+    }
+    if (event.exDates && event.exDates.length > 0) {
+      const exDateValues = event.exDates.map((d) => d.replace(/-/g, "")).join(",");
+      lines.push(`EXDATE;VALUE=DATE:${exDateValues}`);
+    }
+    lines.push("END:VEVENT");
+  }
+  lines.push("END:VCALENDAR");
+  return lines.join("\r\n");
+}
+function downloadICal(events, filename = "calendar.ics", calendarName) {
+  const content = eventsToICal(events, calendarName);
+  const blob = new Blob([content], { type: "text/calendar;charset=utf-8" });
+  const url = URL.createObjectURL(blob);
+  const a = document.createElement("a");
+  a.href = url;
+  a.download = filename;
+  a.click();
+  URL.revokeObjectURL(url);
+}
+
+// src/utils/resources.ts
+function flattenResources(resources) {
+  const result = [];
+  for (const resource of resources) {
+    result.push(resource);
+    if (resource.children && resource.children.length > 0) {
+      result.push(...flattenResources(resource.children));
+    }
+  }
+  return result;
+}
+function getEventsForResource(events, resourceId) {
+  return events.filter((e) => e.resourceId === resourceId);
+}
+function groupEventsByResource(events, resources) {
+  const map = /* @__PURE__ */ new Map();
+  for (const resource of resources) {
+    map.set(resource.id, []);
+  }
+  for (const event of events) {
+    if (event.resourceId && map.has(event.resourceId)) {
+      map.get(event.resourceId).push(event);
+    }
+  }
+  return map;
+}
+
+// src/utils/timeline.ts
+var datePart = (s) => s.slice(0, 10);
+function intersectDay(event, day) {
+  const evStartDay = datePart(event.start);
+  const evEndDay = datePart(event.end);
+  if (day < evStartDay || day > evEndDay) return null;
+  const startsToday = evStartDay === day;
+  const endsToday = evEndDay === day;
+  const start = startsToday ? getTimeOfDay(event.start) : 0;
+  const end = endsToday ? getTimeOfDay(event.end) : 24;
+  if (end <= start) return null;
+  return { start, end, isStart: startsToday, isEnd: endsToday };
+}
+function computeTimelinePositions(events, resourceIds, day, dayStartHour = 0, dayEndHour = 24) {
+  const totalHours = Math.max(1e-4, dayEndHour - dayStartHour);
+  const result = /* @__PURE__ */ new Map();
+  for (const id of resourceIds) result.set(id, []);
+  const byResource = /* @__PURE__ */ new Map();
+  for (const event of events) {
+    if (event.allDay) continue;
+    if (event.display === "background") continue;
+    const rid = event.resourceId;
+    if (!rid || !result.has(rid)) continue;
+    let bucket = byResource.get(rid);
+    if (!bucket) {
+      bucket = [];
+      byResource.set(rid, bucket);
+    }
+    bucket.push(event);
+  }
+  for (const [resourceId, bucketEvents] of byResource) {
+    const clipped = [];
+    for (const event of bucketEvents) {
+      const window = intersectDay(event, day);
+      if (!window) continue;
+      const start = Math.max(window.start, dayStartHour);
+      const end = Math.min(window.end, dayEndHour);
+      if (end <= start) continue;
+      clipped.push({
+        original: event,
+        clippedStart: start,
+        clippedEnd: end,
+        isSegmentStart: window.isStart && window.start >= dayStartHour,
+        isSegmentEnd: window.isEnd && window.end <= dayEndHour
+      });
+    }
+    if (clipped.length === 0) continue;
+    const fakeIso = (h) => {
+      const hours = Math.floor(h);
+      const minutes = Math.floor((h - hours) * 60);
+      const seconds = Math.floor(((h - hours) * 60 - minutes) * 60);
+      const pad = (n) => n < 10 ? `0${n}` : `${n}`;
+      return `${day}T${pad(hours)}:${pad(minutes)}:${pad(seconds)}`;
+    };
+    const synthetic = clipped.map((c, idx) => ({
+      ...c.original,
+      // Keep the original id but tag the index so two clipped segments
+      // of the same parent never collide in a Map lookup.
+      id: `${c.original.id}::tl::${idx}`,
+      start: fakeIso(c.clippedStart),
+      end: fakeIso(c.clippedEnd)
+    }));
+    const groups = buildOverlapGroups(synthetic);
+    const positioned = [];
+    for (const group of groups) {
+      const cols = assignColumns(group);
+      for (const { event, column, totalColumns } of cols) {
+        const idx = parseInt(event.id.split("::tl::")[1] ?? "0", 10);
+        const meta = clipped[idx];
+        const start = meta.clippedStart;
+        const end = meta.clippedEnd;
+        const leftPct = (start - dayStartHour) / totalHours * 100;
+        const widthPct = Math.max((end - start) / totalHours * 100, 0.5);
+        positioned.push({
+          event: meta.original,
+          resourceId,
+          leftPct,
+          widthPct,
+          row: column,
+          totalRows: totalColumns,
+          isSegmentStart: meta.isSegmentStart,
+          isSegmentEnd: meta.isSegmentEnd
+        });
+      }
+    }
+    result.set(resourceId, positioned);
+  }
+  return result;
+}
+
 // src/utils/undo.ts
 var DEFAULT_MAX_HISTORY = 30;
 function createUndoStack(initial) {
@@ -839,6 +1321,7 @@ exports.DEFAULT_DAY_END_HOUR = DEFAULT_DAY_END_HOUR;
 exports.DEFAULT_DAY_START_HOUR = DEFAULT_DAY_START_HOUR;
 exports.DEFAULT_LABELS = DEFAULT_LABELS;
 exports.DEFAULT_LOCALE = DEFAULT_LOCALE;
+exports.DEFAULT_SNAP_DURATION = DEFAULT_SNAP_DURATION;
 exports.DEFAULT_VIEW = DEFAULT_VIEW;
 exports.HOURS_IN_DAY = HOURS_IN_DAY;
 exports.MINUTES_IN_DAY = MINUTES_IN_DAY;
@@ -854,15 +1337,23 @@ exports.canRedo = canRedo;
 exports.canUndo = canUndo;
 exports.computeDropPosition = computeDropPosition;
 exports.computeTimePositions = computeTimePositions;
+exports.computeTimelinePositions = computeTimelinePositions;
+exports.convertWallTime = convertWallTime;
 exports.createInitialState = createInitialState;
 exports.createUndoStack = createUndoStack;
 exports.dateInRange = dateInRange;
 exports.daysBetween = daysBetween;
+exports.displayWallToEvent = displayWallToEvent;
+exports.downloadICal = downloadICal;
 exports.eachDayOfRange = eachDayOfRange;
 exports.endOfMonth = endOfMonth;
+exports.eventWallToDisplay = eventWallToDisplay;
+exports.eventsToICal = eventsToICal;
 exports.expandRecurringEvents = expandRecurringEvents;
 exports.filterEventsInRange = filterEventsInRange;
+exports.filterHiddenDays = filterHiddenDays;
 exports.filterVisibleEvents = filterVisibleEvents;
+exports.flattenResources = flattenResources;
 exports.formatAgendaDate = formatAgendaDate;
 exports.formatDayNumber = formatDayNumber;
 exports.formatMonthDay = formatMonthDay;
@@ -873,22 +1364,30 @@ exports.formatWeekdayNarrow = formatWeekdayNarrow;
 exports.formatWeekdayShort = formatWeekdayShort;
 exports.fractionalHourToDateTime = fractionalHourToDateTime;
 exports.generateOccurrences = generateOccurrences;
+exports.getBrowserTimeZone = getBrowserTimeZone;
 exports.getDurationHours = getDurationHours;
 exports.getEventSegments = getEventSegments;
 exports.getEventsForDay = getEventsForDay;
+exports.getEventsForResource = getEventsForResource;
 exports.getHourLabels = getHourLabels;
+exports.getISOWeekNumber = getISOWeekNumber;
 exports.getMonthViewRange = getMonthViewRange;
 exports.getTimeOfDay = getTimeOfDay;
+exports.getTimeZoneAbbreviation = getTimeZoneAbbreviation;
+exports.getTimeZoneOffset = getTimeZoneOffset;
 exports.getVisibleRange = getVisibleRange;
 exports.getWeekDays = getWeekDays;
 exports.getWeekViewRange = getWeekViewRange;
 exports.groupEventsByDate = groupEventsByDate;
+exports.groupEventsByResource = groupEventsByResource;
 exports.isAfter = isAfter;
 exports.isBefore = isBefore;
 exports.isMultiDayEvent = isMultiDayEvent;
 exports.isSameDay = isSameDay;
 exports.isSameMonth = isSameMonth;
 exports.isToday = isToday;
+exports.isValidTimeZone = isValidTimeZone;
+exports.listTimeZones = listTimeZones;
 exports.normalizeRange = normalizeRange;
 exports.parseDate = parseDate;
 exports.parseRRule = parseRRule;
@@ -907,6 +1406,8 @@ exports.toDateString = toDateString;
 exports.toDateTimeString = toDateTimeString;
 exports.toRRuleString = toRRuleString;
 exports.undo = undo;
+exports.utcToWallTime = utcToWallTime;
+exports.wallTimeToUtc = wallTimeToUtc;
 exports.yPositionToFractionalHour = yPositionToFractionalHour;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map