trud-calendar-core 0.1.0

package/dist/index.js

@@ -0,0 +1,838 @@
+// src/constants/index.ts
+var DEFAULT_LABELS = {
+  today: "Today",
+  month: "Month",
+  week: "Week",
+  day: "Day",
+  agenda: "Agenda",
+  allDay: "all-day",
+  noEvents: "No events in this period",
+  more: (n) => `+${n} more`
+};
+var DEFAULT_LOCALE = {
+  locale: "en-US",
+  weekStartsOn: 0
+};
+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 DEFAULT_DAY_START_HOUR = 0;
+var DEFAULT_DAY_END_HOUR = 24;
+
+// src/utils/date.ts
+function parseDate(iso) {
+  if (iso.length === 10) {
+    const [y, m, d] = iso.split("-").map(Number);
+    return new Date(y, m - 1, d);
+  }
+  return new Date(iso);
+}
+function toDateString(date) {
+  const y = date.getFullYear();
+  const m = String(date.getMonth() + 1).padStart(2, "0");
+  const d = String(date.getDate()).padStart(2, "0");
+  return `${y}-${m}-${d}`;
+}
+function toDateTimeString(date) {
+  const ds = toDateString(date);
+  const h = String(date.getHours()).padStart(2, "0");
+  const min = String(date.getMinutes()).padStart(2, "0");
+  const s = String(date.getSeconds()).padStart(2, "0");
+  return `${ds}T${h}:${min}:${s}`;
+}
+function addDays(date, days) {
+  const d = parseDate(date);
+  d.setDate(d.getDate() + days);
+  return toDateString(d);
+}
+function addMonths(date, months) {
+  const d = parseDate(date);
+  d.setMonth(d.getMonth() + months);
+  return toDateString(d);
+}
+function addWeeks(date, weeks) {
+  return addDays(date, weeks * 7);
+}
+function startOfWeek(date, weekStartsOn = 0) {
+  const d = parseDate(date);
+  const day = d.getDay();
+  const diff = (day - weekStartsOn + 7) % 7;
+  d.setDate(d.getDate() - diff);
+  return toDateString(d);
+}
+function startOfMonth(date) {
+  const d = parseDate(date);
+  return toDateString(new Date(d.getFullYear(), d.getMonth(), 1));
+}
+function endOfMonth(date) {
+  const d = parseDate(date);
+  return toDateString(new Date(d.getFullYear(), d.getMonth() + 1, 0));
+}
+function isSameDay(a, b) {
+  return a.slice(0, 10) === b.slice(0, 10);
+}
+function isSameMonth(a, b) {
+  return a.slice(0, 7) === b.slice(0, 7);
+}
+function isToday(date) {
+  return date.slice(0, 10) === toDateString(/* @__PURE__ */ new Date());
+}
+function isBefore(a, b) {
+  return a < b;
+}
+function isAfter(a, b) {
+  return a > b;
+}
+function rangesOverlap(startA, endA, startB, endB) {
+  return startA < endB && startB < endA;
+}
+function dateInRange(date, rangeStart, rangeEnd) {
+  const d = date.slice(0, 10);
+  return d >= rangeStart.slice(0, 10) && d <= rangeEnd.slice(0, 10);
+}
+function daysBetween(a, b) {
+  const dateA = parseDate(a);
+  const dateB = parseDate(b);
+  const diffMs = dateB.getTime() - dateA.getTime();
+  return Math.round(diffMs / (1e3 * 60 * 60 * 24));
+}
+function eachDayOfRange(start, end) {
+  const days = [];
+  let current = start;
+  while (current <= end) {
+    days.push(current);
+    current = addDays(current, 1);
+  }
+  return days;
+}
+function getWeekDays(weekStart) {
+  return Array.from({ length: 7 }, (_, i) => addDays(weekStart, i));
+}
+function getMonthViewRange(date, weekStartsOn = 0) {
+  const monthStart = startOfMonth(date);
+  const monthEnd = endOfMonth(date);
+  const start = startOfWeek(monthStart, weekStartsOn);
+  const end = addDays(start, 41);
+  return { start, end: end > monthEnd ? end : addDays(start, 41) };
+}
+function getWeekViewRange(date, weekStartsOn = 0) {
+  const start = startOfWeek(date, weekStartsOn);
+  const end = addDays(start, 6);
+  return { start, end };
+}
+function getVisibleRange(date, view, weekStartsOn = 0) {
+  switch (view) {
+    case "month":
+      return getMonthViewRange(date, weekStartsOn);
+    case "week":
+      return getWeekViewRange(date, weekStartsOn);
+    case "day":
+      return { start: date, end: date };
+    case "agenda":
+      return { start: date, end: addDays(date, 30) };
+  }
+}
+function getTimeOfDay(datetime) {
+  const d = parseDate(datetime);
+  return d.getHours() + d.getMinutes() / 60;
+}
+function getDurationHours(start, end) {
+  const startDate = parseDate(start);
+  const endDate = parseDate(end);
+  return (endDate.getTime() - startDate.getTime()) / (1e3 * 60 * 60);
+}
+function getHourLabels(startHour = 0, endHour = 24, locale = "en-US") {
+  const formatter = new Intl.DateTimeFormat(locale, {
+    hour: "numeric",
+    hour12: true
+  });
+  const labels = [];
+  const base = new Date(2024, 0, 1);
+  for (let h = startHour; h < endHour; h++) {
+    base.setHours(h, 0, 0, 0);
+    labels.push(formatter.format(base));
+  }
+  return labels;
+}
+
+// src/utils/format.ts
+var formatterCache = /* @__PURE__ */ new Map();
+function getFormatter(locale, options) {
+  const key = `${locale}:${JSON.stringify(options)}`;
+  let fmt = formatterCache.get(key);
+  if (!fmt) {
+    fmt = new Intl.DateTimeFormat(locale, options);
+    formatterCache.set(key, fmt);
+  }
+  return fmt;
+}
+function formatToolbarTitle(date, view, locale = "en-US") {
+  const d = parseDate(date);
+  switch (view) {
+    case "month":
+      return getFormatter(locale, { month: "long", year: "numeric" }).format(d);
+    case "week": {
+      const weekFmt = getFormatter(locale, {
+        month: "short",
+        day: "numeric",
+        year: "numeric"
+      });
+      return weekFmt.format(d);
+    }
+    case "day":
+      return getFormatter(locale, {
+        weekday: "long",
+        month: "long",
+        day: "numeric",
+        year: "numeric"
+      }).format(d);
+    case "agenda":
+      return getFormatter(locale, { month: "long", year: "numeric" }).format(d);
+  }
+}
+function formatWeekdayShort(date, locale = "en-US") {
+  return getFormatter(locale, { weekday: "short" }).format(parseDate(date));
+}
+function formatWeekdayNarrow(date, locale = "en-US") {
+  return getFormatter(locale, { weekday: "narrow" }).format(parseDate(date));
+}
+function formatDayNumber(date, locale = "en-US") {
+  return getFormatter(locale, { day: "numeric" }).format(parseDate(date));
+}
+function formatTime(datetime, locale = "en-US") {
+  return getFormatter(locale, {
+    hour: "numeric",
+    minute: "2-digit",
+    hour12: true
+  }).format(parseDate(datetime));
+}
+function formatTimeRange(start, end, locale = "en-US") {
+  return `${formatTime(start, locale)} \u2013 ${formatTime(end, locale)}`;
+}
+function formatAgendaDate(date, locale = "en-US") {
+  return getFormatter(locale, {
+    weekday: "long",
+    month: "long",
+    day: "numeric"
+  }).format(parseDate(date));
+}
+function formatMonthDay(date, locale = "en-US") {
+  return getFormatter(locale, {
+    month: "short",
+    day: "numeric"
+  }).format(parseDate(date));
+}
+
+// src/state/reducer.ts
+function createInitialState(date, view) {
+  return {
+    currentDate: date ?? toDateString(/* @__PURE__ */ new Date()),
+    view: view ?? "month"
+  };
+}
+function navigateByView(date, view, direction) {
+  switch (view) {
+    case "month":
+      return addMonths(date, direction);
+    case "week":
+      return addWeeks(date, direction);
+    case "day":
+      return addDays(date, direction);
+    case "agenda":
+      return addMonths(date, direction);
+  }
+}
+function calendarReducer(state, action) {
+  switch (action.type) {
+    case "NAVIGATE_PREV":
+      return {
+        ...state,
+        currentDate: navigateByView(state.currentDate, state.view, -1)
+      };
+    case "NAVIGATE_NEXT":
+      return {
+        ...state,
+        currentDate: navigateByView(state.currentDate, state.view, 1)
+      };
+    case "NAVIGATE_TODAY":
+      return {
+        ...state,
+        currentDate: toDateString(/* @__PURE__ */ new Date())
+      };
+    case "SET_DATE":
+      return {
+        ...state,
+        currentDate: action.payload
+      };
+    case "SET_VIEW":
+      return {
+        ...state,
+        view: action.payload
+      };
+  }
+}
+
+// src/utils/events.ts
+function sortEvents(events) {
+  return [...events].sort((a, b) => {
+    const startCmp = a.start.localeCompare(b.start);
+    if (startCmp !== 0) return startCmp;
+    const durA = parseDate(a.end).getTime() - parseDate(a.start).getTime();
+    const durB = parseDate(b.end).getTime() - parseDate(b.start).getTime();
+    return durB - durA;
+  });
+}
+function filterEventsInRange(events, rangeStart, rangeEnd) {
+  const start = rangeStart + "T00:00:00";
+  const end = rangeEnd + "T23:59:59";
+  return events.filter((e) => rangesOverlap(e.start, e.end, start, end));
+}
+function getEventsForDay(events, date) {
+  return filterEventsInRange(events, date, date);
+}
+function isMultiDayEvent(event) {
+  return !isSameDay(event.start, event.end) || !!event.allDay;
+}
+function partitionEvents(events) {
+  const allDay = [];
+  const timed = [];
+  for (const event of events) {
+    if (event.allDay || isMultiDayEvent(event)) {
+      allDay.push(event);
+    } else {
+      timed.push(event);
+    }
+  }
+  return { allDay, timed };
+}
+function segmentMultiDayEvent(event, rangeStart, rangeEnd) {
+  const eventStartDate = event.start.slice(0, 10);
+  const eventEndDate = event.end.slice(0, 10);
+  const segStart = eventStartDate > rangeStart ? eventStartDate : rangeStart;
+  const segEnd = eventEndDate < rangeEnd ? eventEndDate : rangeEnd;
+  return eachDayOfRange(segStart, segEnd).map((date) => ({
+    event,
+    date,
+    isStart: date === eventStartDate,
+    isEnd: date === eventEndDate
+  }));
+}
+function getEventSegments(events, rangeStart, rangeEnd) {
+  const allDayEvents = events.filter((e) => e.allDay || isMultiDayEvent(e));
+  const segments = [];
+  for (const event of allDayEvents) {
+    segments.push(...segmentMultiDayEvent(event, rangeStart, rangeEnd));
+  }
+  return segments;
+}
+function segmentTimedMultiDayEvent(event, days, dayStartHour, dayEndHour) {
+  const eventStartDate = event.start.slice(0, 10);
+  const eventEndDate = event.end.slice(0, 10);
+  const eventStartHour = getTimeOfDay(event.start);
+  const eventEndHour = getTimeOfDay(event.end);
+  const segments = [];
+  for (const day of days) {
+    if (day < eventStartDate || day > eventEndDate) continue;
+    const isStart = day === eventStartDate;
+    const isEnd = day === eventEndDate;
+    let startHour;
+    let endHour;
+    if (isStart && isEnd) {
+      startHour = eventStartHour;
+      endHour = eventEndHour;
+    } else if (isStart) {
+      startHour = eventStartHour;
+      endHour = dayEndHour;
+    } else if (isEnd) {
+      startHour = dayStartHour;
+      endHour = eventEndHour;
+    } else {
+      startHour = dayStartHour;
+      endHour = dayEndHour;
+    }
+    segments.push({ event, day, startHour, endHour, isStart, isEnd });
+  }
+  return segments;
+}
+function buildOverlapGroups(events) {
+  if (events.length === 0) return [];
+  const sorted = sortEvents(events);
+  const groups = [];
+  let currentGroup = [sorted[0]];
+  let groupEnd = sorted[0].end;
+  for (let i = 1; i < sorted.length; i++) {
+    const event = sorted[i];
+    if (event.start < groupEnd) {
+      currentGroup.push(event);
+      if (event.end > groupEnd) {
+        groupEnd = event.end;
+      }
+    } else {
+      groups.push({ events: currentGroup });
+      currentGroup = [event];
+      groupEnd = event.end;
+    }
+  }
+  groups.push({ events: currentGroup });
+  return groups;
+}
+function assignColumns(group) {
+  const sorted = sortEvents(group.events);
+  const columns = [];
+  const result = [];
+  for (const event of sorted) {
+    let placed = false;
+    for (let col = 0; col < columns.length; col++) {
+      const lastInCol = columns[col][columns[col].length - 1];
+      if (lastInCol.end <= event.start) {
+        columns[col].push(event);
+        result.push({ event, column: col });
+        placed = true;
+        break;
+      }
+    }
+    if (!placed) {
+      columns.push([event]);
+      result.push({ event, column: columns.length - 1 });
+    }
+  }
+  const totalColumns = columns.length;
+  return result.map((r) => ({ ...r, totalColumns }));
+}
+function computeTimePositions(events, dayStartHour = 0, dayEndHour = 24) {
+  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 top = (startTime - dayStartHour) / totalHours * 100;
+      const height = Math.max((endTime - startTime) / totalHours * 100, 1);
+      positioned.push({
+        event,
+        column,
+        totalColumns,
+        top,
+        height
+      });
+    }
+  }
+  return positioned;
+}
+function groupEventsByDate(events, rangeStart, rangeEnd) {
+  const filtered = filterEventsInRange(events, rangeStart, rangeEnd);
+  const sorted = sortEvents(filtered);
+  const groups = /* @__PURE__ */ new Map();
+  for (const event of sorted) {
+    const date = event.start.slice(0, 10);
+    const existing = groups.get(date);
+    if (existing) {
+      existing.push(event);
+    } else {
+      groups.set(date, [event]);
+    }
+  }
+  return groups;
+}
+
+// src/utils/time.ts
+function snapToIncrement(fractionalHour, minutes = 15) {
+  const totalMinutes = fractionalHour * 60;
+  const snapped = Math.round(totalMinutes / minutes) * minutes;
+  return snapped / 60;
+}
+function fractionalHourToDateTime(day, fractionalHour) {
+  const totalMinutes = Math.round(fractionalHour * 60);
+  const hours = Math.floor(totalMinutes / 60);
+  const mins = totalMinutes % 60;
+  const hh = String(Math.max(0, Math.min(23, hours))).padStart(2, "0");
+  const mm = String(mins).padStart(2, "0");
+  return `${day}T${hh}:${mm}:00`;
+}
+function yPositionToFractionalHour(clientY, columnRect, dayStart, dayEnd) {
+  const relativeY = clientY - columnRect.top;
+  const totalHeight = columnRect.height;
+  const totalHours = dayEnd - dayStart;
+  const hoursFromTop = relativeY / totalHeight * totalHours;
+  return dayStart + hoursFromTop;
+}
+function normalizeRange(a, b) {
+  return a <= b ? { start: a, end: b } : { start: b, end: a };
+}
+function computeDropPosition(day, clientY, columnRect, dayStartHour, dayEndHour, durationMs) {
+  const fractionalHour = yPositionToFractionalHour(clientY, columnRect, dayStartHour, dayEndHour);
+  const snapped = snapToIncrement(fractionalHour, 15);
+  const clamped = Math.max(dayStartHour, Math.min(dayEndHour - durationMs / 36e5, snapped));
+  const newStart = fractionalHourToDateTime(day, clamped);
+  const newStartMs = new Date(newStart).getTime();
+  const newEndDate = new Date(newStartMs + durationMs);
+  const pad = (n) => String(n).padStart(2, "0");
+  const endDay = toDateString(newEndDate);
+  const newEnd = `${endDay}T${pad(newEndDate.getHours())}:${pad(newEndDate.getMinutes())}:${pad(newEndDate.getSeconds())}`;
+  return { newStart, newEnd };
+}
+
+// src/utils/recurrence.ts
+var DAY_MAP = {
+  SU: 0,
+  MO: 1,
+  TU: 2,
+  WE: 3,
+  TH: 4,
+  FR: 5,
+  SA: 6
+};
+var MAX_OCCURRENCES = 730;
+function generateOccurrences(rule, eventStartDate, rangeStart, rangeEnd, exDates = []) {
+  const results = [];
+  const exSet = new Set(exDates);
+  const interval = rule.interval ?? 1;
+  const start = parseDate(eventStartDate);
+  const rEnd = parseDate(rangeEnd);
+  const rStart = parseDate(rangeStart);
+  const untilDate = rule.until ? parseDate(rule.until) : null;
+  const maxCount = rule.count ?? MAX_OCCURRENCES;
+  switch (rule.freq) {
+    case "daily":
+      generateDaily(start, interval, rStart, rEnd, untilDate, maxCount, exSet, results);
+      break;
+    case "weekly":
+      generateWeekly(start, interval, rule.byDay, rStart, rEnd, untilDate, maxCount, exSet, results);
+      break;
+    case "monthly":
+      generateMonthly(start, interval, rule, rStart, rEnd, untilDate, maxCount, exSet, results);
+      break;
+    case "yearly":
+      generateYearly(start, interval, rStart, rEnd, untilDate, maxCount, exSet, results);
+      break;
+  }
+  return results;
+}
+function generateDaily(start, interval, rangeStart, rangeEnd, until, maxCount, exSet, results) {
+  const cursor = new Date(start);
+  let count = 0;
+  if (cursor < rangeStart && maxCount === MAX_OCCURRENCES) {
+    const daysDiff = Math.floor((rangeStart.getTime() - cursor.getTime()) / (1e3 * 60 * 60 * 24));
+    const stepsToSkip = Math.floor(daysDiff / interval);
+    if (stepsToSkip > 0) {
+      cursor.setDate(cursor.getDate() + stepsToSkip * interval);
+      cursor.setDate(cursor.getDate() - interval);
+    }
+  }
+  while (count < maxCount) {
+    if (until && cursor > until) break;
+    if (cursor > rangeEnd) break;
+    const ds = toDateString(cursor);
+    if (cursor >= rangeStart && !exSet.has(ds)) {
+      results.push(ds);
+    }
+    count++;
+    cursor.setDate(cursor.getDate() + interval);
+  }
+}
+function generateWeekly(start, interval, byDay, rangeStart, rangeEnd, until, maxCount, exSet, results) {
+  const targetDays = byDay ? byDay.map((d) => DAY_MAP[d]).sort((a, b) => a - b) : [start.getDay()];
+  const cursor = new Date(start);
+  cursor.setDate(cursor.getDate() - cursor.getDay());
+  if (cursor < rangeStart && maxCount === MAX_OCCURRENCES) {
+    const daysDiff = Math.floor((rangeStart.getTime() - cursor.getTime()) / (1e3 * 60 * 60 * 24));
+    const weeksToSkip = Math.floor(daysDiff / (7 * interval));
+    if (weeksToSkip > 1) {
+      cursor.setDate(cursor.getDate() + (weeksToSkip - 1) * 7 * interval);
+    }
+  }
+  let count = 0;
+  while (count < maxCount) {
+    if (until && cursor > until) break;
+    if (cursor > rangeEnd && results.length > 0) break;
+    if (cursor.getTime() > rangeEnd.getTime() + 7 * 24 * 60 * 60 * 1e3) break;
+    const weekStart = new Date(cursor);
+    for (const dayNum of targetDays) {
+      const candidate = new Date(weekStart);
+      candidate.setDate(weekStart.getDate() + dayNum);
+      if (candidate < start) continue;
+      if (until && candidate > until) break;
+      if (count >= maxCount) break;
+      const ds = toDateString(candidate);
+      if (candidate >= rangeStart && candidate <= rangeEnd && !exSet.has(ds)) {
+        results.push(ds);
+      }
+      count++;
+    }
+    cursor.setDate(cursor.getDate() + 7 * interval);
+  }
+}
+function generateMonthly(start, interval, rule, rangeStart, rangeEnd, until, maxCount, exSet, results) {
+  const cursor = new Date(start.getFullYear(), start.getMonth(), 1);
+  let count = 0;
+  if (cursor < rangeStart && maxCount === MAX_OCCURRENCES) {
+    const monthsDiff = (rangeStart.getFullYear() - cursor.getFullYear()) * 12 + (rangeStart.getMonth() - cursor.getMonth());
+    const monthsToSkip = Math.floor(monthsDiff / interval);
+    if (monthsToSkip > 1) {
+      cursor.setMonth(cursor.getMonth() + (monthsToSkip - 1) * interval);
+    }
+  }
+  while (count < maxCount) {
+    if (until && cursor > until) break;
+    if (cursor.getTime() > rangeEnd.getTime() + 31 * 24 * 60 * 60 * 1e3) break;
+    const candidates = [];
+    if (rule.byDay && rule.bySetPos !== void 0) {
+      for (const dayStr of rule.byDay) {
+        const dayNum = DAY_MAP[dayStr];
+        const found = getNthWeekdayOfMonth(cursor.getFullYear(), cursor.getMonth(), dayNum, rule.bySetPos);
+        if (found) candidates.push(found);
+      }
+    } else if (rule.byMonthDay && rule.byMonthDay.length > 0) {
+      for (const md of rule.byMonthDay) {
+        const daysInMonth = new Date(cursor.getFullYear(), cursor.getMonth() + 1, 0).getDate();
+        if (md <= daysInMonth) {
+          candidates.push(new Date(cursor.getFullYear(), cursor.getMonth(), md));
+        }
+      }
+    } else {
+      const daysInMonth = new Date(cursor.getFullYear(), cursor.getMonth() + 1, 0).getDate();
+      const dayOfMonth = Math.min(start.getDate(), daysInMonth);
+      candidates.push(new Date(cursor.getFullYear(), cursor.getMonth(), dayOfMonth));
+    }
+    for (const candidate of candidates) {
+      if (candidate < start) continue;
+      if (until && candidate > until) break;
+      if (count >= maxCount) break;
+      const ds = toDateString(candidate);
+      if (candidate >= rangeStart && candidate <= rangeEnd && !exSet.has(ds)) {
+        results.push(ds);
+      }
+      count++;
+    }
+    cursor.setMonth(cursor.getMonth() + interval);
+  }
+}
+function generateYearly(start, interval, rangeStart, rangeEnd, until, maxCount, exSet, results) {
+  const cursor = new Date(start);
+  let count = 0;
+  while (count < maxCount) {
+    if (until && cursor > until) break;
+    if (cursor > rangeEnd) break;
+    const ds = toDateString(cursor);
+    if (cursor >= rangeStart && !exSet.has(ds)) {
+      results.push(ds);
+    }
+    count++;
+    cursor.setFullYear(cursor.getFullYear() + interval);
+    if (start.getMonth() === 1 && start.getDate() === 29) {
+      const daysInFeb = new Date(cursor.getFullYear(), 2, 0).getDate();
+      cursor.setMonth(1, Math.min(29, daysInFeb));
+    }
+  }
+}
+function getNthWeekdayOfMonth(year, month, dayOfWeek, n) {
+  if (n > 0) {
+    const first = new Date(year, month, 1);
+    const firstDayOfWeek = first.getDay();
+    let dayOfMonth = 1 + (dayOfWeek - firstDayOfWeek + 7) % 7 + (n - 1) * 7;
+    const daysInMonth = new Date(year, month + 1, 0).getDate();
+    if (dayOfMonth > daysInMonth) return null;
+    return new Date(year, month, dayOfMonth);
+  } else if (n === -1) {
+    const last = new Date(year, month + 1, 0);
+    const lastDayOfWeek = last.getDay();
+    const diff = (lastDayOfWeek - dayOfWeek + 7) % 7;
+    return new Date(year, month, last.getDate() - diff);
+  }
+  return null;
+}
+function expandRecurringEvents(events, rangeStart, rangeEnd) {
+  const result = [];
+  for (const event of events) {
+    if (event.recurringEventId) {
+      result.push(event);
+      continue;
+    }
+    if (!event.recurrence) {
+      result.push(event);
+      continue;
+    }
+    const eventStartDate = event.start.slice(0, 10);
+    const eventStartTime = event.start.length > 10 ? event.start.slice(10) : "T00:00:00";
+    const eventEndTime = event.end.length > 10 ? event.end.slice(10) : "T23:59:00";
+    const startD = parseDate(event.start);
+    const endD = parseDate(event.end);
+    const durationDays = Math.floor((endD.getTime() - startD.getTime()) / (1e3 * 60 * 60 * 24));
+    const occurrences = generateOccurrences(
+      event.recurrence,
+      eventStartDate,
+      rangeStart,
+      rangeEnd,
+      event.exDates
+    );
+    for (const occ of occurrences) {
+      const instanceId = `${event.id}::${occ}`;
+      let instanceEnd = `${occ}${eventEndTime}`;
+      if (durationDays > 0) {
+        const occDate = parseDate(occ);
+        occDate.setDate(occDate.getDate() + durationDays);
+        instanceEnd = `${toDateString(occDate)}${eventEndTime}`;
+      }
+      result.push({
+        ...event,
+        id: instanceId,
+        start: `${occ}${eventStartTime}`,
+        end: instanceEnd,
+        recurringEventId: event.id,
+        originalDate: occ,
+        // Don't carry over recurrence to instances
+        recurrence: void 0,
+        exDates: void 0
+      });
+    }
+  }
+  return result;
+}
+var FREQ_MAP = {
+  DAILY: "daily",
+  WEEKLY: "weekly",
+  MONTHLY: "monthly",
+  YEARLY: "yearly"
+};
+var FREQ_REVERSE = {
+  daily: "DAILY",
+  weekly: "WEEKLY",
+  monthly: "MONTHLY",
+  yearly: "YEARLY"
+};
+function parseRRule(rruleString) {
+  const str = rruleString.replace(/^RRULE:/, "");
+  const parts = str.split(";");
+  const rule = { freq: "daily" };
+  for (const part of parts) {
+    const [key, value] = part.split("=");
+    switch (key) {
+      case "FREQ":
+        rule.freq = FREQ_MAP[value] ?? "daily";
+        break;
+      case "INTERVAL":
+        rule.interval = parseInt(value, 10);
+        break;
+      case "COUNT":
+        rule.count = parseInt(value, 10);
+        break;
+      case "UNTIL": {
+        const dateStr = value.replace(/[TZ]/g, "").slice(0, 8);
+        rule.until = `${dateStr.slice(0, 4)}-${dateStr.slice(4, 6)}-${dateStr.slice(6, 8)}`;
+        break;
+      }
+      case "BYDAY":
+        rule.byDay = value.split(",").map((d) => {
+          return d.replace(/^-?\d+/, "");
+        });
+        break;
+      case "BYMONTHDAY":
+        rule.byMonthDay = value.split(",").map(Number);
+        break;
+      case "BYSETPOS":
+        rule.bySetPos = parseInt(value, 10);
+        break;
+    }
+  }
+  return rule;
+}
+function toRRuleString(rule) {
+  const parts = [];
+  parts.push(`FREQ=${FREQ_REVERSE[rule.freq]}`);
+  if (rule.interval && rule.interval > 1) {
+    parts.push(`INTERVAL=${rule.interval}`);
+  }
+  if (rule.count) {
+    parts.push(`COUNT=${rule.count}`);
+  }
+  if (rule.until) {
+    parts.push(`UNTIL=${rule.until.replace(/-/g, "")}`);
+  }
+  if (rule.byDay && rule.byDay.length > 0) {
+    parts.push(`BYDAY=${rule.byDay.join(",")}`);
+  }
+  if (rule.byMonthDay && rule.byMonthDay.length > 0) {
+    parts.push(`BYMONTHDAY=${rule.byMonthDay.join(",")}`);
+  }
+  if (rule.bySetPos !== void 0) {
+    parts.push(`BYSETPOS=${rule.bySetPos}`);
+  }
+  return parts.join(";");
+}
+
+// src/utils/virtualize.ts
+function filterVisibleEvents(positioned, viewportTop, viewportBottom, overscan = 10) {
+  const top = viewportTop - overscan;
+  const bottom = viewportBottom + overscan;
+  return positioned.filter(
+    (p) => p.top + p.height > top && p.top < bottom
+  );
+}
+function scrollToViewportRange(scrollTop, containerHeight, totalHeight, dayStartHour, dayEndHour) {
+  if (totalHeight <= 0) {
+    return { startHour: dayStartHour, endHour: dayEndHour };
+  }
+  const totalHours = dayEndHour - dayStartHour;
+  const topFraction = scrollTop / totalHeight;
+  const bottomFraction = (scrollTop + containerHeight) / totalHeight;
+  return {
+    startHour: dayStartHour + topFraction * totalHours,
+    endHour: dayStartHour + bottomFraction * totalHours
+  };
+}
+
+// src/utils/undo.ts
+var DEFAULT_MAX_HISTORY = 30;
+function createUndoStack(initial) {
+  return {
+    past: [],
+    present: initial,
+    future: []
+  };
+}
+function pushState(stack, state, maxHistory = DEFAULT_MAX_HISTORY) {
+  const past = [...stack.past, stack.present];
+  return {
+    past: past.length > maxHistory ? past.slice(past.length - maxHistory) : past,
+    present: state,
+    future: []
+  };
+}
+function undo(stack) {
+  if (stack.past.length === 0) {
+    return stack;
+  }
+  const previous = stack.past[stack.past.length - 1];
+  const newPast = stack.past.slice(0, -1);
+  return {
+    past: newPast,
+    present: previous,
+    future: [stack.present, ...stack.future]
+  };
+}
+function redo(stack) {
+  if (stack.future.length === 0) {
+    return stack;
+  }
+  const next = stack.future[0];
+  const newFuture = stack.future.slice(1);
+  return {
+    past: [...stack.past, stack.present],
+    present: next,
+    future: newFuture
+  };
+}
+function canUndo(stack) {
+  return stack.past.length > 0;
+}
+function canRedo(stack) {
+  return stack.future.length > 0;
+}
+
+export { DEFAULT_DAY_END_HOUR, DEFAULT_DAY_START_HOUR, DEFAULT_LABELS, DEFAULT_LOCALE, DEFAULT_VIEW, HOURS_IN_DAY, MINUTES_IN_DAY, MINUTES_IN_HOUR, VIEWS, addDays, addMonths, addWeeks, assignColumns, buildOverlapGroups, calendarReducer, canRedo, canUndo, computeDropPosition, computeTimePositions, createInitialState, createUndoStack, dateInRange, daysBetween, eachDayOfRange, endOfMonth, expandRecurringEvents, filterEventsInRange, filterVisibleEvents, formatAgendaDate, formatDayNumber, formatMonthDay, formatTime, formatTimeRange, formatToolbarTitle, formatWeekdayNarrow, formatWeekdayShort, fractionalHourToDateTime, generateOccurrences, getDurationHours, getEventSegments, getEventsForDay, getHourLabels, getMonthViewRange, getTimeOfDay, getVisibleRange, getWeekDays, getWeekViewRange, groupEventsByDate, isAfter, isBefore, isMultiDayEvent, isSameDay, isSameMonth, isToday, normalizeRange, parseDate, parseRRule, partitionEvents, pushState, rangesOverlap, redo, scrollToViewportRange, segmentMultiDayEvent, segmentTimedMultiDayEvent, snapToIncrement, sortEvents, startOfMonth, startOfWeek, toDateString, toDateTimeString, toRRuleString, undo, yPositionToFractionalHour };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map