@allhailai/tempusmachina-core 1.0.0

package/dist/index.cjs

@@ -0,0 +1,1669 @@
+'use strict';
+
+var temporalPolyfill = require('temporal-polyfill');
+
+// src/types/event.ts
+function eventToPlainObject(event) {
+  return {
+    id: event.id,
+    seriesId: event.seriesId ?? null,
+    title: event.title,
+    description: event.description,
+    start: event.start.toString(),
+    end: event.end.toString(),
+    isAllDay: event.isAllDay,
+    duration: event.duration.toString(),
+    resourceIds: event.resourceIds,
+    color: event.color,
+    backgroundColor: event.backgroundColor,
+    borderColor: event.borderColor,
+    textColor: event.textColor,
+    className: event.className,
+    display: event.display,
+    editable: event.editable,
+    startEditable: event.startEditable,
+    durationEditable: event.durationEditable,
+    resourceEditable: event.resourceEditable,
+    overlap: event.overlap,
+    extendedProps: event.extendedProps
+  };
+}
+
+// src/types/view.ts
+function viewTypeFromPreset(preset) {
+  if (preset.startsWith("dayGrid")) return "dayGrid";
+  if (preset.startsWith("timeGrid")) return "timeGrid";
+  if (preset.startsWith("timeline")) return "timeline";
+  if (preset.startsWith("multiMonth")) return "multiMonth";
+  if (preset.startsWith("resourceTimeGrid")) return "resourceTimeGrid";
+  return "agenda";
+}
+function viewUnitFromPreset(preset) {
+  if (preset.endsWith("Day")) return "day";
+  if (preset.endsWith("Week")) return "week";
+  return "month";
+}
+function normalizeEventSourceDef(input, index) {
+  if (typeof input === "object" && !Array.isArray(input) && "id" in input && "events" in input) {
+    return input;
+  }
+  return {
+    id: `source-${index}`,
+    events: input
+  };
+}
+function rangesOverlap(a, b) {
+  return temporalPolyfill.Temporal.PlainDate.compare(a.start, b.end) < 0 && temporalPolyfill.Temporal.PlainDate.compare(b.start, a.end) < 0;
+}
+function rangeContains(range, date) {
+  return temporalPolyfill.Temporal.PlainDate.compare(date, range.start) >= 0 && temporalPolyfill.Temporal.PlainDate.compare(date, range.end) < 0;
+}
+function clampDateToRange(date, range) {
+  if (temporalPolyfill.Temporal.PlainDate.compare(date, range.start) < 0) return range.start;
+  const lastDay = range.end.subtract({ days: 1 });
+  if (temporalPolyfill.Temporal.PlainDate.compare(date, lastDay) > 0) return lastDay;
+  return date;
+}
+function zonedRangesOverlap(aStart, aEnd, bStart, bEnd) {
+  return temporalPolyfill.Temporal.ZonedDateTime.compare(aStart, bEnd) < 0 && temporalPolyfill.Temporal.ZonedDateTime.compare(bStart, aEnd) < 0;
+}
+function zonedRangeContains(start, end, point) {
+  return temporalPolyfill.Temporal.ZonedDateTime.compare(point, start) >= 0 && temporalPolyfill.Temporal.ZonedDateTime.compare(point, end) < 0;
+}
+function createDateRange(start, end) {
+  return { start, end };
+}
+
+// src/utils/invariant.ts
+function invariant(condition, message) {
+  if (!condition) {
+    throw new Error(`[tempus-machina] ${message}`);
+  }
+}
+
+// src/engine/event-store.ts
+var EventStore = class _EventStore {
+  events;
+  constructor(events) {
+    this.events = events;
+  }
+  static empty() {
+    return new _EventStore(/* @__PURE__ */ new Map());
+  }
+  static from(inputs, timezone, defaults) {
+    const events = /* @__PURE__ */ new Map();
+    for (const input of inputs) {
+      const transformed = defaults?.eventDataTransform ? defaults.eventDataTransform(input) : input;
+      const normalized = normalizeEvent(transformed, timezone, defaults);
+      events.set(normalized.id, normalized);
+    }
+    return new _EventStore(events);
+  }
+  add(input, timezone = "UTC", defaults) {
+    const nextEvents = new Map(this.events);
+    const transformed = defaults?.eventDataTransform ? defaults.eventDataTransform(input) : input;
+    const normalized = normalizeEvent(transformed, timezone, defaults);
+    nextEvents.set(normalized.id, normalized);
+    return new _EventStore(nextEvents);
+  }
+  update(id, patch, timezone = "UTC", defaults) {
+    const existing = this.events.get(id);
+    if (!existing) return this;
+    const nextEvents = new Map(this.events);
+    const merged = {
+      id: existing.id,
+      title: patch.title ?? existing.title,
+      description: patch.description ?? existing.description,
+      start: patch.start ?? existing.start,
+      end: patch.end ?? existing.end,
+      color: patch.color ?? existing.color ?? void 0,
+      backgroundColor: patch.backgroundColor ?? existing.backgroundColor ?? void 0,
+      borderColor: patch.borderColor ?? existing.borderColor ?? void 0,
+      textColor: patch.textColor ?? existing.textColor ?? void 0,
+      className: patch.className ?? existing.className ?? void 0,
+      display: patch.display ?? existing.display,
+      editable: patch.editable ?? existing.editable,
+      startEditable: patch.startEditable ?? existing.startEditable,
+      durationEditable: patch.durationEditable ?? existing.durationEditable,
+      resourceEditable: patch.resourceEditable ?? existing.resourceEditable,
+      overlap: patch.overlap ?? existing.overlap,
+      constraint: patch.constraint ?? existing.constraint ?? void 0,
+      resourceIds: patch.resourceIds ?? existing.resourceIds,
+      extendedProps: patch.extendedProps ?? existing.extendedProps
+    };
+    const normalized = normalizeEvent(merged, timezone, defaults);
+    nextEvents.set(id, normalized);
+    return new _EventStore(nextEvents);
+  }
+  remove(id) {
+    const nextEvents = new Map(this.events);
+    nextEvents.delete(id);
+    return new _EventStore(nextEvents);
+  }
+  getAll() {
+    return Array.from(this.events.values());
+  }
+  getById(id) {
+    return this.events.get(id);
+  }
+  getInRange(range, timezone = "UTC") {
+    const rangeStart = range.start.toZonedDateTime({
+      timeZone: timezone,
+      plainTime: temporalPolyfill.Temporal.PlainTime.from("00:00")
+    });
+    const rangeEnd = range.end.toZonedDateTime({
+      timeZone: timezone,
+      plainTime: temporalPolyfill.Temporal.PlainTime.from("00:00")
+    });
+    return this.getAll().filter(
+      (event) => zonedRangesOverlap(event.start, event.end, rangeStart, rangeEnd)
+    );
+  }
+  getForResource(resourceId) {
+    return this.getAll().filter((event) => event.resourceIds.includes(resourceId));
+  }
+  get size() {
+    return this.events.size;
+  }
+};
+function normalizeEvent(input, timezone, defaults) {
+  invariant(input.id, "Event must have an id");
+  invariant(input.title, "Event must have a title");
+  const globalEditable = defaults?.editable ?? true;
+  let start;
+  let end;
+  let isAllDay = false;
+  if (input.date) {
+    isAllDay = true;
+    const defaultDuration = defaults?.defaultAllDayEventDuration ?? temporalPolyfill.Temporal.Duration.from({ days: 1 });
+    const endDate = input.endDate ?? input.date.add(defaultDuration);
+    start = input.date.toZonedDateTime({
+      timeZone: timezone,
+      plainTime: temporalPolyfill.Temporal.PlainTime.from("00:00")
+    });
+    end = endDate.toZonedDateTime({
+      timeZone: timezone,
+      plainTime: temporalPolyfill.Temporal.PlainTime.from("00:00")
+    });
+  } else if (input.start) {
+    start = toZonedDateTime(input.start, timezone);
+    if (input.end) {
+      end = toZonedDateTime(input.end, timezone);
+    } else if (input.duration) {
+      end = start.add(input.duration);
+    } else {
+      const defaultDuration = defaults?.defaultTimedEventDuration ?? temporalPolyfill.Temporal.Duration.from({ hours: 1 });
+      end = start.add(defaultDuration);
+    }
+  } else if (defaults?.defaultAllDay) {
+    isAllDay = true;
+    const today = temporalPolyfill.Temporal.Now.plainDateISO();
+    start = today.toZonedDateTime({
+      timeZone: timezone,
+      plainTime: temporalPolyfill.Temporal.PlainTime.from("00:00")
+    });
+    end = today.add({ days: 1 }).toZonedDateTime({ timeZone: timezone, plainTime: temporalPolyfill.Temporal.PlainTime.from("00:00") });
+  } else {
+    throw new Error(`[tempus-machina] Event "${input.id}" must have either 'date' or 'start'`);
+  }
+  const duration = start.until(end);
+  const resolvedColor = input.color ?? defaults?.eventColor ?? null;
+  const resolvedBgColor = input.backgroundColor ?? defaults?.eventBackgroundColor ?? null;
+  const resolvedBorderColor = input.borderColor ?? defaults?.eventBorderColor ?? null;
+  const resolvedTextColor = input.textColor ?? defaults?.eventTextColor ?? null;
+  return {
+    id: input.id,
+    seriesId: input.recurrenceId,
+    title: input.title,
+    description: input.description ?? "",
+    start,
+    end,
+    isAllDay,
+    duration,
+    resourceIds: input.resourceIds ?? (input.resourceId ? [input.resourceId] : []),
+    color: resolvedColor,
+    backgroundColor: resolvedBgColor,
+    borderColor: resolvedBorderColor,
+    textColor: resolvedTextColor,
+    className: input.className ?? null,
+    display: input.display ?? "auto",
+    editable: input.editable ?? globalEditable,
+    startEditable: input.startEditable ?? input.editable ?? globalEditable,
+    durationEditable: input.durationEditable ?? input.editable ?? globalEditable,
+    resourceEditable: input.resourceEditable ?? input.editable ?? globalEditable,
+    overlap: input.overlap ?? true,
+    constraint: input.constraint ?? null,
+    allow: input.allow ?? null,
+    extendedProps: input.extendedProps ?? {}
+  };
+}
+function toZonedDateTime(dt, timezone) {
+  if ("timeZoneId" in dt && typeof dt.timeZoneId === "string") {
+    return dt;
+  }
+  return dt.toZonedDateTime(timezone);
+}
+function getWeekStart(date, firstDayOfWeek = 0) {
+  const dayOfWeek0 = date.dayOfWeek % 7;
+  const diff = (dayOfWeek0 - firstDayOfWeek + 7) % 7;
+  return date.subtract({ days: diff });
+}
+function getWeekEnd(date, firstDayOfWeek = 0) {
+  return getWeekStart(date, firstDayOfWeek).add({ days: 7 });
+}
+function* iterateDays(start, end) {
+  let current = start;
+  while (temporalPolyfill.Temporal.PlainDate.compare(current, end) < 0) {
+    yield current;
+    current = current.add({ days: 1 });
+  }
+}
+function durationBetween(start, end) {
+  return start.until(end);
+}
+function daysBetween(start, end) {
+  return start.until(end, { largestUnit: "day" }).days;
+}
+function isWeekend(date) {
+  return date.dayOfWeek >= 6;
+}
+function getMonthStart(date) {
+  return date.with({ day: 1 });
+}
+function getMonthEnd(date) {
+  return date.with({ day: 1 }).add({ months: 1 });
+}
+function getDaysInMonth(date) {
+  return date.daysInMonth;
+}
+function toISODayOfWeek(dayOfWeek0) {
+  return dayOfWeek0 === 0 ? 7 : dayOfWeek0;
+}
+function fromISODayOfWeek(isoDayOfWeek) {
+  return isoDayOfWeek % 7;
+}
+function addDurationToDateTime(dateTime, duration) {
+  return dateTime.add(duration);
+}
+function getToday() {
+  return temporalPolyfill.Temporal.Now.plainDateISO();
+}
+function compareDates(a, b) {
+  return temporalPolyfill.Temporal.PlainDate.compare(a, b);
+}
+function compareZonedDateTimes(a, b) {
+  return temporalPolyfill.Temporal.ZonedDateTime.compare(a, b);
+}
+function compareDateTimes(a, b) {
+  return temporalPolyfill.Temporal.PlainDateTime.compare(a, b);
+}
+function compareTimes(a, b) {
+  return temporalPolyfill.Temporal.PlainTime.compare(a, b);
+}
+
+// src/engine/date-spine.ts
+function generateDateSpine(config) {
+  const { type } = config;
+  switch (type) {
+    case "dayGrid":
+      return generateDayGridSpine(config);
+    case "timeGrid":
+      return generateTimeGridSpine(config);
+    case "timeline":
+      return generateTimelineSpine(config);
+    case "agenda":
+      return generateAgendaSpine(config);
+    default:
+      return generateDayGridSpine(config);
+  }
+}
+function generateDayGridSpine(config) {
+  const { visibleRange, firstDayOfWeek, hiddenDays } = config;
+  const gridStart = getWeekStart(visibleRange.start, firstDayOfWeek);
+  const gridEnd = getGridEnd(visibleRange.end, firstDayOfWeek);
+  const dates = [];
+  const weeks = [];
+  let currentWeek = [];
+  for (const date of iterateDays(gridStart, gridEnd)) {
+    const dayOfWeek0 = date.dayOfWeek % 7;
+    if (hiddenDays.includes(dayOfWeek0)) continue;
+    dates.push(date);
+    currentWeek.push(date);
+    if (currentWeek.length === 7 - hiddenDays.length) {
+      weeks.push(currentWeek);
+      currentWeek = [];
+    }
+  }
+  if (currentWeek.length > 0) {
+    weeks.push(currentWeek);
+  }
+  return {
+    dates,
+    weeks,
+    totalDays: dates.length,
+    totalSlots: 0
+  };
+}
+function generateTimeGridSpine(config) {
+  const { visibleRange, hiddenDays } = config;
+  const dates = [];
+  const slots = [];
+  for (const date of iterateDays(visibleRange.start, visibleRange.end)) {
+    const dayOfWeek0 = date.dayOfWeek % 7;
+    if (hiddenDays.includes(dayOfWeek0)) continue;
+    dates.push(date);
+    slots.push(generateSlotsForDay(date, config));
+  }
+  return {
+    dates,
+    slots,
+    totalDays: dates.length,
+    totalSlots: slots.reduce((sum, s) => sum + s.length, 0)
+  };
+}
+function generateTimelineSpine(config) {
+  return generateTimeGridSpine(config);
+}
+function generateAgendaSpine(config) {
+  const { visibleRange, hiddenDays } = config;
+  const dates = [];
+  for (const date of iterateDays(visibleRange.start, visibleRange.end)) {
+    const dayOfWeek0 = date.dayOfWeek % 7;
+    if (hiddenDays.includes(dayOfWeek0)) continue;
+    dates.push(date);
+  }
+  return {
+    dates,
+    totalDays: dates.length,
+    totalSlots: 0
+  };
+}
+function generateSlotsForDay(date, config) {
+  const { slotDuration, slotMinTime, slotMaxTime, businessHours } = config;
+  const slots = [];
+  let currentTime = slotMinTime;
+  let index = 0;
+  while (compareTimes(currentTime, slotMaxTime) < 0) {
+    const slotStart = date.toPlainDateTime(currentTime);
+    const nextTime = addTimeByDuration(currentTime, slotDuration);
+    const effectiveEndTime = compareTimes(nextTime, slotMaxTime) <= 0 ? nextTime : slotMaxTime;
+    const slotEnd = date.toPlainDateTime(effectiveEndTime);
+    const dayOfWeek0 = date.dayOfWeek % 7;
+    slots.push({
+      start: slotStart,
+      end: slotEnd,
+      duration: slotDuration,
+      index,
+      isBusinessHour: businessHours ? businessHours.daysOfWeek.includes(dayOfWeek0) && compareTimes(currentTime, businessHours.startTime) >= 0 && compareTimes(currentTime, businessHours.endTime) < 0 : false,
+      isNow: false,
+      // Computed at render time by React layer
+      date,
+      time: currentTime
+    });
+    currentTime = effectiveEndTime;
+    index++;
+  }
+  return slots;
+}
+function addTimeByDuration(time, duration) {
+  const totalSeconds = time.hour * 3600 + time.minute * 60 + time.second + (duration.hours || 0) * 3600 + (duration.minutes || 0) * 60 + (duration.seconds || 0);
+  const clampedSeconds = Math.min(totalSeconds, 24 * 3600 - 1);
+  const hours = Math.floor(clampedSeconds / 3600);
+  const minutes = Math.floor(clampedSeconds % 3600 / 60);
+  const seconds = clampedSeconds % 60;
+  return temporalPolyfill.Temporal.PlainTime.from({ hour: hours, minute: minutes, second: seconds });
+}
+function getGridEnd(end, firstDayOfWeek) {
+  const weekStart = getWeekStart(end, firstDayOfWeek);
+  if (end.equals(weekStart)) return end;
+  return weekStart.add({ days: 7 });
+}
+function getMonthVisibleRange(date, firstDayOfWeek) {
+  const monthStart = getMonthStart(date);
+  const monthEnd = getMonthEnd(date);
+  const gridStart = getWeekStart(monthStart, firstDayOfWeek);
+  const gridEnd = getGridEnd(monthEnd, firstDayOfWeek);
+  return { start: gridStart, end: gridEnd };
+}
+function applyEventOrder(events, eventOrder) {
+  const sorted = [...events];
+  if (eventOrder) {
+    sorted.sort(
+      (a, b) => eventOrder(
+        { start: a.start, end: a.end, title: a.title, allDay: a.isAllDay },
+        { start: b.start, end: b.end, title: b.title, allDay: b.isAllDay }
+      )
+    );
+  } else {
+    sorted.sort((a, b) => {
+      const startCmp = compareZonedDateTimes(a.start, b.start);
+      if (startCmp !== 0) return startCmp;
+      return compareZonedDateTimes(a.end, b.end) * -1;
+    });
+  }
+  return sorted;
+}
+function partitionByDisplay(events) {
+  const foreground = [];
+  const background = [];
+  for (const event of events) {
+    if (event.display === "none") continue;
+    if (event.display === "background") {
+      background.push(event);
+    } else {
+      foreground.push(event);
+    }
+  }
+  return [foreground, background];
+}
+function solveLayout(events, config) {
+  const [foreground] = partitionByDisplay(events);
+  if (foreground.length === 0) return [];
+  const sorted = applyEventOrder(foreground, config.eventOrder);
+  const clusters = findOverlapClusters(sorted);
+  const positioned = [];
+  for (const cluster of clusters) {
+    const columnAssignments = packColumns(cluster);
+    const totalColumns = Math.max(...columnAssignments.values()) + 1;
+    for (const event of cluster) {
+      const column = columnAssignments.get(event.id) ?? 0;
+      const { top, height } = computeTimePosition(event, config);
+      positioned.push({
+        event,
+        column,
+        totalColumns,
+        top,
+        height,
+        left: column / totalColumns * 100,
+        width: 1 / totalColumns * 100,
+        daySpan: 1,
+        startSlotIndex: 0,
+        endSlotIndex: 0,
+        isDragging: false,
+        isResizing: false,
+        isSelected: false,
+        isFocused: false
+      });
+    }
+  }
+  return positioned;
+}
+function solveLayoutFull(events, config) {
+  const [foreground, background] = partitionByDisplay(events);
+  const positioned = foreground.length > 0 ? solveLayout(foreground, config) : [];
+  const backgroundEvents = background.map((event) => {
+    const { top, height } = computeTimePosition(event, config);
+    return { event, top, height };
+  });
+  return { positioned, backgroundEvents };
+}
+function solveDayGridLayout(events, weeks, maxEventsPerCell = 3, timezone = "UTC", eventOrder) {
+  const today = temporalPolyfill.Temporal.Now.plainDateISO();
+  const [foreground] = partitionByDisplay(events);
+  const allDates = weeks.flat();
+  const midDate = allDates[Math.floor(allDates.length / 2)];
+  const referenceMonth = midDate?.month ?? today.month;
+  return weeks.map(
+    (week) => week.map((date) => {
+      const dayOfWeek0 = date.dayOfWeek % 7;
+      const dateStart = date.toZonedDateTime({
+        timeZone: timezone,
+        plainTime: temporalPolyfill.Temporal.PlainTime.from("00:00")
+      });
+      const dateEnd = date.add({ days: 1 }).toZonedDateTime({
+        timeZone: timezone,
+        plainTime: temporalPolyfill.Temporal.PlainTime.from("00:00")
+      });
+      const dayEvents = foreground.filter((event) => {
+        return compareZonedDateTimes(event.start, dateEnd) < 0 && compareZonedDateTimes(event.end, dateStart) > 0;
+      });
+      if (eventOrder) {
+        dayEvents.sort(
+          (a, b) => eventOrder(
+            { start: a.start, end: a.end, title: a.title, allDay: a.isAllDay },
+            { start: b.start, end: b.end, title: b.title, allDay: b.isAllDay }
+          )
+        );
+      } else {
+        dayEvents.sort((a, b) => {
+          if (a.isAllDay && !b.isAllDay) return -1;
+          if (!a.isAllDay && b.isAllDay) return 1;
+          return compareZonedDateTimes(a.start, b.start);
+        });
+      }
+      const visibleEvents = dayEvents.slice(0, maxEventsPerCell);
+      const moreCount = Math.max(0, dayEvents.length - maxEventsPerCell);
+      const positionedEvents = visibleEvents.map((event, idx) => ({
+        event,
+        column: 0,
+        totalColumns: 1,
+        top: 0,
+        height: 0,
+        left: 0,
+        width: 100,
+        daySpan: event.isAllDay ? Math.max(1, daysBetween(date, temporalPolyfill.Temporal.PlainDate.from(event.end.toPlainDate()))) : 1,
+        startSlotIndex: idx,
+        endSlotIndex: idx,
+        isDragging: false,
+        isResizing: false,
+        isSelected: false,
+        isFocused: false
+      }));
+      return {
+        date,
+        dayOfWeek: dayOfWeek0,
+        isToday: date.equals(today),
+        isCurrentMonth: date.month === referenceMonth,
+        isWeekend: isWeekend(date),
+        isHidden: false,
+        events: positionedEvents,
+        moreCount
+      };
+    })
+  );
+}
+function findOverlapClusters(sortedEvents) {
+  const clusters = [];
+  let currentCluster = [];
+  let clusterEnd = null;
+  for (const event of sortedEvents) {
+    if (clusterEnd === null || compareZonedDateTimes(event.start, clusterEnd) >= 0) {
+      if (currentCluster.length > 0) {
+        clusters.push(currentCluster);
+      }
+      currentCluster = [event];
+      clusterEnd = event.end;
+    } else {
+      currentCluster.push(event);
+      if (compareZonedDateTimes(event.end, clusterEnd) > 0) {
+        clusterEnd = event.end;
+      }
+    }
+  }
+  if (currentCluster.length > 0) {
+    clusters.push(currentCluster);
+  }
+  return clusters;
+}
+function packColumns(cluster) {
+  const assignments = /* @__PURE__ */ new Map();
+  const columnEnds = [];
+  for (const event of cluster) {
+    let assignedColumn = -1;
+    for (let col = 0; col < columnEnds.length; col++) {
+      if (compareZonedDateTimes(event.start, columnEnds[col]) >= 0) {
+        assignedColumn = col;
+        break;
+      }
+    }
+    if (assignedColumn === -1) {
+      assignedColumn = columnEnds.length;
+      columnEnds.push(event.end);
+    } else {
+      columnEnds[assignedColumn] = event.end;
+    }
+    assignments.set(event.id, assignedColumn);
+  }
+  return assignments;
+}
+function computeTimePosition(event, config) {
+  const minTime = config.slotMinTime;
+  const maxTime = config.slotMaxTime;
+  const totalMinutes = timeToMinutes(maxTime) - timeToMinutes(minTime);
+  if (totalMinutes <= 0) return { top: 0, height: 0 };
+  const eventStartMinutes = Math.max(
+    timeToMinutes(event.start.toPlainTime()),
+    timeToMinutes(minTime)
+  );
+  const eventEndMinutes = Math.min(timeToMinutes(event.end.toPlainTime()), timeToMinutes(maxTime));
+  const top = (eventStartMinutes - timeToMinutes(minTime)) / totalMinutes * 100;
+  const height = (eventEndMinutes - eventStartMinutes) / totalMinutes * 100;
+  return { top: Math.max(0, top), height: Math.max(0, height) };
+}
+function timeToMinutes(time) {
+  return time.hour * 60 + time.minute;
+}
+function clampToValidRange(date, validRange) {
+  if (!validRange) return date;
+  if (temporalPolyfill.Temporal.PlainDate.compare(date, validRange.start) < 0) return validRange.start;
+  if (temporalPolyfill.Temporal.PlainDate.compare(date, validRange.end) >= 0) {
+    return validRange.end.subtract({ days: 1 });
+  }
+  return date;
+}
+function navigateNext(date, preset, validRange) {
+  const unit = viewUnitFromPreset(preset);
+  let next;
+  switch (unit) {
+    case "day":
+      next = date.add({ days: 1 });
+      break;
+    case "week":
+      next = date.add({ weeks: 1 });
+      break;
+    case "month":
+      next = date.add({ months: 1 });
+      break;
+  }
+  return clampToValidRange(next, validRange);
+}
+function navigatePrev(date, preset, validRange) {
+  const unit = viewUnitFromPreset(preset);
+  let prev;
+  switch (unit) {
+    case "day":
+      prev = date.subtract({ days: 1 });
+      break;
+    case "week":
+      prev = date.subtract({ weeks: 1 });
+      break;
+    case "month":
+      prev = date.subtract({ months: 1 });
+      break;
+  }
+  return clampToValidRange(prev, validRange);
+}
+function getVisibleRange(date, preset, firstDayOfWeek = 0) {
+  const unit = viewUnitFromPreset(preset);
+  switch (unit) {
+    case "day":
+      return { start: date, end: date.add({ days: 1 }) };
+    case "week": {
+      const weekStart = getWeekStart(date, firstDayOfWeek);
+      return { start: weekStart, end: weekStart.add({ days: 7 }) };
+    }
+    case "month": {
+      const monthStart = getMonthStart(date);
+      const monthEnd = getMonthEnd(date);
+      const gridStart = getWeekStart(monthStart, firstDayOfWeek);
+      let gridEnd = getWeekStart(monthEnd, firstDayOfWeek);
+      if (!monthEnd.equals(gridEnd)) {
+        gridEnd = gridEnd.add({ days: 7 });
+      }
+      return { start: gridStart, end: gridEnd };
+    }
+  }
+}
+function getToday2() {
+  return temporalPolyfill.Temporal.Now.plainDateISO();
+}
+function generateTimeSlots(date, config) {
+  const { slotDuration, slotMinTime, slotMaxTime, businessHours } = config;
+  const slots = [];
+  let currentTime = slotMinTime;
+  let index = 0;
+  while (compareTimes(currentTime, slotMaxTime) < 0) {
+    const nextTime = addTimeByDuration2(currentTime, slotDuration);
+    const effectiveEnd = compareTimes(nextTime, slotMaxTime) <= 0 ? nextTime : slotMaxTime;
+    const dayOfWeek0 = date.dayOfWeek % 7;
+    slots.push({
+      start: date.toPlainDateTime(currentTime),
+      end: date.toPlainDateTime(effectiveEnd),
+      duration: slotDuration,
+      index,
+      isBusinessHour: isBusinessHour(currentTime, dayOfWeek0, businessHours),
+      isNow: false,
+      date,
+      time: currentTime
+    });
+    currentTime = effectiveEnd;
+    index++;
+  }
+  return slots;
+}
+function snapToSlot(dateTime, slotDuration) {
+  const totalMinutes = dateTime.hour * 60 + dateTime.minute;
+  const slotMinutes = (slotDuration.hours || 0) * 60 + (slotDuration.minutes || 0) || 30;
+  const snappedMinutes = Math.round(totalMinutes / slotMinutes) * slotMinutes;
+  const hours = Math.floor(snappedMinutes / 60);
+  const minutes = snappedMinutes % 60;
+  return dateTime.with({
+    hour: Math.min(hours, 23),
+    minute: minutes,
+    second: 0,
+    millisecond: 0,
+    microsecond: 0,
+    nanosecond: 0
+  });
+}
+function getSlotIndex(time, config) {
+  const slotMinutes = (config.slotDuration.hours || 0) * 60 + (config.slotDuration.minutes || 0) || 30;
+  const startMinutes = config.slotMinTime.hour * 60 + config.slotMinTime.minute;
+  const timeMinutes = time.hour * 60 + time.minute;
+  return Math.floor((timeMinutes - startMinutes) / slotMinutes);
+}
+function getNowPosition(config) {
+  const now = temporalPolyfill.Temporal.Now.plainTimeISO();
+  const minMinutes = config.slotMinTime.hour * 60 + config.slotMinTime.minute;
+  const maxMinutes = config.slotMaxTime.hour * 60 + config.slotMaxTime.minute;
+  const nowMinutes = now.hour * 60 + now.minute;
+  if (nowMinutes < minMinutes || nowMinutes > maxMinutes) return -1;
+  return (nowMinutes - minMinutes) / (maxMinutes - minMinutes) * 100;
+}
+function isBusinessHour(time, dayOfWeek0, businessHours) {
+  if (!businessHours) return false;
+  if (!businessHours.daysOfWeek.includes(dayOfWeek0)) return false;
+  return compareTimes(time, businessHours.startTime) >= 0 && compareTimes(time, businessHours.endTime) < 0;
+}
+function addTimeByDuration2(time, duration) {
+  const totalSeconds = time.hour * 3600 + time.minute * 60 + time.second + (duration.hours || 0) * 3600 + (duration.minutes || 0) * 60 + (duration.seconds || 0);
+  const clampedSeconds = Math.min(totalSeconds, 24 * 3600 - 1);
+  const hours = Math.floor(clampedSeconds / 3600);
+  const minutes = Math.floor(clampedSeconds % 3600 / 60);
+  const seconds = clampedSeconds % 60;
+  return temporalPolyfill.Temporal.PlainTime.from({ hour: hours, minute: minutes, second: seconds });
+}
+function validateEventDrop(event, newStart, newEnd, allEvents, config, viewConfig, resourceId) {
+  if (event.allow) {
+    const allowed = event.allow({ start: newStart, end: newEnd, resourceId });
+    if (!allowed) return false;
+  }
+  if (config.eventAllow) {
+    const allowed = config.eventAllow({ start: newStart, end: newEnd, resourceId }, event);
+    if (!allowed) return false;
+  }
+  if (event.constraint) {
+    if (typeof event.constraint === "string") {
+      if (!isWithinBusinessHours(newStart, newEnd, viewConfig)) return false;
+    }
+  }
+  if (config.eventConstraint) {
+    if (config.eventConstraint === "businessHours") {
+      if (!isWithinBusinessHours(newStart, newEnd, viewConfig)) return false;
+    } else {
+      if (!isWithinDateRange(newStart, newEnd, config.eventConstraint)) return false;
+    }
+  }
+  if (!checkOverlap(event, newStart, newEnd, allEvents, config)) return false;
+  if (viewConfig.validRange) {
+    if (!isWithinValidRange(newStart.toPlainDate(), viewConfig.validRange)) return false;
+    if (!isWithinValidRange(newEnd.toPlainDate(), viewConfig.validRange)) return false;
+  }
+  return true;
+}
+function validateSelection(start, end, allEvents, config, viewConfig, resourceId) {
+  if (config.selectAllow) {
+    if (!config.selectAllow({ start, end, resourceId })) return false;
+  }
+  if (config.selectConstraint) {
+    if (config.selectConstraint === "businessHours") {
+      if (!isWithinBusinessHours(start, end, viewConfig)) return false;
+    } else {
+      if (!isWithinDateRange(start, end, config.selectConstraint)) return false;
+    }
+  }
+  if (config.selectOverlap !== void 0) {
+    for (const existing of allEvents) {
+      if (zonedRangesOverlap(start, end, existing.start, existing.end)) {
+        if (typeof config.selectOverlap === "function") {
+          if (!config.selectOverlap(existing)) return false;
+        } else if (!config.selectOverlap) {
+          return false;
+        }
+      }
+    }
+  }
+  return true;
+}
+function isWithinValidRange(date, validRange) {
+  return temporalPolyfill.Temporal.PlainDate.compare(date, validRange.start) >= 0 && temporalPolyfill.Temporal.PlainDate.compare(date, validRange.end) < 0;
+}
+function isWithinBusinessHours(start, end, viewConfig) {
+  if (!viewConfig.businessHours) return true;
+  const bh = viewConfig.businessHours;
+  const startDay = start.toPlainDate().dayOfWeek % 7;
+  const startTime = start.toPlainTime();
+  const endTime = end.toPlainTime();
+  if (!bh.daysOfWeek.includes(startDay)) return false;
+  if (temporalPolyfill.Temporal.PlainTime.compare(startTime, bh.startTime) < 0) return false;
+  if (temporalPolyfill.Temporal.PlainTime.compare(endTime, bh.endTime) > 0) return false;
+  return true;
+}
+function isWithinDateRange(start, end, range) {
+  const startDate = start.toPlainDate();
+  const endDate = end.toPlainDate();
+  return temporalPolyfill.Temporal.PlainDate.compare(startDate, range.start) >= 0 && temporalPolyfill.Temporal.PlainDate.compare(endDate, range.end) <= 0;
+}
+function checkOverlap(movingEvent, newStart, newEnd, allEvents, config) {
+  if (!movingEvent.overlap) {
+    for (const existing of allEvents) {
+      if (existing.id === movingEvent.id) continue;
+      if (zonedRangesOverlap(newStart, newEnd, existing.start, existing.end)) {
+        return false;
+      }
+    }
+  }
+  if (config.eventOverlap !== void 0) {
+    for (const existing of allEvents) {
+      if (existing.id === movingEvent.id) continue;
+      if (!existing.overlap) continue;
+      if (zonedRangesOverlap(newStart, newEnd, existing.start, existing.end)) {
+        if (typeof config.eventOverlap === "function") {
+          if (!config.eventOverlap(existing, movingEvent)) return false;
+        } else if (!config.eventOverlap) {
+          return false;
+        }
+      }
+    }
+  }
+  return true;
+}
+
+// src/engine/event-source-engine.ts
+async function fetchEventSource(source, range, timezone) {
+  const { events: input } = source;
+  if (Array.isArray(input)) {
+    return applySourceDefaults(input, source);
+  }
+  if (typeof input === "string") {
+    return fetchJsonFeed(input, range, timezone, source);
+  }
+  if (typeof input === "function") {
+    const fetchInfo = {
+      start: range.start,
+      end: range.end,
+      startStr: range.start.toString(),
+      endStr: range.end.toString(),
+      timezone
+    };
+    const events = await input(fetchInfo);
+    return applySourceDefaults(events, source);
+  }
+  return [];
+}
+async function fetchJsonFeed(url, range, timezone, source) {
+  const params = new URLSearchParams({
+    start: range.start.toString(),
+    end: range.end.toString(),
+    timeZone: timezone,
+    ...source.extraParams
+  });
+  const separator = url.includes("?") ? "&" : "?";
+  const fullUrl = `${url}${separator}${params.toString()}`;
+  const response = await fetch(fullUrl);
+  if (!response.ok) {
+    throw new Error(`Event source fetch failed: ${response.status} ${response.statusText}`);
+  }
+  const events = await response.json();
+  return applySourceDefaults(events, source);
+}
+function applySourceDefaults(events, source) {
+  if (!source.color && !source.className && source.editable === void 0 && source.overlap === void 0) {
+    return events;
+  }
+  return events.map((event) => ({
+    ...event,
+    color: event.color ?? source.color,
+    className: event.className ?? source.className,
+    editable: event.editable ?? source.editable,
+    overlap: event.overlap ?? source.overlap
+  }));
+}
+async function mergeEventSources(sources, range, timezone) {
+  const results = await Promise.allSettled(
+    sources.map((source) => fetchEventSource(source, range, timezone))
+  );
+  const events = [];
+  const errors = /* @__PURE__ */ new Map();
+  results.forEach((result, index) => {
+    if (result.status === "fulfilled") {
+      events.push(...result.value);
+    } else {
+      errors.set(sources[index].id, result.reason);
+    }
+  });
+  return { events, errors };
+}
+function createEventSources(inputs) {
+  return inputs.map((input, index) => {
+    const def = normalizeEventSourceDef(input, index);
+    return {
+      id: def.id,
+      def,
+      state: "idle",
+      events: [],
+      error: null,
+      lastFetched: null
+    };
+  });
+}
+function formatDate(date, locale = "en-US", options) {
+  const defaultOptions = {
+    year: "numeric",
+    month: "long",
+    day: "numeric",
+    ...options
+  };
+  const jsDate = new Date(date.toString());
+  return new Intl.DateTimeFormat(locale, defaultOptions).format(jsDate);
+}
+function formatTime(time, locale = "en-US", options) {
+  const defaultOptions = {
+    hour: "numeric",
+    minute: "2-digit",
+    ...options
+  };
+  const jsDate = /* @__PURE__ */ new Date(`2000-01-01T${time.toString()}`);
+  return new Intl.DateTimeFormat(locale, defaultOptions).format(jsDate);
+}
+function formatDateRange(start, end, locale = "en-US", separator = " \u2013 ") {
+  const startDate = new Date(start.toString());
+  const endDate = new Date(end.subtract({ days: 1 }).toString());
+  if (start.equals(end.subtract({ days: 1 }))) {
+    return new Intl.DateTimeFormat(locale, {
+      year: "numeric",
+      month: "long",
+      day: "numeric"
+    }).format(startDate);
+  }
+  if (start.month === end.subtract({ days: 1 }).month && start.year === end.subtract({ days: 1 }).year) {
+    return `${new Intl.DateTimeFormat(locale, { month: "short" }).format(startDate)} ${start.day}${separator}${end.subtract({ days: 1 }).day}, ${start.year}`;
+  }
+  const startFormatted = new Intl.DateTimeFormat(locale, { month: "short", day: "numeric" }).format(
+    startDate
+  );
+  const endFormatted = new Intl.DateTimeFormat(locale, {
+    month: "short",
+    day: "numeric",
+    year: "numeric"
+  }).format(endDate);
+  return `${startFormatted}${separator}${endFormatted}`;
+}
+function getViewTitle(date, preset, locale = "en-US", titleFormat, titleRangeSeparator = " \u2013 ") {
+  const jsDate = new Date(date.toString());
+  if (titleFormat) {
+    return new Intl.DateTimeFormat(locale, titleFormat).format(jsDate);
+  }
+  switch (preset) {
+    case "dayGridMonth":
+    case "timelineMonth":
+    case "agendaMonth":
+      return new Intl.DateTimeFormat(locale, { year: "numeric", month: "long" }).format(jsDate);
+    case "dayGridWeek":
+    case "timeGridWeek":
+    case "timelineWeek":
+    case "agendaWeek": {
+      const weekEnd = date.add({ days: 6 });
+      return formatDateRange(date, weekEnd.add({ days: 1 }), locale, titleRangeSeparator);
+    }
+    case "dayGridDay":
+    case "timeGridDay":
+    case "timelineDay":
+    case "agendaDay":
+      return new Intl.DateTimeFormat(locale, {
+        weekday: "long",
+        year: "numeric",
+        month: "long",
+        day: "numeric"
+      }).format(jsDate);
+    default:
+      return new Intl.DateTimeFormat(locale, { year: "numeric", month: "long" }).format(jsDate);
+  }
+}
+function formatEventTime(dateTime, locale = "en-US", options) {
+  const jsDate = new Date(
+    dateTime.year,
+    dateTime.month - 1,
+    // JS months are 0-indexed
+    dateTime.day,
+    dateTime.hour,
+    dateTime.minute,
+    dateTime.second
+  );
+  return new Intl.DateTimeFormat(locale, {
+    hour: "numeric",
+    minute: "2-digit",
+    ...options
+  }).format(jsDate);
+}
+function formatSlotLabel(time, locale = "en-US", format) {
+  const defaultFormat = {
+    hour: "numeric",
+    minute: "2-digit",
+    ...format
+  };
+  const jsDate = /* @__PURE__ */ new Date(`2000-01-01T${time.toString()}`);
+  return new Intl.DateTimeFormat(locale, defaultFormat).format(jsDate);
+}
+function formatDayHeader(date, locale = "en-US", format) {
+  const defaultFormat = {
+    weekday: "short",
+    ...format
+  };
+  const jsDate = new Date(date.toString());
+  return new Intl.DateTimeFormat(locale, defaultFormat).format(jsDate);
+}
+function getWeekNumber(date) {
+  const jan4 = temporalPolyfill.Temporal.PlainDate.from({ year: date.year, month: 1, day: 4 });
+  const jan4DayOfWeek = jan4.dayOfWeek;
+  const isoWeekStart = jan4.subtract({ days: jan4DayOfWeek - 1 });
+  const daysSinceWeekStart = date.since(isoWeekStart, { largestUnit: "days" }).days;
+  if (daysSinceWeekStart < 0) {
+    return getWeekNumber(temporalPolyfill.Temporal.PlainDate.from({ year: date.year - 1, month: 12, day: 31 }));
+  }
+  const weekNumber = Math.floor(daysSinceWeekStart / 7) + 1;
+  if (weekNumber > 52) {
+    const dec31 = temporalPolyfill.Temporal.PlainDate.from({ year: date.year, month: 12, day: 31 });
+    const dec31Day = dec31.dayOfWeek;
+    if (dec31Day < 4) return 1;
+  }
+  return weekNumber;
+}
+var RTL_LOCALES = /* @__PURE__ */ new Set([
+  "ar",
+  "arc",
+  "dv",
+  "fa",
+  "ha",
+  "he",
+  "khw",
+  "ks",
+  "ku",
+  "ps",
+  "ur",
+  "yi"
+]);
+function isRtl(locale) {
+  const primary = locale.split("-")[0].toLowerCase();
+  return RTL_LOCALES.has(primary);
+}
+var DAY_MAP = {
+  MO: 1,
+  TU: 2,
+  WE: 3,
+  TH: 4,
+  FR: 5,
+  SA: 6,
+  SU: 7
+};
+function parseRRule(rruleStr) {
+  const cleanStr = rruleStr.replace(/^RRULE:/i, "");
+  const parts = cleanStr.split(";");
+  const result = {
+    freq: "WEEKLY",
+    interval: 1
+  };
+  for (const part of parts) {
+    const [key, value] = part.split("=");
+    if (!key || !value) continue;
+    switch (key.toUpperCase()) {
+      case "FREQ":
+        result.freq = value.toUpperCase();
+        break;
+      case "INTERVAL":
+        result.interval = parseInt(value, 10);
+        break;
+      case "COUNT":
+        result.count = parseInt(value, 10);
+        break;
+      case "UNTIL":
+        result.until = parseRRuleDate(value);
+        break;
+      case "BYDAY":
+        result.byDay = value.split(",").map((d) => d.trim().toUpperCase());
+        break;
+      case "BYMONTHDAY":
+        result.byMonthDay = value.split(",").map((d) => parseInt(d, 10));
+        break;
+      case "BYMONTH":
+        result.byMonth = value.split(",").map((m) => parseInt(m, 10));
+        break;
+      case "WKST":
+        result.wkst = value.toUpperCase();
+        break;
+    }
+  }
+  return result;
+}
+function parseRRuleDate(dateStr) {
+  const cleanDate = dateStr.replace(/[TZ]/g, "").substring(0, 8);
+  const year = parseInt(cleanDate.substring(0, 4), 10);
+  const month = parseInt(cleanDate.substring(4, 6), 10);
+  const day = parseInt(cleanDate.substring(6, 8), 10);
+  return temporalPolyfill.Temporal.PlainDate.from({ year, month, day });
+}
+function expandRRule(start, rruleStr, rangeStart, rangeEnd, exDates = [], maxOccurrences = 365) {
+  const rule = parseRRule(rruleStr);
+  const occurrences = [];
+  const exDateSet = new Set(exDates.map((d) => d.toString()));
+  let count = 0;
+  let current = start;
+  const safetyLimit = maxOccurrences * 10;
+  let iterations = 0;
+  while (iterations < safetyLimit) {
+    iterations++;
+    if (rule.count !== void 0 && count >= rule.count) break;
+    if (rule.until && temporalPolyfill.Temporal.PlainDate.compare(current, rule.until) > 0) break;
+    if (temporalPolyfill.Temporal.PlainDate.compare(current, rangeEnd) >= 0) break;
+    if (matchesRule(current, rule)) {
+      if (temporalPolyfill.Temporal.PlainDate.compare(current, rangeStart) >= 0 && !exDateSet.has(current.toString())) {
+        occurrences.push(current);
+      }
+      count++;
+      if (occurrences.length >= maxOccurrences) break;
+    }
+    current = advanceDate(current, rule);
+  }
+  return occurrences;
+}
+function matchesRule(date, rule, _seriesStart) {
+  if (rule.byDay && rule.byDay.length > 0) {
+    const dayOfWeek = date.dayOfWeek;
+    const dayMatch = rule.byDay.some((day) => DAY_MAP[day] === dayOfWeek);
+    if (!dayMatch) return false;
+  }
+  if (rule.byMonthDay && rule.byMonthDay.length > 0) {
+    if (!rule.byMonthDay.includes(date.day)) return false;
+  }
+  if (rule.byMonth && rule.byMonth.length > 0) {
+    if (!rule.byMonth.includes(date.month)) return false;
+  }
+  return true;
+}
+function advanceDate(current, rule) {
+  switch (rule.freq) {
+    case "DAILY":
+      return current.add({ days: rule.interval });
+    case "WEEKLY":
+      if (rule.byDay && rule.byDay.length > 0) {
+        return current.add({ days: 1 });
+      }
+      return current.add({ weeks: rule.interval });
+    case "MONTHLY":
+      if (rule.byMonthDay && rule.byMonthDay.length > 0) {
+        return current.add({ days: 1 });
+      }
+      return current.add({ months: rule.interval });
+    case "YEARLY":
+      if (rule.byMonth && rule.byMonth.length > 0) {
+        return current.add({ days: 1 });
+      }
+      return current.add({ years: rule.interval });
+    default:
+      return current.add({ days: 1 });
+  }
+}
+
+// src/plugins/daygrid.ts
+var dayGridLayoutSolver = (events, config, context) => {
+  const spine = generateDateSpine(config);
+  const weeks = spine.weeks ?? [];
+  const dayCells = solveDayGridLayout(events, weeks, config.eventMaxStack ?? 3, "UTC");
+  return {
+    viewType: "dayGrid",
+    dateRange: config.visibleRange,
+    weeks: dayCells
+  };
+};
+var dayGridPlugin = {
+  name: "dayGrid",
+  viewTypes: ["dayGrid"],
+  layoutSolvers: {
+    dayGrid: dayGridLayoutSolver
+  }
+};
+
+// src/plugins/timegrid.ts
+var timeGridLayoutSolver = (events, config, _context) => {
+  const spine = generateDateSpine(config);
+  const dates = spine.dates;
+  const slotsPerDay = spine.slots ?? [];
+  const allDayEvents = events.filter((e) => e.isAllDay);
+  const timedEvents = events.filter((e) => !e.isAllDay);
+  const columns = dates.map((date, dayIdx) => {
+    const dayStart = date.toZonedDateTime({
+      timeZone: "UTC",
+      plainTime: config.slotMinTime
+    });
+    const dayEnd = date.toZonedDateTime({
+      timeZone: "UTC",
+      plainTime: config.slotMaxTime
+    });
+    const columnEvents = timedEvents.filter((event) => {
+      return compareZonedDateTimes(event.start, dayEnd) < 0 && compareZonedDateTimes(event.end, dayStart) > 0;
+    });
+    const positioned = solveLayout(columnEvents, config);
+    return {
+      date,
+      slots: slotsPerDay[dayIdx] ?? [],
+      events: positioned
+    };
+  });
+  const allDayPositioned = allDayEvents.map((event, idx) => ({
+    event,
+    column: 0,
+    totalColumns: 1,
+    top: 0,
+    height: 24,
+    left: 0,
+    width: 100,
+    daySpan: 1,
+    startSlotIndex: idx,
+    endSlotIndex: idx,
+    isDragging: false,
+    isResizing: false,
+    isSelected: false,
+    isFocused: false
+  }));
+  return {
+    viewType: "timeGrid",
+    dateRange: config.visibleRange,
+    columns,
+    allDayRow: allDayPositioned,
+    timeSlots: slotsPerDay[0] ?? [],
+    nowPosition: getNowPosition(config)
+  };
+};
+var timeGridPlugin = {
+  name: "timeGrid",
+  viewTypes: ["timeGrid"],
+  layoutSolvers: {
+    timeGrid: timeGridLayoutSolver
+  }
+};
+
+// src/plugins/timeline.ts
+var timelineLayoutSolver = (events, config, context) => {
+  const spine = generateDateSpine(config);
+  const resources = context.getResources();
+  const lanes = resources.map((resource) => {
+    const resourceEvents = events.filter((e) => e.resourceIds.includes(resource.id));
+    const positioned = solveLayout(resourceEvents, config);
+    return {
+      resource,
+      events: positioned
+    };
+  });
+  const unassignedEvents = events.filter((e) => e.resourceIds.length === 0);
+  if (unassignedEvents.length > 0) {
+    lanes.push({
+      resource: { id: "__unassigned__", title: "Unassigned" },
+      events: solveLayout(unassignedEvents, config)
+    });
+  }
+  return {
+    viewType: "timeline",
+    dateRange: config.visibleRange,
+    lanes,
+    timeSlots: spine.slots?.[0] ?? [],
+    nowPosition: getNowPosition(config)
+  };
+};
+var timelinePlugin = {
+  name: "timeline",
+  viewTypes: ["timeline"],
+  layoutSolvers: {
+    timeline: timelineLayoutSolver
+  }
+};
+var agendaLayoutSolver = (events, config, _context) => {
+  const groups = [];
+  for (const date of iterateDays(config.visibleRange.start, config.visibleRange.end)) {
+    const dateStart = date.toZonedDateTime({
+      timeZone: "UTC",
+      plainTime: temporalPolyfill.Temporal.PlainTime.from("00:00")
+    });
+    const dateEnd = date.add({ days: 1 }).toZonedDateTime({
+      timeZone: "UTC",
+      plainTime: temporalPolyfill.Temporal.PlainTime.from("00:00")
+    });
+    const dayEvents = events.filter(
+      (event) => compareZonedDateTimes(event.start, dateEnd) < 0 && compareZonedDateTimes(event.end, dateStart) > 0
+    ).sort((a, b) => compareZonedDateTimes(a.start, b.start));
+    if (dayEvents.length > 0) {
+      groups.push({ date, events: dayEvents });
+    }
+  }
+  return {
+    viewType: "agenda",
+    dateRange: config.visibleRange,
+    groups
+  };
+};
+var agendaPlugin = {
+  name: "agenda",
+  viewTypes: ["agenda"],
+  layoutSolvers: {
+    agenda: agendaLayoutSolver
+  }
+};
+function generateMonthGrids(startDate, monthCount, firstDayOfWeek, timezone) {
+  const months = [];
+  for (let i = 0; i < monthCount; i++) {
+    const monthDate = startDate.add({ months: i });
+    const monthStart = monthDate.with({ day: 1 });
+    monthStart.add({ months: 1 });
+    let gridStart = monthStart;
+    while (gridStart.dayOfWeek % 7 !== firstDayOfWeek) {
+      gridStart = gridStart.subtract({ days: 1 });
+    }
+    const weeks = [];
+    let currentDay = gridStart;
+    for (let w = 0; w < 6; w++) {
+      const week = [];
+      for (let d = 0; d < 7; d++) {
+        week.push(currentDay);
+        currentDay = currentDay.add({ days: 1 });
+      }
+      weeks.push(week);
+    }
+    months.push({ month: monthStart, weeks });
+  }
+  return months;
+}
+var multiMonthLayoutSolver = (events, config, context) => {
+  const defaultMonthCount = config.preset === "multiMonthStack" ? 3 : 4;
+  const monthCount = config.multiMonthMaxColumns ?? defaultMonthCount;
+  const startDate = config.visibleRange.start.with({ day: 1 });
+  const firstDayOfWeek = config.firstDayOfWeek ?? 0;
+  const monthGrids = generateMonthGrids(startDate, monthCount, firstDayOfWeek);
+  const monthLayouts = monthGrids.map(({ month, weeks }) => {
+    const dayCells = solveDayGridLayout(
+      events,
+      weeks,
+      config.eventMaxStack ?? 2,
+      // Smaller max for multi-month
+      "UTC"
+    );
+    return {
+      month,
+      weeks: dayCells
+    };
+  });
+  return {
+    viewType: "multiMonth",
+    dateRange: config.visibleRange,
+    months: monthLayouts
+  };
+};
+var multiMonthPlugin = {
+  name: "multiMonth",
+  viewTypes: ["multiMonth"],
+  layoutSolvers: {
+    multiMonth: multiMonthLayoutSolver
+  }
+};
+var resourceTimeGridLayoutSolver = (events, config, context) => {
+  const resources = context.getResources();
+  const dates = Array.from(iterateDays(config.visibleRange.start, config.visibleRange.end));
+  const slots = generateTimeSlots(dates[0] ?? config.visibleRange.start, config);
+  const resourceLanes = resources.map((resource) => {
+    const resourceEvents = events.filter(
+      (event) => event.resourceIds?.includes(resource.id) ?? false
+    );
+    const dayColumns = dates.map((date) => {
+      const dateStart = date.toZonedDateTime({
+        timeZone: "UTC",
+        plainTime: config.slotMinTime
+      });
+      const dateEnd = date.toZonedDateTime({
+        timeZone: "UTC",
+        plainTime: config.slotMaxTime
+      });
+      const dayEvents = resourceEvents.filter(
+        (event) => compareZonedDateTimes(event.start, dateEnd) < 0 && compareZonedDateTimes(event.end, dateStart) > 0
+      );
+      return solveLayout(dayEvents, config);
+    });
+    return {
+      resource,
+      events: dayColumns.flat(),
+      date: dates[0]
+    };
+  });
+  return {
+    viewType: "resourceTimeGrid",
+    dateRange: config.visibleRange,
+    slots,
+    resourceLanes
+  };
+};
+var verticalResourcePlugin = {
+  name: "verticalResource",
+  viewTypes: ["resourceTimeGrid"],
+  layoutSolvers: {
+    resourceTimeGrid: resourceTimeGridLayoutSolver
+  }
+};
+function calculateNewTimes(params) {
+  const {
+    operation,
+    originalStartMinutes,
+    originalEndMinutes,
+    deltaMinutes,
+    minHour,
+    maxHour,
+    snapMinutes
+  } = params;
+  const minMinutes = minHour * 60;
+  const maxMinutes = maxHour * 60;
+  const duration = originalEndMinutes - originalStartMinutes;
+  let newStart;
+  let newEnd;
+  switch (operation) {
+    case "move":
+      newStart = snap(originalStartMinutes + deltaMinutes, snapMinutes);
+      newEnd = newStart + duration;
+      if (newStart < minMinutes) {
+        newStart = minMinutes;
+        newEnd = newStart + duration;
+      }
+      if (newEnd > maxMinutes) {
+        newEnd = maxMinutes;
+        newStart = newEnd - duration;
+      }
+      break;
+    case "resize-start":
+      newStart = snap(originalStartMinutes + deltaMinutes, snapMinutes);
+      newEnd = originalEndMinutes;
+      newStart = Math.max(minMinutes, Math.min(newStart, newEnd - snapMinutes));
+      break;
+    case "resize-end":
+      newStart = originalStartMinutes;
+      newEnd = snap(originalEndMinutes + deltaMinutes, snapMinutes);
+      newEnd = Math.min(maxMinutes, Math.max(newEnd, newStart + snapMinutes));
+      break;
+  }
+  return { start: newStart, end: newEnd };
+}
+function snap(value, gridSize) {
+  return Math.round(value / gridSize) * gridSize;
+}
+function getSnapMinutes(config) {
+  const snapDuration = config.snapDuration ?? config.slotDuration;
+  return (snapDuration.hours || 0) * 60 + (snapDuration.minutes || 0) || 30;
+}
+function resolveDropTarget(yPercent, config) {
+  const minMinutes = config.slotMinTime.hour * 60 + config.slotMinTime.minute;
+  const maxMinutes = config.slotMaxTime.hour * 60 + config.slotMaxTime.minute;
+  const totalMinutes = maxMinutes - minMinutes;
+  const targetMinutes = minMinutes + yPercent / 100 * totalMinutes;
+  const snapMinutes = getSnapMinutes(config);
+  const snapped = snap(targetMinutes, snapMinutes);
+  return {
+    hour: Math.floor(snapped / 60),
+    minute: snapped % 60
+  };
+}
+var interactionPlugin = {
+  name: "interaction",
+  interactionHandlers: [
+    {
+      type: "drag",
+      onStart: (_info) => {
+      },
+      onMove: (_info) => {
+      },
+      onEnd: (info) => {
+        if (!info.event) return { type: "create" };
+        return {
+          type: "move",
+          event: info.event,
+          newStart: void 0,
+          // Computed by the React layer
+          newEnd: void 0
+        };
+      }
+    },
+    {
+      type: "resize",
+      onStart: (_info) => {
+      },
+      onMove: (_info) => {
+      },
+      onEnd: (info) => ({
+        type: "resize",
+        event: info.event,
+        newStart: void 0,
+        newEnd: void 0
+      })
+    },
+    {
+      type: "select",
+      onEnd: (info) => ({
+        type: "select",
+        event: void 0,
+        newStart: void 0,
+        newEnd: void 0
+      })
+    },
+    {
+      type: "click",
+      onEnd: (info) => ({
+        type: "select",
+        event: info.event
+      })
+    }
+  ]
+};
+function isDropAllowed(event, newStart, newEnd, allEvents, constraints, viewConfig, resourceId) {
+  return validateEventDrop(event, newStart, newEnd, allEvents, constraints, viewConfig, resourceId);
+}
+
+// src/plugins/registry.ts
+function createPluginRegistry(plugins) {
+  const registry = {
+    viewTypes: /* @__PURE__ */ new Set(),
+    layoutSolvers: /* @__PURE__ */ new Map(),
+    eventNormalizers: [],
+    interactionHandlers: []
+  };
+  for (const plugin of plugins) {
+    if (plugin.viewTypes) {
+      for (const vt of plugin.viewTypes) {
+        registry.viewTypes.add(vt);
+      }
+    }
+    if (plugin.layoutSolvers) {
+      for (const [viewType, solver] of Object.entries(plugin.layoutSolvers)) {
+        if (solver) {
+          registry.layoutSolvers.set(viewType, solver);
+        }
+      }
+    }
+    if (plugin.eventNormalizers) {
+      registry.eventNormalizers.push(...plugin.eventNormalizers);
+    }
+    if (plugin.interactionHandlers) {
+      registry.interactionHandlers.push(...plugin.interactionHandlers);
+    }
+  }
+  return registry;
+}
+function resolveLayoutSolver(viewType, registry) {
+  return registry.layoutSolvers.get(viewType);
+}
+function applyEventNormalizers(events, registry, context) {
+  let result = [...events];
+  for (const normalizer of registry.eventNormalizers) {
+    const expanded = [];
+    for (const event of result) {
+      const output = normalizer(event, context);
+      if (Array.isArray(output)) {
+        expanded.push(...output);
+      } else {
+        expanded.push(output);
+      }
+    }
+    result = expanded;
+  }
+  return result;
+}
+
+exports.EventStore = EventStore;
+exports.addDurationToDateTime = addDurationToDateTime;
+exports.agendaPlugin = agendaPlugin;
+exports.applyEventNormalizers = applyEventNormalizers;
+exports.calculateNewTimes = calculateNewTimes;
+exports.clampDateToRange = clampDateToRange;
+exports.clampToValidRange = clampToValidRange;
+exports.compareDateTimes = compareDateTimes;
+exports.compareDates = compareDates;
+exports.compareTimes = compareTimes;
+exports.compareZonedDateTimes = compareZonedDateTimes;
+exports.createDateRange = createDateRange;
+exports.createEventSources = createEventSources;
+exports.createPluginRegistry = createPluginRegistry;
+exports.dayGridPlugin = dayGridPlugin;
+exports.daysBetween = daysBetween;
+exports.durationBetween = durationBetween;
+exports.eventToPlainObject = eventToPlainObject;
+exports.expandRRule = expandRRule;
+exports.fetchEventSource = fetchEventSource;
+exports.formatDate = formatDate;
+exports.formatDateRange = formatDateRange;
+exports.formatDayHeader = formatDayHeader;
+exports.formatEventTime = formatEventTime;
+exports.formatSlotLabel = formatSlotLabel;
+exports.formatTime = formatTime;
+exports.fromISODayOfWeek = fromISODayOfWeek;
+exports.generateDateSpine = generateDateSpine;
+exports.generateTimeSlots = generateTimeSlots;
+exports.getDaysInMonth = getDaysInMonth;
+exports.getMonthEnd = getMonthEnd;
+exports.getMonthStart = getMonthStart;
+exports.getMonthVisibleRange = getMonthVisibleRange;
+exports.getNowPosition = getNowPosition;
+exports.getSlotIndex = getSlotIndex;
+exports.getSnapMinutes = getSnapMinutes;
+exports.getToday = getToday2;
+exports.getTodayDate = getToday;
+exports.getViewTitle = getViewTitle;
+exports.getVisibleRange = getVisibleRange;
+exports.getWeekEnd = getWeekEnd;
+exports.getWeekNumber = getWeekNumber;
+exports.getWeekStart = getWeekStart;
+exports.interactionPlugin = interactionPlugin;
+exports.invariant = invariant;
+exports.isDropAllowed = isDropAllowed;
+exports.isRtl = isRtl;
+exports.isWeekend = isWeekend;
+exports.isWithinValidRange = isWithinValidRange;
+exports.iterateDays = iterateDays;
+exports.mergeEventSources = mergeEventSources;
+exports.multiMonthPlugin = multiMonthPlugin;
+exports.navigateNext = navigateNext;
+exports.navigatePrev = navigatePrev;
+exports.normalizeEvent = normalizeEvent;
+exports.normalizeEventSourceDef = normalizeEventSourceDef;
+exports.parseRRule = parseRRule;
+exports.rangeContains = rangeContains;
+exports.rangesOverlap = rangesOverlap;
+exports.resolveDropTarget = resolveDropTarget;
+exports.resolveLayoutSolver = resolveLayoutSolver;
+exports.snapToSlot = snapToSlot;
+exports.solveDayGridLayout = solveDayGridLayout;
+exports.solveLayout = solveLayout;
+exports.solveLayoutFull = solveLayoutFull;
+exports.timeGridPlugin = timeGridPlugin;
+exports.timelinePlugin = timelinePlugin;
+exports.toISODayOfWeek = toISODayOfWeek;
+exports.validateEventDrop = validateEventDrop;
+exports.validateSelection = validateSelection;
+exports.verticalResourcePlugin = verticalResourcePlugin;
+exports.viewTypeFromPreset = viewTypeFromPreset;
+exports.viewUnitFromPreset = viewUnitFromPreset;
+exports.zonedRangeContains = zonedRangeContains;
+exports.zonedRangesOverlap = zonedRangesOverlap;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map