@primeui/scheduler-core 0.0.1-alpha.1

package/dist/chunk-6VYWVIGM.mjs

@@ -0,0 +1,1170 @@
+import { filterEventsForDay, sortEvents, eventsOverlap, getEventStartMinutes, getEventEndMinutes } from './chunk-2B3YLWHA.mjs';
+import { isSchedulerAutoTextColor, markSchedulerAutoTextColor, filterEventsByCategory, getEventCategoryStyle, calculateContrastTextColor } from './chunk-C7ADJGNV.mjs';
+import { resolveSchedulerEventSurfaceColor } from './chunk-5KORIWDT.mjs';
+import { parseRRule, serializeRRule, expandRRule } from './chunk-FIBAZFC4.mjs';
+import { getLocalTimezone, convertEventsToTimezone } from './chunk-QDMZBJDV.mjs';
+
+// src/event/event-list.ts
+function upsertEventById(eventList, event) {
+  const index = eventList.findIndex((item) => item.id === event.id);
+  if (index === -1) {
+    return [...eventList, event];
+  }
+  const next = [...eventList];
+  next[index] = event;
+  return next;
+}
+function removeEventById(eventList, eventId) {
+  const index = eventList.findIndex((event) => event.id === eventId);
+  if (index === -1) {
+    return eventList;
+  }
+  return eventList.filter((event) => event.id !== eventId);
+}
+
+// src/event/event.positioning.ts
+function timeStringToMinutes(time) {
+  const [hours, minutes] = time.split(":").map(Number);
+  return hours * 60 + (minutes || 0);
+}
+var DEFAULT_TITLE_HEIGHT_MINUTES = 45;
+function findOverlapGroups(events) {
+  if (events.length === 0) return [];
+  const sorted = [...events].sort((a, b) => {
+    const startDiff = a.start.getTime() - b.start.getTime();
+    if (startDiff !== 0) return startDiff;
+    return b.durationMinutes - a.durationMinutes;
+  });
+  const groups = [];
+  const assigned = /* @__PURE__ */ new Set();
+  for (const event of sorted) {
+    if (assigned.has(event)) continue;
+    const group = [event];
+    assigned.add(event);
+    let changed = true;
+    while (changed) {
+      changed = false;
+      for (const other of sorted) {
+        if (assigned.has(other)) continue;
+        const overlapsWithGroup = group.some((groupEvent) => eventsOverlap(groupEvent, other));
+        if (overlapsWithGroup) {
+          group.push(other);
+          assigned.add(other);
+          changed = true;
+        }
+      }
+    }
+    groups.push(group);
+  }
+  return groups;
+}
+function assignColumnsWithinGroup(events, titleHeightMinutes) {
+  const result = /* @__PURE__ */ new Map();
+  if (events.length === 0) return result;
+  const sorted = [...events].sort((a, b) => {
+    const startDiff = a.start.getTime() - b.start.getTime();
+    if (startDiff !== 0) return startDiff;
+    return b.durationMinutes - a.durationMinutes;
+  });
+  const columns = [];
+  const processedEvents = [];
+  const eventColumnMap = /* @__PURE__ */ new Map();
+  for (const event of sorted) {
+    const eventStart = getEventStartMinutes(event);
+    const eventEnd = getEventEndMinutes(event);
+    const eventTitleEnd = eventStart + titleHeightMinutes;
+    let assignedColumn = -1;
+    for (let colIndex = 0; colIndex < columns.length; colIndex++) {
+      const column = columns[colIndex];
+      let canFit = true;
+      for (const slot of column) {
+        const timesOverlap = eventStart < slot.endMinutes && eventEnd > slot.startMinutes;
+        if (!timesOverlap) continue;
+        const titleOverlap = eventStart < slot.titleEndMinutes && eventTitleEnd > slot.startMinutes;
+        if (titleOverlap) {
+          canFit = false;
+          break;
+        }
+      }
+      if (canFit) {
+        assignedColumn = colIndex;
+        break;
+      }
+    }
+    if (assignedColumn === -1) {
+      assignedColumn = columns.length;
+      columns.push([]);
+    }
+    let nestingDepth = 0;
+    for (const processed of processedEvents) {
+      const otherStart = getEventStartMinutes(processed.event);
+      const otherEnd = getEventEndMinutes(processed.event);
+      const otherTitleEnd = otherStart + titleHeightMinutes;
+      const timesOverlap = eventStart < otherEnd && eventEnd > otherStart;
+      if (!timesOverlap) continue;
+      const titleOverlap = eventStart < otherTitleEnd && eventTitleEnd > otherStart;
+      if (!titleOverlap) {
+        nestingDepth = Math.max(nestingDepth, processed.nestingDepth + 1);
+      }
+    }
+    columns[assignedColumn].push({
+      event,
+      startMinutes: eventStart,
+      endMinutes: eventEnd,
+      titleEndMinutes: eventTitleEnd
+    });
+    processedEvents.push({ event, nestingDepth, column: assignedColumn });
+    eventColumnMap.set(event, assignedColumn);
+    result.set(event, { column: assignedColumn, totalColumns: 0, nestingDepth });
+  }
+  for (const event of sorted) {
+    const assignment = result.get(event);
+    const eventStart = getEventStartMinutes(event);
+    const eventEnd = getEventEndMinutes(event);
+    const eventTitleEnd = eventStart + titleHeightMinutes;
+    const columnsUsed = /* @__PURE__ */ new Set();
+    columnsUsed.add(assignment.column);
+    for (const other of sorted) {
+      if (other === event) continue;
+      const otherStart = getEventStartMinutes(other);
+      const otherEnd = getEventEndMinutes(other);
+      const otherTitleEnd = otherStart + titleHeightMinutes;
+      const timesOverlap = eventStart < otherEnd && eventEnd > otherStart;
+      if (!timesOverlap) continue;
+      const titleOverlap = eventStart < otherTitleEnd && eventTitleEnd > otherStart;
+      if (titleOverlap) {
+        columnsUsed.add(eventColumnMap.get(other));
+      }
+    }
+    assignment.totalColumns = columnsUsed.size;
+  }
+  return result;
+}
+var NESTING_INDENT_PERCENT = 5;
+function calculateEventPositionGoogle(event, column, totalColumns, nestingDepth, options) {
+  const { slotMinTime, slotMaxTime, slotDuration, slotHeight } = options;
+  const minMinutes = timeStringToMinutes(slotMinTime);
+  const maxMinutes = timeStringToMinutes(slotMaxTime);
+  const totalMinutes = maxMinutes - minMinutes;
+  let eventStartMinutes = event.start.getHours() * 60 + event.start.getMinutes();
+  let eventEndMinutes = event.end.getHours() * 60 + event.end.getMinutes();
+  if (eventEndMinutes === 0) eventEndMinutes = 24 * 60;
+  eventStartMinutes = Math.max(eventStartMinutes, minMinutes);
+  eventEndMinutes = Math.min(eventEndMinutes, maxMinutes);
+  const totalSlots = totalMinutes / slotDuration;
+  const totalHeight = totalSlots * slotHeight;
+  const top = (eventStartMinutes - minMinutes) / totalMinutes * totalHeight;
+  const height = Math.max((eventEndMinutes - eventStartMinutes) / totalMinutes * totalHeight, slotHeight / 2);
+  const nestingIndent = nestingDepth * NESTING_INDENT_PERCENT;
+  const availableWidth = 100 - nestingIndent;
+  const columnWidthPercent = availableWidth / totalColumns;
+  const left = nestingIndent + column * columnWidthPercent;
+  const width = columnWidthPercent;
+  return {
+    top: Math.round(top * 100) / 100,
+    height: Math.round(height * 100) / 100,
+    left,
+    width: Math.max(width, 10)
+  };
+}
+function positionEventsForDay(events, date, options) {
+  const dayEvents = filterEventsForDay(events, date);
+  const timedEvents = dayEvents.filter((e) => !e.allDay && !e.isMultiDay);
+  const sorted = sortEvents(timedEvents);
+  const titleHeightMinutes = options.titleHeight ?? DEFAULT_TITLE_HEIGHT_MINUTES;
+  const groups = findOverlapGroups(sorted);
+  const positioned = [];
+  for (const group of groups) {
+    const columnAssignments = assignColumnsWithinGroup(group, titleHeightMinutes);
+    for (const event of group) {
+      const assignment = columnAssignments.get(event);
+      if (!assignment) continue;
+      const { column, totalColumns, nestingDepth } = assignment;
+      const position = calculateEventPositionGoogle(event, column, totalColumns, nestingDepth, options);
+      positioned.push({
+        ...event,
+        column,
+        totalColumns,
+        zIndex: 1,
+        ...position
+      });
+    }
+  }
+  const stackingOrder = [...positioned].sort((a, b) => {
+    const topDiff = b.top - a.top;
+    if (Math.abs(topDiff) > 0.01) {
+      return topDiff;
+    }
+    const leftDiff = b.left - a.left;
+    if (Math.abs(leftDiff) > 0.01) {
+      return leftDiff;
+    }
+    const widthDiff = a.width - b.width;
+    if (Math.abs(widthDiff) > 0.01) {
+      return widthDiff;
+    }
+    return a.height - b.height;
+  });
+  stackingOrder.forEach((event, index) => {
+    event.zIndex = stackingOrder.length - index;
+  });
+  return positioned;
+}
+function calculateEventPosition(event, column, totalColumns, options, nestingDepth = 0) {
+  return calculateEventPositionGoogle(event, column, totalColumns, nestingDepth, options);
+}
+function getAllDayEventsForDay(events, date) {
+  const dayEvents = filterEventsForDay(events, date);
+  return sortEvents(dayEvents.filter((e) => e.allDay || e.isMultiDay));
+}
+function positionAllDayEventsForWeek(events, weekStart, weekEnd) {
+  const positioned = [];
+  const allDayEvents = events.filter((event) => {
+    const overlapsWeek = event.start <= weekEnd && event.end >= weekStart;
+    return overlapsWeek && (event.allDay || event.isMultiDay);
+  }).map((event) => {
+    const eventStart = event.start < weekStart ? weekStart : event.start;
+    const eventEnd = event.end > weekEnd ? weekEnd : event.end;
+    const startCol = Math.floor((eventStart.getTime() - weekStart.getTime()) / (1e3 * 60 * 60 * 24));
+    const endCol = Math.floor((eventEnd.getTime() - weekStart.getTime()) / (1e3 * 60 * 60 * 24));
+    return {
+      event,
+      eventStart,
+      eventEnd,
+      startCol,
+      endCol
+    };
+  });
+  const sorted = [...allDayEvents].sort((a, b) => {
+    if (a.startCol !== b.startCol) return a.startCol - b.startCol;
+    const spanA = a.endCol - a.startCol;
+    const spanB = b.endCol - b.startCol;
+    if (spanA !== spanB) return spanB - spanA;
+    const startDiff = a.event.start.getTime() - b.event.start.getTime();
+    if (startDiff !== 0) return startDiff;
+    const durationDiff = b.event.durationMinutes - a.event.durationMinutes;
+    if (durationDiff !== 0) return durationDiff;
+    return String(a.event.id ?? "").localeCompare(String(b.event.id ?? ""));
+  });
+  const rowEndDates = [];
+  for (const eventPosition of sorted) {
+    let assignedRow = -1;
+    for (let row = 0; row < rowEndDates.length; row++) {
+      if (rowEndDates[row] < eventPosition.eventStart) {
+        assignedRow = row;
+        rowEndDates[row] = eventPosition.eventEnd;
+        break;
+      }
+    }
+    if (assignedRow === -1) {
+      assignedRow = rowEndDates.length;
+      rowEndDates.push(eventPosition.eventEnd);
+    }
+    positioned.push({
+      event: eventPosition.event,
+      row: assignedRow,
+      startCol: eventPosition.startCol,
+      endCol: eventPosition.endCol,
+      isStart: eventPosition.event.start >= weekStart,
+      isEnd: eventPosition.event.end <= weekEnd
+    });
+  }
+  return positioned;
+}
+function getTimedEventsForDay(events, date) {
+  const dayStart = new Date(date.getFullYear(), date.getMonth(), date.getDate(), 0, 0, 0, 0);
+  const dayEnd = new Date(date.getFullYear(), date.getMonth(), date.getDate(), 23, 59, 59, 999);
+  return events.filter((event) => {
+    if (event.allDay || event.isMultiDay) return false;
+    return event.start >= dayStart && event.start <= dayEnd;
+  }).sort((a, b) => a.start.getTime() - b.start.getTime());
+}
+function positionEventsForWeekRow(events, weekStart, weekEnd, maxEventsPerDay = 3) {
+  const positioned = positionAllDayEventsForWeek(events, weekStart, weekEnd);
+  const timedEventsByDay = /* @__PURE__ */ new Map();
+  for (let dayIndex = 0; dayIndex < 7; dayIndex++) {
+    const dayDate = new Date(weekStart.getTime() + dayIndex * 24 * 60 * 60 * 1e3);
+    const timedEvents = getTimedEventsForDay(events, dayDate);
+    timedEventsByDay.set(dayIndex, timedEvents);
+  }
+  const overflow = /* @__PURE__ */ new Map();
+  const rowsUsedByDay = /* @__PURE__ */ new Map();
+  for (const pos of positioned) {
+    for (let col = pos.startCol; col <= pos.endCol; col++) {
+      if (!rowsUsedByDay.has(col)) {
+        rowsUsedByDay.set(col, /* @__PURE__ */ new Set());
+      }
+      rowsUsedByDay.get(col).add(pos.row);
+    }
+  }
+  for (let dayIndex = 0; dayIndex < 7; dayIndex++) {
+    const rowsUsed = rowsUsedByDay.get(dayIndex)?.size || 0;
+    const timedEvents = timedEventsByDay.get(dayIndex) || [];
+    const timedCount = timedEvents.length;
+    const totalItems = rowsUsed + timedCount;
+    const availableSlots = maxEventsPerDay;
+    if (totalItems > availableSlots) {
+      const overflowCount = totalItems - availableSlots + 1;
+      overflow.set(dayIndex, overflowCount);
+    }
+  }
+  return { positioned, timedEventsByDay, overflow };
+}
+
+// src/event/pipeline.ts
+function toDate(value) {
+  if (!value) return null;
+  return value instanceof Date ? value : new Date(value);
+}
+function getFallbackEnd(start, event) {
+  if (typeof event.duration === "number" && Number.isFinite(event.duration) && event.duration > 0) {
+    return new Date(start.getTime() + event.duration);
+  }
+  return new Date(start.getTime() + 60 * 60 * 1e3);
+}
+function normalizeSchedulerEventToDisplayTimezone(event, schedulerTimezone, displayTimezone) {
+  const start = toDate(event.start);
+  if (!start) {
+    return event;
+  }
+  const end = toDate(event.end) ?? getFallbackEnd(start, event);
+  const sourceTimezone = event.timezone ?? schedulerTimezone ?? getLocalTimezone();
+  const normalized = {
+    ...event,
+    start,
+    end,
+    timezone: sourceTimezone
+  };
+  if (sourceTimezone === displayTimezone) {
+    const nextEvent2 = {
+      ...normalized,
+      timezone: displayTimezone
+    };
+    return isSchedulerAutoTextColor(event) ? markSchedulerAutoTextColor(nextEvent2) : nextEvent2;
+  }
+  const [converted] = convertEventsToTimezone([normalized], displayTimezone);
+  const nextEvent = {
+    ...converted,
+    timezone: displayTimezone
+  };
+  return isSchedulerAutoTextColor(event) ? markSchedulerAutoTextColor(nextEvent) : nextEvent;
+}
+function normalizeSchedulerEventsToDisplayTimezone(events, schedulerTimezone, resolvedDisplayTimezone) {
+  if (!resolvedDisplayTimezone) {
+    return events;
+  }
+  return events.map((event) => normalizeSchedulerEventToDisplayTimezone(event, schedulerTimezone, resolvedDisplayTimezone));
+}
+function hasRecurrenceRule(event) {
+  return event.rrule != null;
+}
+function expandSchedulerEvents(events, dateRange) {
+  const out = [];
+  for (const event of events) {
+    if (!hasRecurrenceRule(event)) {
+      out.push(event);
+      continue;
+    }
+    try {
+      const expanded = expandRRule(event, dateRange.start, dateRange.end);
+      if (Array.isArray(expanded) && expanded.length > 0) {
+        for (const occurrence of expanded) {
+          out.push(occurrence);
+        }
+      } else {
+        out.push(event);
+      }
+    } catch {
+      out.push(event);
+    }
+  }
+  return out;
+}
+function countEventsByCategory(events, categoryField) {
+  const counts = {};
+  for (const event of events) {
+    const rawEvent = event;
+    const categoryId = rawEvent[categoryField] ?? event.metadata?.[categoryField];
+    if (categoryId !== void 0 && categoryId !== null) {
+      counts[categoryId] = (counts[categoryId] ?? 0) + 1;
+    }
+  }
+  return counts;
+}
+function enrichEventCategoryStyles(events, categories, categoryField, categoryAutoTextColor, eventShell) {
+  if (categories.length === 0) {
+    return events;
+  }
+  const preserveCategoryTextColor = eventShell === "none";
+  return events.map((event) => {
+    const categoryId = event[categoryField];
+    if (categoryId == null) return event;
+    const category = categories.find((item) => item.id === categoryId);
+    if (!category) return event;
+    const style = getEventCategoryStyle(event, categories, categoryField);
+    const color = event.color ?? style.background ?? category.color;
+    let textColor = event.textColor;
+    let isAutoTextColor = false;
+    if (!textColor && preserveCategoryTextColor) {
+      textColor = style.color ?? category.textColor;
+      if (!textColor && categoryAutoTextColor && (color || category.color)) {
+        try {
+          textColor = calculateContrastTextColor(color || category.color);
+          isAutoTextColor = true;
+        } catch {
+          textColor = void 0;
+        }
+      }
+    }
+    if (!textColor) {
+      return { ...event, color };
+    }
+    const nextEvent = { ...event, color, textColor };
+    return isAutoTextColor ? markSchedulerAutoTextColor(nextEvent) : nextEvent;
+  });
+}
+function buildEventSurfaceColors(events, context) {
+  const colors = /* @__PURE__ */ new Map();
+  for (const event of events) {
+    colors.set(event.id, resolveSchedulerEventSurfaceColor(event, context));
+  }
+  return colors;
+}
+function getRangeTime(value) {
+  return value.getTime();
+}
+function normalizeActiveCategoryIdsKey(activeCategoryIds) {
+  if (!activeCategoryIds || activeCategoryIds.length === 0) {
+    return "";
+  }
+  const normalized = new Set(activeCategoryIds.map((id) => `${typeof id}:${String(id)}`));
+  return JSON.stringify([...normalized].sort());
+}
+function createSchedulerEventPipelineMemoKey(input) {
+  return {
+    events: input.events,
+    dateRangeStart: getRangeTime(input.dateRange.start),
+    dateRangeEnd: getRangeTime(input.dateRange.end),
+    categories: input.categories,
+    categoryField: input.categoryField ?? "categoryId",
+    categoryAutoTextColor: input.categoryAutoTextColor ?? false,
+    eventShell: input.eventShell ?? "default",
+    activeCategoryIdsKey: normalizeActiveCategoryIdsKey(input.activeCategoryIds),
+    resources: input.resources,
+    schedulerTimezone: input.schedulerTimezone,
+    resolvedDisplayTimezone: input.resolvedDisplayTimezone
+  };
+}
+function areSchedulerEventPipelineMemoKeysEqual(a, b) {
+  return a.events === b.events && Object.is(a.dateRangeStart, b.dateRangeStart) && Object.is(a.dateRangeEnd, b.dateRangeEnd) && a.categories === b.categories && a.categoryField === b.categoryField && a.categoryAutoTextColor === b.categoryAutoTextColor && a.eventShell === b.eventShell && a.activeCategoryIdsKey === b.activeCategoryIdsKey && a.resources === b.resources && a.schedulerTimezone === b.schedulerTimezone && a.resolvedDisplayTimezone === b.resolvedDisplayTimezone;
+}
+function buildSchedulerEventPipeline(input) {
+  const rawEvents = input.events;
+  const categories = input.categories ?? [];
+  const categoryField = input.categoryField ?? "categoryId";
+  const activeCategoryIds = input.activeCategoryIds ?? [];
+  const expandedEvents = expandSchedulerEvents(rawEvents, input.dateRange);
+  const filteredEvents = activeCategoryIds.length > 0 && categories.length > 0 ? filterEventsByCategory(expandedEvents, activeCategoryIds, categories, categoryField, false) : expandedEvents;
+  const categoryFilteredEvents = enrichEventCategoryStyles(filteredEvents, categories, categoryField, input.categoryAutoTextColor ?? false, input.eventShell ?? "default");
+  const displayTimezoneEvents = normalizeSchedulerEventsToDisplayTimezone(categoryFilteredEvents, input.schedulerTimezone, input.resolvedDisplayTimezone);
+  const categoryCounts = countEventsByCategory(rawEvents, categoryField);
+  const eventSurfaceContext = {
+    resources: input.resources,
+    categories,
+    categoryField
+  };
+  return {
+    rawEvents,
+    expandedEvents,
+    categoryFilteredEvents,
+    displayTimezoneEvents,
+    categoryCounts,
+    eventSurfaceContext,
+    eventSurfaceColors: buildEventSurfaceColors(categoryFilteredEvents, eventSurfaceContext)
+  };
+}
+function createSchedulerEventPipelineMemo() {
+  let previous = null;
+  return (input) => {
+    const key = createSchedulerEventPipelineMemoKey(input);
+    if (previous && areSchedulerEventPipelineMemoKeysEqual(previous.key, key)) {
+      return previous.result;
+    }
+    const result = buildSchedulerEventPipeline(input);
+    previous = { key, result };
+    return result;
+  };
+}
+
+// src/event/recurrence-edit.ts
+var DEFAULT_RECURRENCE_EDIT_OPTIONS = {
+  editModes: ["this", "all", "future"],
+  deleteModes: ["this", "all", "future"],
+  dragMode: "ask",
+  resizeMode: "ask",
+  confirmDialog: true,
+  allowExceptions: true
+};
+function normalizeRecurrenceEditOptions(options) {
+  if (options === false || options === void 0) {
+    return { ...DEFAULT_RECURRENCE_EDIT_OPTIONS, editModes: [], deleteModes: [] };
+  }
+  if (options === true) {
+    return { ...DEFAULT_RECURRENCE_EDIT_OPTIONS };
+  }
+  return { ...DEFAULT_RECURRENCE_EDIT_OPTIONS, ...options };
+}
+function dateToKey(date) {
+  const d = typeof date === "string" ? new Date(date) : date;
+  return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, "0")}-${String(d.getDate()).padStart(2, "0")}`;
+}
+function isSameDay(date1, date2) {
+  return dateToKey(date1) === dateToKey(date2);
+}
+function toDate2(date) {
+  return typeof date === "string" ? new Date(date) : new Date(date);
+}
+function editThisOnly(series, occurrence, changes) {
+  const originalStart = toDate2(occurrence.start);
+  const existingExceptions = series.exceptions || [];
+  const existingIndex = existingExceptions.findIndex((ex) => isSameDay(ex.originalStart, originalStart));
+  let exception;
+  if (existingIndex >= 0) {
+    exception = {
+      ...existingExceptions[existingIndex],
+      event: {
+        ...existingExceptions[existingIndex].event,
+        ...changes
+      }
+    };
+  } else {
+    exception = {
+      recurrenceId: originalStart,
+      originalStart,
+      event: {
+        id: `${series.id}_exc_${originalStart.getTime()}`,
+        title: series.title,
+        start: occurrence.start,
+        end: occurrence.end,
+        duration: series.duration,
+        allDay: series.allDay,
+        color: series.color,
+        textColor: series.textColor,
+        className: series.className,
+        editable: series.editable,
+        draggable: series.draggable,
+        resizable: series.resizable,
+        metadata: series.metadata,
+        ...changes
+      }
+    };
+  }
+  const newExceptions = existingIndex >= 0 ? existingExceptions.map((ex, i) => i === existingIndex ? exception : ex) : [...existingExceptions, exception];
+  return {
+    series: {
+      ...series,
+      exceptions: newExceptions
+    },
+    exception
+  };
+}
+function editAll(series, changes) {
+  const { start: changesStart, end: changesEnd, ...otherChanges } = changes;
+  const updatedSeries = {
+    ...series,
+    ...otherChanges
+  };
+  if (changesStart !== void 0) {
+    const originalStart = toDate2(series.start);
+    const newStart = toDate2(changesStart);
+    const updatedStart = new Date(originalStart);
+    updatedStart.setHours(newStart.getHours(), newStart.getMinutes(), newStart.getSeconds(), newStart.getMilliseconds());
+    updatedSeries.start = updatedStart;
+  }
+  if (changesEnd !== void 0 && series.end !== void 0) {
+    const originalEnd = toDate2(series.end);
+    const newEnd = toDate2(changesEnd);
+    const updatedEnd = new Date(originalEnd);
+    updatedEnd.setHours(newEnd.getHours(), newEnd.getMinutes(), newEnd.getSeconds(), newEnd.getMilliseconds());
+    updatedSeries.end = updatedEnd;
+  }
+  if (otherChanges.rrule !== void 0) {
+    updatedSeries.rrule = otherChanges.rrule;
+  }
+  return { series: updatedSeries };
+}
+function editThisAndFuture(series, occurrence, changes) {
+  const splitDate = toDate2(occurrence.start);
+  const dayBefore = new Date(splitDate);
+  dayBefore.setDate(dayBefore.getDate() - 1);
+  const originalRRule = typeof series.rrule === "string" ? parseRRule(series.rrule) : series.rrule;
+  if (!originalRRule) {
+    throw new Error("Cannot split series: invalid RRULE");
+  }
+  const truncatedRRule = {
+    ...originalRRule,
+    until: dayBefore
+  };
+  delete truncatedRRule.count;
+  const originalExceptions = series.exceptions || [];
+  const pastExceptions = originalExceptions.filter((ex) => toDate2(ex.originalStart) < splitDate);
+  const originalExdates = series.exdate || [];
+  const pastExdates = originalExdates.filter((exd) => toDate2(exd) < splitDate);
+  const originalRdates = series.rdate || [];
+  const pastRdates = originalRdates.filter((rd) => toDate2(rd) < splitDate);
+  const originalSeries = {
+    ...series,
+    rrule: truncatedRRule,
+    exdate: pastExdates.length > 0 ? pastExdates : void 0,
+    rdate: pastRdates.length > 0 ? pastRdates : void 0,
+    exceptions: pastExceptions.length > 0 ? pastExceptions : void 0
+  };
+  const newSeriesRRule = changes.rrule ? typeof changes.rrule === "string" ? parseRRule(changes.rrule) || originalRRule : changes.rrule : { ...originalRRule };
+  if (newSeriesRRule.until) {
+    const originalUntil = toDate2(newSeriesRRule.until);
+    if (originalUntil < splitDate) {
+      delete newSeriesRRule.until;
+    }
+  }
+  const newSeriesId = `${series.id}_split_${splitDate.getTime()}`;
+  const newSeries = {
+    id: newSeriesId,
+    title: changes.title ?? series.title,
+    start: changes.start ?? occurrence.start,
+    end: changes.end,
+    duration: changes.duration ?? series.duration,
+    allDay: changes.allDay ?? series.allDay,
+    color: changes.color ?? series.color,
+    textColor: changes.textColor ?? series.textColor,
+    className: changes.className ?? series.className,
+    editable: changes.editable ?? series.editable,
+    draggable: changes.draggable ?? series.draggable,
+    resizable: changes.resizable ?? series.resizable,
+    metadata: changes.metadata ?? series.metadata,
+    rrule: newSeriesRRule,
+    timezone: series.timezone,
+    resourceId: changes.resourceId ?? series.resourceId,
+    resourceIds: changes.resourceIds ?? series.resourceIds
+  };
+  return {
+    originalSeries,
+    newSeries
+  };
+}
+function deleteThisOnly(series, occurrence) {
+  const occurrenceStart = toDate2(occurrence.start);
+  const existingExdates = series.exdate || [];
+  const alreadyExcluded = existingExdates.some((exd) => isSameDay(exd, occurrenceStart));
+  if (alreadyExcluded) {
+    return { series };
+  }
+  const existingExceptions = series.exceptions || [];
+  const remainingExceptions = existingExceptions.filter((ex) => !isSameDay(ex.originalStart, occurrenceStart));
+  return {
+    series: {
+      ...series,
+      exdate: [...existingExdates, occurrenceStart],
+      exceptions: remainingExceptions.length > 0 ? remainingExceptions : void 0
+    }
+  };
+}
+function deleteAll() {
+  return { deleted: true };
+}
+function deleteThisAndFuture(series, occurrence) {
+  const splitDate = toDate2(occurrence.start);
+  const seriesStart = toDate2(series.start);
+  if (isSameDay(splitDate, seriesStart)) {
+    return { series: null };
+  }
+  const dayBefore = new Date(splitDate);
+  dayBefore.setDate(dayBefore.getDate() - 1);
+  const originalRRule = typeof series.rrule === "string" ? parseRRule(series.rrule) : series.rrule;
+  if (!originalRRule) {
+    return { series: null };
+  }
+  const truncatedRRule = {
+    ...originalRRule,
+    until: dayBefore
+  };
+  delete truncatedRRule.count;
+  const originalExceptions = series.exceptions || [];
+  const pastExceptions = originalExceptions.filter((ex) => toDate2(ex.originalStart) < splitDate);
+  const originalExdates = series.exdate || [];
+  const pastExdates = originalExdates.filter((exd) => toDate2(exd) < splitDate);
+  const originalRdates = series.rdate || [];
+  const pastRdates = originalRdates.filter((rd) => toDate2(rd) < splitDate);
+  return {
+    series: {
+      ...series,
+      rrule: truncatedRRule,
+      exdate: pastExdates.length > 0 ? pastExdates : void 0,
+      rdate: pastRdates.length > 0 ? pastRdates : void 0,
+      exceptions: pastExceptions.length > 0 ? pastExceptions : void 0
+    }
+  };
+}
+function applyRecurrenceEdit(series, occurrence, changes, scope) {
+  switch (scope) {
+    case "this": {
+      const result = editThisOnly(series, occurrence, changes);
+      return { series: result.series };
+    }
+    case "all": {
+      const result = editAll(series, changes);
+      return { series: result.series };
+    }
+    case "future": {
+      const result = editThisAndFuture(series, occurrence, changes);
+      return {
+        series: result.originalSeries,
+        newSeries: result.newSeries
+      };
+    }
+  }
+}
+function applyRecurrenceDelete(series, occurrence, scope) {
+  switch (scope) {
+    case "this": {
+      const result = deleteThisOnly(series, occurrence);
+      return { series: result.series };
+    }
+    case "all": {
+      return { series: null, deleted: true };
+    }
+    case "future": {
+      const result = deleteThisAndFuture(series, occurrence);
+      return { series: result.series };
+    }
+  }
+}
+function addRDate(series, date) {
+  const existingRdates = series.rdate || [];
+  const newDate = toDate2(date);
+  const alreadyExists = existingRdates.some((rd) => isSameDay(rd, newDate));
+  if (alreadyExists) {
+    return series;
+  }
+  return {
+    ...series,
+    rdate: [...existingRdates, newDate]
+  };
+}
+function removeRDate(series, date) {
+  const existingRdates = series.rdate || [];
+  const targetDate = toDate2(date);
+  return {
+    ...series,
+    rdate: existingRdates.filter((rd) => !isSameDay(rd, targetDate))
+  };
+}
+function addException(series, exception) {
+  const existingExceptions = series.exceptions || [];
+  const existingIndex = existingExceptions.findIndex((ex) => isSameDay(ex.originalStart, exception.originalStart));
+  if (existingIndex >= 0) {
+    return {
+      ...series,
+      exceptions: existingExceptions.map((ex, i) => i === existingIndex ? exception : ex)
+    };
+  }
+  return {
+    ...series,
+    exceptions: [...existingExceptions, exception]
+  };
+}
+function removeException(series, originalStart) {
+  const existingExceptions = series.exceptions || [];
+  return {
+    ...series,
+    exceptions: existingExceptions.filter((ex) => !isSameDay(ex.originalStart, originalStart))
+  };
+}
+function getExceptionForDate(series, date) {
+  const exceptions = series.exceptions || [];
+  return exceptions.find((ex) => isSameDay(ex.originalStart, date));
+}
+function hasExceptionForDate(series, date) {
+  return getExceptionForDate(series, date) !== void 0;
+}
+function isOccurrenceExcluded(series, date) {
+  const exdates = series.exdate || [];
+  return exdates.some((exd) => isSameDay(exd, date));
+}
+function getRecurrenceDescription(scope) {
+  switch (scope) {
+    case "this":
+      return "This event only";
+    case "all":
+      return "All events in the series";
+    case "future":
+      return "This and all future events";
+  }
+}
+function getDeleteDescription(scope) {
+  switch (scope) {
+    case "this":
+      return "Delete this event only";
+    case "all":
+      return "Delete all events in the series";
+    case "future":
+      return "Delete this and all future events";
+  }
+}
+function isRecurringSeries(event) {
+  return event.rrule !== void 0 && !("recurrenceId" in event && event.recurrenceId !== void 0);
+}
+function convertToSeries(event) {
+  if (!event.rrule) {
+    return null;
+  }
+  return {
+    id: event.id,
+    title: event.title,
+    start: event.start,
+    end: event.end,
+    duration: event.duration,
+    allDay: event.allDay,
+    color: event.color,
+    textColor: event.textColor,
+    className: event.className,
+    editable: event.editable,
+    draggable: event.draggable,
+    resizable: event.resizable,
+    metadata: event.metadata,
+    rrule: event.rrule,
+    exdate: event.exdate,
+    rdate: event.rdate,
+    timezone: event.timezone,
+    resourceId: event.resourceId,
+    resourceIds: event.resourceIds
+  };
+}
+function serializeSeries(series) {
+  const rrule = typeof series.rrule === "string" ? series.rrule : serializeRRule(series.rrule);
+  const parts = [`RRULE:${rrule}`];
+  if (series.exdate && series.exdate.length > 0) {
+    const exdates = series.exdate.map((d) => formatICalDate(toDate2(d))).join(",");
+    parts.push(`EXDATE:${exdates}`);
+  }
+  if (series.rdate && series.rdate.length > 0) {
+    const rdates = series.rdate.map((d) => formatICalDate(toDate2(d))).join(",");
+    parts.push(`RDATE:${rdates}`);
+  }
+  return parts.join("\n");
+}
+function formatICalDate(date) {
+  const year = date.getFullYear();
+  const month = String(date.getMonth() + 1).padStart(2, "0");
+  const day = String(date.getDate()).padStart(2, "0");
+  const hour = String(date.getHours()).padStart(2, "0");
+  const minute = String(date.getMinutes()).padStart(2, "0");
+  const second = String(date.getSeconds()).padStart(2, "0");
+  return `${year}${month}${day}T${hour}${minute}${second}`;
+}
+function parseICalDate(dateStr) {
+  if (dateStr.length === 8) {
+    const year = parseInt(dateStr.slice(0, 4), 10);
+    const month = parseInt(dateStr.slice(4, 6), 10) - 1;
+    const day = parseInt(dateStr.slice(6, 8), 10);
+    return new Date(year, month, day);
+  }
+  if (dateStr.includes("T")) {
+    const datePart = dateStr.slice(0, 8);
+    const timePart = dateStr.slice(9, 15);
+    const year = parseInt(datePart.slice(0, 4), 10);
+    const month = parseInt(datePart.slice(4, 6), 10) - 1;
+    const day = parseInt(datePart.slice(6, 8), 10);
+    const hour = parseInt(timePart.slice(0, 2), 10);
+    const minute = parseInt(timePart.slice(2, 4), 10);
+    const second = parseInt(timePart.slice(4, 6), 10);
+    if (dateStr.endsWith("Z")) {
+      return new Date(Date.UTC(year, month, day, hour, minute, second));
+    }
+    return new Date(year, month, day, hour, minute, second);
+  }
+  return new Date(dateStr);
+}
+function parseExDates(exdateStr) {
+  const cleaned = exdateStr.replace(/^EXDATE[;:]/i, "").trim();
+  return cleaned.split(",").map((d) => parseICalDate(d.trim()));
+}
+function parseRDates(rdateStr) {
+  const cleaned = rdateStr.replace(/^RDATE[;:]/i, "").trim();
+  return cleaned.split(",").map((d) => parseICalDate(d.trim()));
+}
+
+// src/event/recurrence-runtime.ts
+var toDateValue = (value, fallback) => {
+  if (value instanceof Date) {
+    return new Date(value);
+  }
+  if (typeof value === "string") {
+    const parsed = new Date(value);
+    if (!Number.isNaN(parsed.getTime())) {
+      return parsed;
+    }
+  }
+  return /* @__PURE__ */ new Date();
+};
+var toEventDurationMinutes = (event, fallback) => {
+  if (typeof event.duration === "number" && Number.isFinite(event.duration) && event.duration > 0) {
+    return event.duration;
+  }
+  const start = toDateValue(event.start);
+  if (event.end) {
+    const end = toDateValue(event.end);
+    const diff = Math.round((end.getTime() - start.getTime()) / 6e4);
+    if (diff > 0) {
+      return diff;
+    }
+  }
+  return fallback;
+};
+function resolveSeriesIdFromOccurrence(event) {
+  const recurringEvent = event;
+  if (recurringEvent.recurringEventId !== void 0 && recurringEvent.recurringEventId !== null) {
+    return recurringEvent.recurringEventId;
+  }
+  if (recurringEvent.originalId !== void 0 && recurringEvent.originalId !== null) {
+    return recurringEvent.originalId;
+  }
+  const metadataRecurringId = recurringEvent.metadata?.recurringEventId;
+  if (typeof metadataRecurringId === "string" || typeof metadataRecurringId === "number") {
+    return metadataRecurringId;
+  }
+  if (typeof event.id === "string") {
+    const match = event.id.match(/^(.*)_\d+$/);
+    if (match && match[1]) {
+      return match[1];
+    }
+  }
+  return null;
+}
+function isRecurringOccurrenceEvent(event) {
+  const recurringEvent = event;
+  if (recurringEvent.isRecurring) {
+    return true;
+  }
+  if (recurringEvent.recurringEventId !== void 0 && recurringEvent.recurringEventId !== null) {
+    return true;
+  }
+  if (recurringEvent.originalId !== void 0 && recurringEvent.originalId !== null) {
+    return true;
+  }
+  return Boolean(event.recurrenceId && !event.rrule);
+}
+function resolveRecurringContext(event, baseEvents, durationFallbackMinutes = 60) {
+  if (!isRecurringOccurrenceEvent(event)) {
+    return null;
+  }
+  const seriesId = resolveSeriesIdFromOccurrence(event);
+  if (seriesId === null) {
+    return null;
+  }
+  const sourceSeries = baseEvents.find((candidate) => String(candidate.id) === String(seriesId) && Boolean(candidate.rrule) && !candidate.recurrenceId) ?? (event.rrule && !event.recurrenceId ? event : null);
+  if (!sourceSeries) {
+    return null;
+  }
+  const series = convertToSeries(sourceSeries);
+  if (!series) {
+    return null;
+  }
+  const start = toDateValue(event.start);
+  const duration = toEventDurationMinutes(event, typeof series.duration === "number" ? series.duration : durationFallbackMinutes);
+  const end = event.end ? toDateValue(event.end) : new Date(start.getTime() + duration * 6e4);
+  const recurringEvent = event;
+  const occurrence = {
+    id: String(event.id),
+    originalId: recurringEvent.originalId ?? series.id,
+    title: event.title,
+    start,
+    end,
+    allDay: event.allDay,
+    color: event.color,
+    textColor: event.textColor,
+    className: event.className,
+    editable: event.editable,
+    draggable: event.draggable,
+    resizable: event.resizable,
+    metadata: event.metadata,
+    isRecurring: true,
+    recurringEventId: series.id,
+    recurrenceId: recurringEvent.recurrenceId ?? recurringEvent.originalStart ?? start,
+    isException: recurringEvent.isException,
+    originalStart: recurringEvent.originalStart ? toDateValue(recurringEvent.originalStart) : start,
+    timezone: event.timezone,
+    resourceId: event.resourceId,
+    resourceIds: event.resourceIds,
+    categoryId: event.categoryId,
+    categoryIds: event.categoryIds
+  };
+  return { series, occurrence };
+}
+function resolveDefaultEditScope(modes) {
+  if (modes.length === 0) {
+    return null;
+  }
+  return modes.includes("this") ? "this" : modes[0];
+}
+function resolveDefaultDeleteScope(modes) {
+  if (modes.length === 0) {
+    return null;
+  }
+  return modes.includes("this") ? "this" : modes[0];
+}
+function resolveRecurrenceEditScope(action, options, scopeSelector) {
+  if (options.editModes.length === 0) {
+    return null;
+  }
+  const fallback = resolveDefaultEditScope(options.editModes);
+  if (!fallback) {
+    return null;
+  }
+  if (action === "drag" && options.dragMode === "this") {
+    return fallback;
+  }
+  if (action === "resize" && options.resizeMode === "this") {
+    return fallback;
+  }
+  if (!scopeSelector) {
+    return fallback;
+  }
+  return scopeSelector({
+    action,
+    modes: options.editModes,
+    fallback
+  });
+}
+function resolveRecurrenceDeleteScope(options, scopeSelector) {
+  if (options.deleteModes.length === 0) {
+    return null;
+  }
+  const fallback = resolveDefaultDeleteScope(options.deleteModes);
+  if (!fallback) {
+    return null;
+  }
+  if (!scopeSelector) {
+    return fallback;
+  }
+  return scopeSelector({
+    modes: options.deleteModes,
+    fallback
+  });
+}
+function applyRecurringEditChange(input) {
+  const context = resolveRecurringContext(input.event, input.baseEvents, input.durationFallbackMinutes);
+  if (!context || input.editOptions.editModes.length === 0) {
+    return { handled: false };
+  }
+  const scope = resolveRecurrenceEditScope(input.action, input.editOptions, input.scopeSelector);
+  if (!scope) {
+    return { handled: true, canceled: true };
+  }
+  const result = applyRecurrenceEdit(context.series, context.occurrence, input.changes, scope);
+  return {
+    handled: true,
+    scope,
+    context,
+    result
+  };
+}
+function applyRecurringDeleteChange(input) {
+  const context = resolveRecurringContext(input.event, input.baseEvents, input.durationFallbackMinutes);
+  if (!context || input.editOptions.deleteModes.length === 0) {
+    return { handled: false };
+  }
+  const scope = resolveRecurrenceDeleteScope(input.editOptions, input.scopeSelector);
+  if (!scope) {
+    return { handled: true, canceled: true };
+  }
+  const result = applyRecurrenceDelete(context.series, context.occurrence, scope);
+  return {
+    handled: true,
+    scope,
+    context,
+    result
+  };
+}
+
+// src/event/recurrence.controller.ts
+function processRecurrenceEdit(input) {
+  const state = applyRecurringEditChange(input);
+  if (!state.handled || state.canceled || !state.scope || !state.context || !state.result) {
+    return state;
+  }
+  const emits = {
+    recurrenceEdit: {
+      source: input.source,
+      scope: state.scope,
+      occurrence: state.context.occurrence,
+      series: state.context.series,
+      changes: input.changes,
+      result: state.result
+    },
+    eventChange: {
+      event: state.result.series,
+      oldEvent: state.context.series
+    }
+  };
+  if (state.result.newSeries) {
+    emits.eventAdd = state.result.newSeries;
+  }
+  return { ...state, emits };
+}
+function processRecurrenceDelete(input) {
+  const state = applyRecurringDeleteChange(input);
+  if (!state.handled || state.canceled || !state.scope || !state.context || !state.result) {
+    return state;
+  }
+  const emits = {
+    recurrenceDelete: {
+      source: input.source,
+      scope: state.scope,
+      occurrence: state.context.occurrence,
+      series: state.context.series,
+      result: state.result
+    }
+  };
+  if (state.result.series) {
+    emits.eventChange = {
+      event: state.result.series,
+      oldEvent: state.context.series
+    };
+  } else {
+    emits.eventRemove = {
+      event: state.context.series
+    };
+  }
+  return { ...state, emits };
+}
+function resolveRecurrenceEditContext(input) {
+  const context = resolveRecurringContext(input.event, input.baseEvents, input.durationFallbackMinutes);
+  if (!context || input.editOptions.editModes.length === 0) {
+    return { resolved: false };
+  }
+  const scope = resolveRecurrenceEditScope("edit", input.editOptions, input.scopeSelector);
+  if (!scope) {
+    return { resolved: true, canceled: true };
+  }
+  return { resolved: true, scope, context };
+}
+function getRecurrenceEditScopeMessage(action) {
+  if (action === "drag") return "Apply drag changes to recurring event:";
+  if (action === "resize") return "Apply resize changes to recurring event:";
+  return "Apply edit changes to recurring event:";
+}
+function getRecurrenceDeleteScopeMessage() {
+  return "Delete recurring event scope:";
+}
+function getEditScopeLabel(scope, index) {
+  if (scope === "this") return `${index}. This event only`;
+  if (scope === "all") return `${index}. All events in series`;
+  return `${index}. This and future events`;
+}
+function getDeleteScopeLabel(scope, index) {
+  if (scope === "this") return `${index}. Delete this event only`;
+  if (scope === "all") return `${index}. Delete all events in series`;
+  return `${index}. Delete this and future events`;
+}
+
+export { DEFAULT_RECURRENCE_EDIT_OPTIONS, addException, addRDate, applyRecurrenceDelete, applyRecurrenceEdit, applyRecurringDeleteChange, applyRecurringEditChange, buildSchedulerEventPipeline, calculateEventPosition, convertToSeries, createSchedulerEventPipelineMemo, deleteAll, deleteThisAndFuture, deleteThisOnly, editAll, editThisAndFuture, editThisOnly, getAllDayEventsForDay, getDeleteDescription, getDeleteScopeLabel, getEditScopeLabel, getExceptionForDate, getRecurrenceDeleteScopeMessage, getRecurrenceDescription, getRecurrenceEditScopeMessage, getTimedEventsForDay, hasExceptionForDate, isOccurrenceExcluded, isRecurringOccurrenceEvent, isRecurringSeries, normalizeRecurrenceEditOptions, normalizeSchedulerEventToDisplayTimezone, normalizeSchedulerEventsToDisplayTimezone, parseExDates, parseICalDate, parseRDates, positionAllDayEventsForWeek, positionEventsForDay, positionEventsForWeekRow, processRecurrenceDelete, processRecurrenceEdit, removeEventById, removeException, removeRDate, resolveDefaultDeleteScope, resolveDefaultEditScope, resolveRecurrenceDeleteScope, resolveRecurrenceEditContext, resolveRecurrenceEditScope, resolveRecurringContext, resolveSeriesIdFromOccurrence, serializeSeries, upsertEventById };