@primeui/scheduler-core 0.0.1-alpha.1

package/dist/chunk-2THQAZ26.mjs

@@ -0,0 +1,1669 @@
+import { canDropEventWithResourceConstraints, getResourceCapacity } from './chunk-NX46LPLF.mjs';
+import { getEventStart, moveEventTo, getEventEnd, resizeEventBy } from './chunk-2B3YLWHA.mjs';
+import { addDays, addYears, addMonths, parseTimeString, timeStringToMinutes, isSameDay, startOfWeek } from './chunk-WFUJWDST.mjs';
+import { formatTime, formatTimeRange, createSchedulerDateFormatter } from './chunk-TNKJPFGI.mjs';
+import { differenceInCalendarDays, addCalendarDaysToDate, resolveSchedulerCalendarModeForView, getSchedulerCalendarAdapter } from './chunk-DYW6WUHE.mjs';
+import { findResourceById } from './chunk-QR2SVYAD.mjs';
+
+// src/interaction/drag.ts
+var DEFAULT_DRAG_MIN_DISTANCE = 5;
+var DEFAULT_SNAP_DURATION = 15;
+function createDragState(event, startX, startY, offsetX, offsetY) {
+  return {
+    event: { ...event },
+    originalEvent: { ...event },
+    startX,
+    startY,
+    currentX: startX,
+    currentY: startY,
+    offsetX,
+    offsetY,
+    delta: { days: 0, milliseconds: 0 },
+    isDragging: false,
+    hasMovedMinDistance: false
+  };
+}
+function updateDragState(state, currentX, currentY, minDistance = DEFAULT_DRAG_MIN_DISTANCE) {
+  const dx = currentX - state.startX;
+  const dy = currentY - state.startY;
+  const distance = Math.sqrt(dx * dx + dy * dy);
+  return {
+    ...state,
+    currentX,
+    currentY,
+    hasMovedMinDistance: state.hasMovedMinDistance || distance >= minDistance,
+    isDragging: state.hasMovedMinDistance || distance >= minDistance
+  };
+}
+function snapToSlot(minutes, slotDuration) {
+  return Math.round(minutes / slotDuration) * slotDuration;
+}
+function snapTime(date, slotDuration) {
+  const totalMinutes = date.getHours() * 60 + date.getMinutes();
+  const snappedMinutes = snapToSlot(totalMinutes, slotDuration);
+  const result = new Date(date);
+  result.setHours(Math.floor(snappedMinutes / 60), snappedMinutes % 60, 0, 0);
+  return result;
+}
+function calculateTimeDelta(pixelDelta, slotHeight, slotDuration, snapDuration = slotDuration) {
+  const minutesDelta = pixelDelta / slotHeight * slotDuration;
+  return snapToSlot(minutesDelta, snapDuration) * 60 * 1e3;
+}
+function getSchedulerTimedInteractionDeltaMs(input) {
+  return calculateTimeDelta(input.pixelDelta, input.slotHeight, input.slotDuration, input.snapDuration);
+}
+function getSchedulerEventDropDelta(sourceStart, nextStart, options = {}) {
+  const days = differenceInCalendarDays(sourceStart, nextStart, options);
+  if (days === 0) {
+    return { days, milliseconds: nextStart.getTime() - sourceStart.getTime() };
+  }
+  const dayAdjustedStart = addCalendarDaysToDate(sourceStart, days, options);
+  return {
+    days,
+    milliseconds: nextStart.getTime() - dayAdjustedStart.getTime()
+  };
+}
+function createSchedulerEventDropCandidate({ source, date, resourceId, preserveTime = true, calendar, locale, view }) {
+  const sourceStart = getEventStart(source);
+  const target = new Date(date);
+  if (preserveTime) {
+    target.setHours(sourceStart.getHours(), sourceStart.getMinutes(), sourceStart.getSeconds(), sourceStart.getMilliseconds());
+  }
+  const targetResourceId = resourceId ?? source.resourceId;
+  const next = {
+    ...moveEventTo(source, target),
+    resourceId: targetResourceId
+  };
+  const nextStart = getEventStart(next);
+  const nextEnd = getEventEnd(next);
+  const delta = getSchedulerEventDropDelta(sourceStart, nextStart, { calendar, locale, view });
+  return { next, nextStart, nextEnd, sourceStart, targetResourceId, delta };
+}
+function calculateDayDelta(pixelDelta, columnWidth) {
+  return Math.round(pixelDelta / columnWidth);
+}
+function shouldApplyCalendarDayDelta(calendarOptions) {
+  if (!calendarOptions) {
+    return false;
+  }
+  const mode = resolveSchedulerCalendarModeForView(calendarOptions.calendar ?? "gregory", calendarOptions.view);
+  if (mode === "gregory") {
+    return false;
+  }
+  return getSchedulerCalendarAdapter(mode, { locale: calendarOptions.locale }).id !== "gregory";
+}
+function applyDeltaToEvent(event, delta, calendarOptions) {
+  const start = typeof event.start === "string" ? new Date(event.start) : new Date(event.start);
+  const end = event.end ? typeof event.end === "string" ? new Date(event.end) : new Date(event.end) : null;
+  const hasCalendarDayDelta = shouldApplyCalendarDayDelta(calendarOptions) && delta.days !== 0;
+  if (hasCalendarDayDelta) {
+    const calendarStart = addCalendarDaysToDate(start, delta.days, calendarOptions);
+    const newStart2 = new Date(calendarStart.getTime() + delta.milliseconds);
+    const totalDelta2 = newStart2.getTime() - start.getTime();
+    const newEnd2 = end ? new Date(end.getTime() + totalDelta2) : void 0;
+    return {
+      ...event,
+      start: newStart2,
+      end: newEnd2
+    };
+  }
+  const dayMillis = delta.days * 24 * 60 * 60 * 1e3;
+  const totalDelta = dayMillis + delta.milliseconds;
+  const newStart = new Date(start.getTime() + totalDelta);
+  const newEnd = end ? new Date(end.getTime() + totalDelta) : void 0;
+  return {
+    ...event,
+    start: newStart,
+    end: newEnd
+  };
+}
+function validateDragPosition(event, delta, constraints, allEvents) {
+  const newEvent = applyDeltaToEvent(event, delta);
+  const newStart = typeof newEvent.start === "string" ? new Date(newEvent.start) : newEvent.start;
+  const newEnd = newEvent.end ? typeof newEvent.end === "string" ? new Date(newEvent.end) : newEvent.end : newStart;
+  if (constraints.minDate && newStart < constraints.minDate) {
+    return { valid: false, reason: "Event would be before minimum date" };
+  }
+  if (constraints.maxDate && newEnd > constraints.maxDate) {
+    return { valid: false, reason: "Event would be after maximum date" };
+  }
+  if (constraints.allowOverlap === false) {
+    const overlapping = findOverlappingEvents(newEvent, allEvents);
+    if (overlapping.length > 0) {
+      return { valid: false, reason: "Event would overlap with another event" };
+    }
+  }
+  return { valid: true };
+}
+function findOverlappingEvents(event, allEvents) {
+  const eventStart = typeof event.start === "string" ? new Date(event.start) : event.start;
+  const eventEnd = event.end ? typeof event.end === "string" ? new Date(event.end) : event.end : new Date(eventStart.getTime() + 30 * 60 * 1e3);
+  return allEvents.filter((other) => {
+    if (other.id === event.id) return false;
+    const otherStart = typeof other.start === "string" ? new Date(other.start) : other.start;
+    const otherEnd = other.end ? typeof other.end === "string" ? new Date(other.end) : other.end : new Date(otherStart.getTime() + 30 * 60 * 1e3);
+    return eventStart < otherEnd && eventEnd > otherStart;
+  });
+}
+function isEventDraggable(event, globalEditable = false, eventStartEditable = true) {
+  if (event.draggable === false) return false;
+  if (event.editable === false) return false;
+  if (event.draggable === true) return true;
+  if (event.editable === true) return eventStartEditable;
+  return globalEditable && eventStartEditable;
+}
+function getTimeFromYPosition(yPosition, date, slotMinTime, slotDuration, slotHeight) {
+  const [minHours, minMinutes] = slotMinTime.split(":").map(Number);
+  const minTimeInMinutes = minHours * 60 + (minMinutes || 0);
+  const minutesPerPixel = slotDuration / slotHeight;
+  const minutesFromTop = yPosition * minutesPerPixel;
+  const totalMinutes = minTimeInMinutes + minutesFromTop;
+  const snappedMinutes = snapToSlot(totalMinutes, slotDuration);
+  const hours = Math.floor(snappedMinutes / 60);
+  const minutes = snappedMinutes % 60;
+  const result = new Date(date);
+  result.setHours(hours, minutes, 0, 0);
+  return result;
+}
+function getYPositionFromTime(date, slotMinTime, slotDuration, slotHeight) {
+  const [minHours, minMinutes] = slotMinTime.split(":").map(Number);
+  const minTimeInMinutes = minHours * 60 + (minMinutes || 0);
+  const timeInMinutes = date.getHours() * 60 + date.getMinutes();
+  const minutesFromMin = timeInMinutes - minTimeInMinutes;
+  return minutesFromMin / slotDuration * slotHeight;
+}
+function getDayIndexFromX(x, columnWidth, numColumns) {
+  const index = Math.floor(x / columnWidth);
+  return Math.max(0, Math.min(index, numColumns - 1));
+}
+function clampTime(date, slotMinTime, slotMaxTime) {
+  const [minHours, minMinutes] = slotMinTime.split(":").map(Number);
+  const [maxHours, maxMinutes] = slotMaxTime.split(":").map(Number);
+  const minTimeInMinutes = minHours * 60 + (minMinutes || 0);
+  const maxTimeInMinutes = maxHours * 60 + (maxMinutes || 0);
+  const currentMinutes = date.getHours() * 60 + date.getMinutes();
+  const clampedMinutes = Math.max(minTimeInMinutes, Math.min(currentMinutes, maxTimeInMinutes));
+  const result = new Date(date);
+  result.setHours(Math.floor(clampedMinutes / 60), clampedMinutes % 60, 0, 0);
+  return result;
+}
+function calculateDragDelta(state, columnWidth, slotHeight, slotDuration) {
+  const dxPixels = state.currentX - state.startX;
+  const dyPixels = state.currentY - state.startY;
+  const days = calculateDayDelta(dxPixels, columnWidth);
+  const milliseconds = calculateTimeDelta(dyPixels, slotHeight, slotDuration);
+  return { days, milliseconds };
+}
+
+// src/interaction/auto-scroll.ts
+var DEFAULT_THRESHOLD = 48;
+var DEFAULT_MAX_SPEED = 18;
+var DEFAULT_INTERVAL = 16;
+function resolveEdgeSpeed(distanceIntoEdge, threshold, maxSpeed) {
+  if (distanceIntoEdge <= 0) return 0;
+  const ratio = Math.min(1, distanceIntoEdge / threshold);
+  return Math.max(1, Math.round(maxSpeed * ratio));
+}
+function resolveAutoScrollDelta(input) {
+  const { pointerX, pointerY, rect, canScrollX, canScrollY, threshold, maxSpeed } = input;
+  let x = 0;
+  let y = 0;
+  if (canScrollX && pointerY >= rect.top && pointerY <= rect.bottom) {
+    if (pointerX >= rect.left && pointerX <= rect.left + threshold) {
+      x = -resolveEdgeSpeed(rect.left + threshold - pointerX, threshold, maxSpeed);
+    } else if (pointerX <= rect.right && pointerX >= rect.right - threshold) {
+      x = resolveEdgeSpeed(pointerX - (rect.right - threshold), threshold, maxSpeed);
+    }
+  }
+  if (canScrollY && pointerX >= rect.left && pointerX <= rect.right) {
+    if (pointerY >= rect.top && pointerY <= rect.top + threshold) {
+      y = -resolveEdgeSpeed(rect.top + threshold - pointerY, threshold, maxSpeed);
+    } else if (pointerY <= rect.bottom && pointerY >= rect.bottom - threshold) {
+      y = resolveEdgeSpeed(pointerY - (rect.bottom - threshold), threshold, maxSpeed);
+    }
+  }
+  return { x, y };
+}
+function createDragAutoScroller(options) {
+  const threshold = options.threshold ?? DEFAULT_THRESHOLD;
+  const maxSpeed = options.maxSpeed ?? DEFAULT_MAX_SPEED;
+  const interval = options.interval ?? DEFAULT_INTERVAL;
+  let point = null;
+  let timer = null;
+  const isEnabled = () => (typeof options.enabled === "function" ? options.enabled() : options.enabled) !== false;
+  const stop = () => {
+    if (timer !== null) {
+      clearInterval(timer);
+      timer = null;
+    }
+    point = null;
+  };
+  const tick = () => {
+    if (!point || !isEnabled()) {
+      stop();
+      return;
+    }
+    let scrolled = false;
+    for (const target of options.getContainers(point)) {
+      if (!target) continue;
+      const rect = target.measure();
+      const delta = resolveAutoScrollDelta({
+        pointerX: point.clientX,
+        pointerY: point.clientY,
+        rect,
+        canScrollX: isScrollContainerScrollable(target, "x"),
+        canScrollY: isScrollContainerScrollable(target, "y"),
+        threshold,
+        maxSpeed
+      });
+      scrolled = scrollTarget(target, delta) || scrolled;
+      if (scrolled) break;
+    }
+    if (!scrolled) {
+      stop();
+    }
+  };
+  const update = (nextPoint) => {
+    if (!isEnabled()) {
+      stop();
+      return;
+    }
+    point = nextPoint;
+    tick();
+    if (point && timer === null) {
+      timer = setInterval(tick, interval);
+    }
+  };
+  return {
+    update,
+    stop,
+    destroy: stop,
+    isActive: () => timer !== null
+  };
+}
+function isScrollContainerScrollable(target, axis) {
+  if (axis === "x") {
+    return target.scrollWidth > target.clientWidth;
+  }
+  return target.scrollHeight > target.clientHeight;
+}
+function scrollTarget(target, delta) {
+  if (delta.x === 0 && delta.y === 0) return false;
+  const beforeLeft = target.scrollLeft;
+  const beforeTop = target.scrollTop;
+  if (delta.x !== 0) {
+    target.scrollLeft += delta.x;
+  }
+  if (delta.y !== 0) {
+    target.scrollTop += delta.y;
+  }
+  return target.scrollLeft !== beforeLeft || target.scrollTop !== beforeTop;
+}
+
+// src/interaction/event-selection.ts
+var RESOURCE_VIEWS = ["resourceDay", "resourceWeek", "resourceMonth", "resourceTimelineDay", "resourceTimelineWeek", "resourceTimelineMonth"];
+function isResourceView(view) {
+  return RESOURCE_VIEWS.includes(view);
+}
+function eventBelongsToResource(event, resourceId) {
+  if (event.resourceId === resourceId) return true;
+  if (Array.isArray(event.resourceIds) && event.resourceIds.includes(resourceId)) return true;
+  return false;
+}
+function filterVisibleIdsByResource(visibleIds, events, resourceId, currentView) {
+  if (!isResourceView(currentView) || resourceId === void 0) {
+    return visibleIds;
+  }
+  const eventMap = new Map(events.map((e) => [e.id, e]));
+  return visibleIds.filter((id) => {
+    const event = eventMap.get(id);
+    if (!event) return false;
+    return eventBelongsToResource(event, resourceId);
+  });
+}
+var DEFAULT_OPTIONS = {
+  multiple: true,
+  selectMode: "click",
+  preserveOnNavigation: false,
+  maxSelection: void 0
+};
+function normalizeEventSelectionOptions(options) {
+  if (!options) {
+    return { ...DEFAULT_OPTIONS, enabled: false };
+  }
+  if (options === true) {
+    return { ...DEFAULT_OPTIONS, enabled: true };
+  }
+  return {
+    enabled: true,
+    multiple: options.multiple ?? DEFAULT_OPTIONS.multiple,
+    selectMode: options.selectMode ?? DEFAULT_OPTIONS.selectMode,
+    preserveOnNavigation: options.preserveOnNavigation ?? DEFAULT_OPTIONS.preserveOnNavigation,
+    maxSelection: options.maxSelection
+  };
+}
+var applyMaxSelection = (ids, maxSelection) => {
+  if (!maxSelection || maxSelection <= 0) {
+    return { ids, limitReached: false };
+  }
+  if (ids.length <= maxSelection) {
+    return { ids, limitReached: false };
+  }
+  return { ids: ids.slice(0, maxSelection), limitReached: true };
+};
+var buildRange = (anchorId, targetId, visibleIds) => {
+  const anchorIndex = visibleIds.indexOf(anchorId);
+  const targetIndex = visibleIds.indexOf(targetId);
+  if (anchorIndex === -1 || targetIndex === -1) {
+    return [targetId];
+  }
+  const start = Math.min(anchorIndex, targetIndex);
+  const end = Math.max(anchorIndex, targetIndex);
+  return visibleIds.slice(start, end + 1);
+};
+function applyEventSelection(params) {
+  const { eventId, visibleIds, modifiers, options, state } = params;
+  const selectedSet = new Set(state.selectedEventIds);
+  const isSelected = selectedSet.has(eventId);
+  if (!options.enabled) {
+    return { ...state, changed: false };
+  }
+  if (!options.multiple) {
+    return {
+      selectedEventIds: [eventId],
+      lastSelected: eventId,
+      selectionAnchor: eventId,
+      selectionModeActive: state.selectionModeActive,
+      changed: state.selectedEventIds.length !== 1 || state.selectedEventIds[0] !== eventId
+    };
+  }
+  const wantsRange = Boolean(modifiers.shiftKey && state.selectionAnchor);
+  const wantsToggle = Boolean(modifiers.ctrlKey || modifiers.metaKey || modifiers.toggle);
+  if (wantsRange && state.selectionAnchor !== null) {
+    const range = buildRange(state.selectionAnchor, eventId, visibleIds);
+    const { ids: nextIds, limitReached } = applyMaxSelection(range, options.maxSelection);
+    return {
+      selectedEventIds: nextIds,
+      lastSelected: eventId,
+      selectionAnchor: state.selectionAnchor,
+      selectionModeActive: state.selectionModeActive,
+      changed: true,
+      limitReached
+    };
+  }
+  if (wantsToggle) {
+    if (isSelected) {
+      const nextIds2 = state.selectedEventIds.filter((id) => id !== eventId);
+      const nextAnchor = state.selectionAnchor === eventId ? nextIds2[0] ?? null : state.selectionAnchor;
+      const nextLastSelected = nextIds2.length ? state.lastSelected : null;
+      return {
+        selectedEventIds: nextIds2,
+        lastSelected: nextLastSelected,
+        selectionAnchor: nextAnchor,
+        selectionModeActive: state.selectionModeActive,
+        changed: true
+      };
+    }
+    if (options.maxSelection && state.selectedEventIds.length >= options.maxSelection) {
+      return { ...state, changed: false, limitReached: true };
+    }
+    const nextIds = [...state.selectedEventIds, eventId];
+    return {
+      selectedEventIds: nextIds,
+      lastSelected: eventId,
+      selectionAnchor: state.selectionAnchor ?? eventId,
+      selectionModeActive: state.selectionModeActive,
+      changed: true
+    };
+  }
+  return {
+    selectedEventIds: [eventId],
+    lastSelected: eventId,
+    selectionAnchor: eventId,
+    selectionModeActive: state.selectionModeActive,
+    changed: state.selectedEventIds.length !== 1 || state.selectedEventIds[0] !== eventId
+  };
+}
+function selectAllVisibleEvents(visibleIds, options) {
+  if (!options.enabled) {
+    return {
+      selectedEventIds: [],
+      lastSelected: null,
+      selectionAnchor: null,
+      selectionModeActive: false,
+      changed: false
+    };
+  }
+  const { ids: nextIds, limitReached } = options.multiple ? applyMaxSelection(visibleIds, options.maxSelection) : { ids: visibleIds.slice(0, 1), limitReached: false };
+  const lastSelected = nextIds.length ? nextIds[nextIds.length - 1] : null;
+  return {
+    selectedEventIds: nextIds,
+    lastSelected,
+    selectionAnchor: nextIds[0] ?? null,
+    selectionModeActive: true,
+    changed: true,
+    limitReached
+  };
+}
+function invertSelection(currentIds, visibleIds, options) {
+  if (!options.enabled) {
+    return {
+      selectedEventIds: [],
+      lastSelected: null,
+      selectionAnchor: null,
+      selectionModeActive: false,
+      changed: false
+    };
+  }
+  const currentSet = new Set(currentIds);
+  const inverted = visibleIds.filter((id) => !currentSet.has(id));
+  const { ids: nextIds, limitReached } = options.multiple ? applyMaxSelection(inverted, options.maxSelection) : { ids: inverted.slice(0, 1), limitReached: false };
+  const lastSelected = nextIds.length ? nextIds[nextIds.length - 1] : null;
+  return {
+    selectedEventIds: nextIds,
+    lastSelected,
+    selectionAnchor: nextIds[0] ?? null,
+    selectionModeActive: nextIds.length > 0,
+    changed: true,
+    limitReached
+  };
+}
+function clearEventSelection() {
+  return {
+    selectedEventIds: [],
+    lastSelected: null,
+    selectionAnchor: null,
+    selectionModeActive: false
+  };
+}
+
+// src/interaction/resize.ts
+var RESIZE_HANDLE_SIZE = 8;
+function createResizeState(event, edge, startY) {
+  return {
+    event: { ...event },
+    originalEvent: { ...event },
+    edge,
+    startY,
+    currentY: startY,
+    startDelta: 0,
+    endDelta: 0,
+    isResizing: false
+  };
+}
+function updateResizeState(state, currentY, slotHeight, slotDuration, snapDuration = slotDuration) {
+  const dyPixels = currentY - state.startY;
+  const minutesDelta = dyPixels / slotHeight * slotDuration;
+  const snappedMinutes = snapToSlot(minutesDelta, snapDuration);
+  const deltaMs = snappedMinutes * 60 * 1e3;
+  let startDelta = 0;
+  let endDelta = 0;
+  if (state.edge === "top") {
+    startDelta = deltaMs;
+  } else {
+    endDelta = deltaMs;
+  }
+  return {
+    ...state,
+    currentY,
+    startDelta,
+    endDelta,
+    isResizing: Math.abs(dyPixels) > 2
+  };
+}
+function applyResizeToEvent(event, startDelta, endDelta) {
+  const start = typeof event.start === "string" ? new Date(event.start) : new Date(event.start);
+  const end = event.end ? typeof event.end === "string" ? new Date(event.end) : new Date(event.end) : new Date(start.getTime() + 30 * 60 * 1e3);
+  const newStart = new Date(start.getTime() + startDelta);
+  const newEnd = new Date(end.getTime() + endDelta);
+  if (newStart > newEnd) {
+    return event;
+  }
+  return {
+    ...event,
+    start: newStart,
+    end: newEnd
+  };
+}
+function getSchedulerTimedResizePreview(input) {
+  const minDuration = input.snapMinutes * 6e4;
+  const nextStartTime = input.edge === "top" ? Math.min(input.start.getTime() + input.deltaMinutes * 6e4, input.end.getTime() - minDuration) : input.start.getTime();
+  const nextEndTime = input.edge === "bottom" ? Math.max(input.end.getTime() + input.deltaMinutes * 6e4, input.start.getTime() + minDuration) : input.end.getTime();
+  const event = input.edge === "top" ? { ...input.event, start: new Date(nextStartTime) } : resizeEventBy(input.event, (nextEndTime - input.end.getTime()) / 6e4);
+  return {
+    edge: input.edge,
+    event,
+    startDelta: getEventStart(event).getTime() - input.start.getTime(),
+    endDelta: getEventEnd(event).getTime() - input.end.getTime()
+  };
+}
+function getSchedulerTimelineResizePreview(input) {
+  const minDuration = input.snapMinutes * 6e4;
+  const nextStartTime = input.edge === "start" ? Math.min(input.start.getTime() + input.deltaMs, input.end.getTime() - minDuration) : input.start.getTime();
+  const nextEndTime = input.edge === "end" ? Math.max(input.end.getTime() + input.deltaMs, input.start.getTime() + minDuration) : input.end.getTime();
+  const event = input.edge === "start" ? { ...input.event, start: new Date(nextStartTime) } : resizeEventBy(input.event, (nextEndTime - input.end.getTime()) / 6e4);
+  return {
+    edge: input.edge,
+    event,
+    startDelta: getEventStart(event).getTime() - input.start.getTime(),
+    endDelta: getEventEnd(event).getTime() - input.end.getTime()
+  };
+}
+function validateResize(event, startDelta, endDelta, constraints, allEvents, minDuration = 15) {
+  const newEvent = applyResizeToEvent(event, startDelta, endDelta);
+  const newStart = typeof newEvent.start === "string" ? new Date(newEvent.start) : newEvent.start;
+  const newEnd = newEvent.end ? typeof newEvent.end === "string" ? new Date(newEvent.end) : newEvent.end : newStart;
+  const durationMs = newEnd.getTime() - newStart.getTime();
+  const minDurationMs = minDuration * 60 * 1e3;
+  if (durationMs < minDurationMs) {
+    return { valid: false, reason: `Event must be at least ${minDuration} minutes` };
+  }
+  if (constraints.minDate && newStart < constraints.minDate) {
+    return { valid: false, reason: "Event would start before minimum date" };
+  }
+  if (constraints.maxDate && newEnd > constraints.maxDate) {
+    return { valid: false, reason: "Event would end after maximum date" };
+  }
+  if (constraints.allowOverlap === false) {
+    const overlapping = findOverlappingEvents(newEvent, allEvents);
+    if (overlapping.length > 0) {
+      return { valid: false, reason: "Event would overlap with another event" };
+    }
+  }
+  return { valid: true };
+}
+function isEventResizable(event, globalEditable = false, eventDurationEditable = true) {
+  if (event.resizable === false) return false;
+  if (event.editable === false) return false;
+  if (event.resizable === true) return true;
+  if (event.editable === true) return eventDurationEditable;
+  return globalEditable && eventDurationEditable;
+}
+function detectResizeEdge(mouseY, eventTop, eventHeight) {
+  const relativeY = mouseY - eventTop;
+  if (relativeY <= RESIZE_HANDLE_SIZE) {
+    return "top";
+  }
+  if (relativeY >= eventHeight - RESIZE_HANDLE_SIZE) {
+    return "bottom";
+  }
+  return null;
+}
+function getResizeCursor(edge) {
+  if (edge === "top" || edge === "bottom") {
+    return "ns-resize";
+  }
+  return "grab";
+}
+function calculateNewEventTimes(state, slotMinTime, slotMaxTime) {
+  const event = state.originalEvent;
+  const start = typeof event.start === "string" ? new Date(event.start) : new Date(event.start);
+  const end = event.end ? typeof event.end === "string" ? new Date(event.end) : new Date(event.end) : new Date(start.getTime() + 30 * 60 * 1e3);
+  const newStart = new Date(start.getTime() + state.startDelta);
+  const newEnd = new Date(end.getTime() + state.endDelta);
+  const [minHours, minMinutes] = slotMinTime.split(":").map(Number);
+  const [maxHours, maxMinutes] = slotMaxTime.split(":").map(Number);
+  const minTimeMinutes = minHours * 60 + (minMinutes || 0);
+  const maxTimeMinutes = maxHours * 60 + (maxMinutes || 0);
+  const newStartMinutes = newStart.getHours() * 60 + newStart.getMinutes();
+  const newEndMinutes = newEnd.getHours() * 60 + newEnd.getMinutes();
+  if (newStartMinutes < minTimeMinutes) {
+    newStart.setHours(minHours, minMinutes || 0, 0, 0);
+  }
+  if (newEndMinutes > maxTimeMinutes || maxTimeMinutes === 24 * 60 && newEndMinutes === 0) {
+    if (maxTimeMinutes === 24 * 60) {
+      newEnd.setHours(23, 59, 59, 999);
+    } else {
+      newEnd.setHours(maxHours, maxMinutes || 0, 0, 0);
+    }
+  }
+  if (newStart > newEnd) {
+    return null;
+  }
+  return { start: newStart, end: newEnd };
+}
+
+// src/interaction/keyboard.ts
+var KEY_TO_ACTION_MAP = {
+  ArrowLeft: "prev-day",
+  ArrowRight: "next-day",
+  ArrowUp: "prev-week",
+  ArrowDown: "next-week",
+  Home: "start-of-week",
+  End: "end-of-week",
+  PageUp: "prev-month",
+  PageDown: "next-month",
+  Enter: "select",
+  " ": "select",
+  Escape: "escape",
+  Tab: "tab"
+};
+var TIME_VIEW_KEY_OVERRIDES = {
+  ArrowUp: "prev-time-slot",
+  ArrowDown: "next-time-slot"
+};
+var YEAR_VIEW_KEY_OVERRIDES = {
+  PageUp: "prev-year",
+  PageDown: "next-year"
+};
+var AGENDA_VIEW_KEYS = /* @__PURE__ */ new Set(["Escape", "Tab"]);
+function getKeyboardAction(key, viewType) {
+  if (viewType === "agenda" && !AGENDA_VIEW_KEYS.has(key)) {
+    return null;
+  }
+  if (viewType === "week" || viewType === "day") {
+    const override = TIME_VIEW_KEY_OVERRIDES[key];
+    if (override) return override;
+  }
+  if (viewType === "year") {
+    const override = YEAR_VIEW_KEY_OVERRIDES[key];
+    if (override) return override;
+  }
+  return KEY_TO_ACTION_MAP[key] || null;
+}
+function getStartOfWeek(date, firstDayOfWeek = 0) {
+  const result = new Date(date);
+  const day = result.getDay();
+  const diff = (day - firstDayOfWeek + 7) % 7;
+  result.setDate(result.getDate() - diff);
+  result.setHours(0, 0, 0, 0);
+  return result;
+}
+function getEndOfWeek(date, firstDayOfWeek = 0) {
+  const start = getStartOfWeek(date, firstDayOfWeek);
+  return addDays(start, 6);
+}
+function addMinutesToDate(date, minutes) {
+  const result = new Date(date);
+  result.setMinutes(result.getMinutes() + minutes);
+  return result;
+}
+function calculateNewFocusedDate(action, options) {
+  const { currentDate, firstDayOfWeek = 0, slotDuration = 30 } = options;
+  switch (action) {
+    case "prev-day":
+      return addDays(currentDate, -1);
+    case "next-day":
+      return addDays(currentDate, 1);
+    case "prev-week":
+      return addDays(currentDate, -7);
+    case "next-week":
+      return addDays(currentDate, 7);
+    case "start-of-week":
+      return getStartOfWeek(currentDate, firstDayOfWeek);
+    case "end-of-week":
+      return getEndOfWeek(currentDate, firstDayOfWeek);
+    case "prev-month":
+      return addMonths(currentDate, -1);
+    case "next-month":
+      return addMonths(currentDate, 1);
+    case "prev-year":
+      return addYears(currentDate, -1);
+    case "next-year":
+      return addYears(currentDate, 1);
+    case "prev-time-slot":
+      return addMinutesToDate(currentDate, -slotDuration);
+    case "next-time-slot":
+      return addMinutesToDate(currentDate, slotDuration);
+    case "select":
+    case "escape":
+    case "tab":
+      return null;
+    default:
+      return null;
+  }
+}
+function handleKeyboardNavigation(input, viewType, currentFocusedDate, options) {
+  const action = getKeyboardAction(input.key, viewType);
+  if (!action) return null;
+  const effectiveCurrentDate = currentFocusedDate || /* @__PURE__ */ new Date();
+  const fullOptions = {
+    ...options,
+    currentDate: effectiveCurrentDate
+  };
+  const result = {
+    action,
+    newFocusedDate: null,
+    shouldPreventDefault: true,
+    shouldNavigate: null,
+    shouldSelect: false,
+    shouldClearFocus: false
+  };
+  switch (action) {
+    case "prev-month":
+      result.shouldNavigate = "prev";
+      result.newFocusedDate = calculateNewFocusedDate(action, fullOptions);
+      break;
+    case "next-month":
+      result.shouldNavigate = "next";
+      result.newFocusedDate = calculateNewFocusedDate(action, fullOptions);
+      break;
+    case "prev-year":
+      result.shouldNavigate = "prev";
+      result.newFocusedDate = calculateNewFocusedDate(action, fullOptions);
+      break;
+    case "next-year":
+      result.shouldNavigate = "next";
+      result.newFocusedDate = calculateNewFocusedDate(action, fullOptions);
+      break;
+    case "select":
+      if (currentFocusedDate) {
+        result.shouldSelect = true;
+        result.shouldClearFocus = true;
+      }
+      break;
+    case "escape":
+      result.shouldClearFocus = true;
+      break;
+    case "tab":
+      result.shouldPreventDefault = false;
+      break;
+    default:
+      result.newFocusedDate = calculateNewFocusedDate(action, fullOptions);
+      break;
+  }
+  return result;
+}
+function getPeriodNavigationDirection(input) {
+  if (input.key === "ArrowLeft" || input.key === "PageUp") {
+    return "prev";
+  }
+  if (input.key === "ArrowRight" || input.key === "PageDown") {
+    return "next";
+  }
+  return null;
+}
+
+// src/interaction/focus.ts
+function snapTimeToSlot(date, slotMinTime, slotDuration) {
+  const { hours: minHours, minutes: minMinutes } = parseTimeString(slotMinTime);
+  const minTimeInMinutes = minHours * 60 + minMinutes;
+  const timeInMinutes = date.getHours() * 60 + date.getMinutes();
+  const minutesFromMin = timeInMinutes - minTimeInMinutes;
+  const snappedMinutesFromMin = Math.floor(minutesFromMin / slotDuration) * slotDuration;
+  const snappedTotalMinutes = minTimeInMinutes + snappedMinutesFromMin;
+  const result = new Date(date);
+  result.setHours(Math.floor(snappedTotalMinutes / 60), snappedTotalMinutes % 60, 0, 0);
+  return result;
+}
+function clampTimeToSlotBounds(date, slotMinTime, slotMaxTime, slotDuration) {
+  const minTimeInMinutes = timeStringToMinutes(slotMinTime);
+  const maxTimeInMinutes = timeStringToMinutes(slotMaxTime);
+  const timeInMinutes = date.getHours() * 60 + date.getMinutes();
+  const result = new Date(date);
+  if (timeInMinutes < minTimeInMinutes) {
+    const { hours, minutes } = parseTimeString(slotMinTime);
+    result.setHours(hours, minutes, 0, 0);
+  } else if (timeInMinutes >= maxTimeInMinutes) {
+    const lastSlotMinutes = maxTimeInMinutes - slotDuration;
+    result.setHours(Math.floor(lastSlotMinutes / 60), lastSlotMinutes % 60, 0, 0);
+  }
+  return result;
+}
+function getDefaultFocusDateForMonth(grid) {
+  const today = /* @__PURE__ */ new Date();
+  for (const week of grid) {
+    for (const cell of week) {
+      if (cell.isCurrentMonth && cell.isToday) {
+        return cell.date;
+      }
+    }
+  }
+  for (const week of grid) {
+    for (const cell of week) {
+      if (cell.isCurrentMonth) {
+        return cell.date;
+      }
+    }
+  }
+  return today;
+}
+function getDefaultFocusDateForWeek(columns, slotMinTime, slotDuration) {
+  const now = /* @__PURE__ */ new Date();
+  const todayColumn = columns.find((col) => col.isToday);
+  if (todayColumn) {
+    const result = new Date(todayColumn.date);
+    result.setHours(now.getHours(), now.getMinutes(), 0, 0);
+    return clampTimeToSlotBounds(snapTimeToSlot(result, slotMinTime, slotDuration), slotMinTime, "24:00", slotDuration);
+  }
+  if (columns.length > 0) {
+    const { hours, minutes } = parseTimeString(slotMinTime);
+    const result = new Date(columns[0].date);
+    result.setHours(hours, minutes, 0, 0);
+    return result;
+  }
+  return now;
+}
+function getDefaultFocusDateForDay(date, isToday, slotMinTime, slotDuration) {
+  const now = /* @__PURE__ */ new Date();
+  if (isToday) {
+    const result2 = new Date(date);
+    result2.setHours(now.getHours(), now.getMinutes(), 0, 0);
+    return clampTimeToSlotBounds(snapTimeToSlot(result2, slotMinTime, slotDuration), slotMinTime, "24:00", slotDuration);
+  }
+  const { hours, minutes } = parseTimeString(slotMinTime);
+  const result = new Date(date);
+  result.setHours(hours, minutes, 0, 0);
+  return result;
+}
+function getDefaultFocusDateForYear(displayedYear) {
+  const today = /* @__PURE__ */ new Date();
+  if (today.getFullYear() === displayedYear) {
+    return today;
+  }
+  return new Date(displayedYear, 0, 1);
+}
+function getDefaultFocusDate(context) {
+  switch (context.viewType) {
+    case "month":
+      return getDefaultFocusDateForMonth(context.grid);
+    case "week":
+      return getDefaultFocusDateForWeek(context.columns, context.slotMinTime ?? "00:00", context.slotDuration ?? 30);
+    case "day":
+      return getDefaultFocusDateForDay(context.currentDate, context.isToday, context.slotMinTime ?? "00:00", context.slotDuration ?? 30);
+    case "year":
+      return getDefaultFocusDateForYear(context.displayedYear);
+    default:
+      return /* @__PURE__ */ new Date();
+  }
+}
+function isDateInMonthView(date, grid) {
+  for (const week of grid) {
+    for (const cell of week) {
+      if (isSameDay(cell.date, date)) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function isDateInWeekView(date, columns) {
+  return columns.some((col) => isSameDay(col.date, date));
+}
+function isDateInDayView(date, viewDate) {
+  return isSameDay(date, viewDate);
+}
+function isDateInYearView(date, displayedYear) {
+  return date.getFullYear() === displayedYear;
+}
+function getNavigationDirectionForMonth(targetDate, grid) {
+  let displayedMonth = -1;
+  let displayedYear = -1;
+  for (const week of grid) {
+    for (const cell of week) {
+      if (cell.isCurrentMonth) {
+        displayedMonth = cell.date.getMonth();
+        displayedYear = cell.date.getFullYear();
+        break;
+      }
+    }
+    if (displayedMonth >= 0) break;
+  }
+  if (displayedMonth < 0) {
+    const middleWeek = grid[Math.floor(grid.length / 2)];
+    const middleCell = middleWeek[Math.floor(middleWeek.length / 2)];
+    displayedMonth = middleCell.date.getMonth();
+    displayedYear = middleCell.date.getFullYear();
+  }
+  const targetMonth = targetDate.getMonth();
+  const targetYear = targetDate.getFullYear();
+  if (targetYear < displayedYear) return "prev";
+  if (targetYear > displayedYear) return "next";
+  if (targetMonth < displayedMonth) return "prev";
+  if (targetMonth > displayedMonth) return "next";
+  return null;
+}
+function getNavigationDirectionForWeek(targetDate, columns) {
+  if (columns.length === 0) return null;
+  const firstDay = columns[0].date;
+  const lastDay = columns[columns.length - 1].date;
+  if (targetDate < firstDay && !isSameDay(targetDate, firstDay)) return "prev";
+  if (targetDate > lastDay && !isSameDay(targetDate, lastDay)) return "next";
+  return null;
+}
+function getNavigationDirectionForDay(targetDate, viewDate) {
+  if (targetDate < viewDate && !isSameDay(targetDate, viewDate)) return "prev";
+  if (targetDate > viewDate && !isSameDay(targetDate, viewDate)) return "next";
+  return null;
+}
+function getNavigationDirectionForYear(targetDate, displayedYear) {
+  if (targetDate.getFullYear() < displayedYear) return "prev";
+  if (targetDate.getFullYear() > displayedYear) return "next";
+  return null;
+}
+function findCellForDate(date, grid) {
+  for (const week of grid) {
+    for (const cell of week) {
+      if (isSameDay(cell.date, date)) {
+        return cell;
+      }
+    }
+  }
+  return null;
+}
+function getDisplayedMonthFromGrid(grid) {
+  for (const week of grid) {
+    for (const cell of week) {
+      if (cell.isCurrentMonth) {
+        return { month: cell.date.getMonth(), year: cell.date.getFullYear() };
+      }
+    }
+  }
+  const middleWeek = grid[Math.floor(grid.length / 2)];
+  const middleCell = middleWeek[Math.floor(middleWeek.length / 2)];
+  return { month: middleCell.date.getMonth(), year: middleCell.date.getFullYear() };
+}
+function getStartOfWeekForFocus(date, firstDayOfWeek = 0) {
+  return startOfWeek(date, firstDayOfWeek);
+}
+function getEndOfWeekForFocus(date, firstDayOfWeek = 0) {
+  const start = startOfWeek(date, firstDayOfWeek);
+  return addDays(start, 6);
+}
+
+// src/interaction/popover.ts
+function formatEventTimeRange(event, locale = "en", options, timeZone, displayConfig) {
+  if (event.allDay) {
+    return "All day";
+  }
+  const startDate = event.start instanceof Date ? event.start : new Date(event.start);
+  const endDate = event.end ? event.end instanceof Date ? event.end : new Date(event.end) : null;
+  if (!endDate) {
+    return formatTime(startDate, locale, options, timeZone);
+  }
+  const isSameDay2 = startDate.getFullYear() === endDate.getFullYear() && startDate.getMonth() === endDate.getMonth() && startDate.getDate() === endDate.getDate();
+  if (isSameDay2) {
+    return formatTimeRange(startDate, endDate, locale, options, timeZone);
+  }
+  const includeYear = startDate.getFullYear() !== endDate.getFullYear();
+  const dateOptions = includeYear ? { month: "short", day: "numeric", year: "numeric" } : { month: "short", day: "numeric" };
+  const formatter = createSchedulerDateFormatter({ ...displayConfig, locale, timeZone });
+  const startDateTime = `${formatter.format(startDate, dateOptions)} ${formatTime(startDate, locale, options, timeZone)}`;
+  const endDateTime = `${formatter.format(endDate, dateOptions)} ${formatTime(endDate, locale, options, timeZone)}`;
+  return `${startDateTime} - ${endDateTime}`;
+}
+function formatEventDate(event, locale = "en", displayConfig) {
+  const startDate = event.start instanceof Date ? event.start : new Date(event.start);
+  const endDate = event.end ? event.end instanceof Date ? event.end : new Date(event.end) : null;
+  const formatter = createSchedulerDateFormatter({ ...displayConfig, locale });
+  const dateFormat = {
+    weekday: "long",
+    month: "long",
+    day: "numeric",
+    year: "numeric"
+  };
+  const startDateStr = formatter.format(startDate, dateFormat);
+  if (!endDate) {
+    return startDateStr;
+  }
+  const isSameDay2 = startDate.getFullYear() === endDate.getFullYear() && startDate.getMonth() === endDate.getMonth() && startDate.getDate() === endDate.getDate();
+  if (isSameDay2) {
+    return startDateStr;
+  }
+  const endDateStr = formatter.format(endDate, dateFormat);
+  return `${startDateStr} - ${endDateStr}`;
+}
+function formatEventDuration(event) {
+  if (event.allDay) {
+    const startDate2 = event.start instanceof Date ? event.start : new Date(event.start);
+    const endDate2 = event.end ? event.end instanceof Date ? event.end : new Date(event.end) : startDate2;
+    const startDay = new Date(startDate2.getFullYear(), startDate2.getMonth(), startDate2.getDate());
+    const endDay = new Date(endDate2.getFullYear(), endDate2.getMonth(), endDate2.getDate());
+    const days = Math.round((endDay.getTime() - startDay.getTime()) / (1e3 * 60 * 60 * 24)) + 1;
+    if (days === 1) {
+      return "1 day";
+    }
+    return `${days} days`;
+  }
+  const startDate = event.start instanceof Date ? event.start : new Date(event.start);
+  const endDate = event.end ? event.end instanceof Date ? event.end : new Date(event.end) : null;
+  if (!endDate) {
+    return "";
+  }
+  const durationMs = endDate.getTime() - startDate.getTime();
+  const durationMinutes = Math.round(durationMs / (1e3 * 60));
+  if (durationMinutes < 60) {
+    return `${durationMinutes} min`;
+  }
+  const hours = Math.floor(durationMinutes / 60);
+  const minutes = durationMinutes % 60;
+  if (minutes === 0) {
+    return hours === 1 ? "1 hour" : `${hours} hours`;
+  }
+  if (hours === 1) {
+    return `1 hour ${minutes} min`;
+  }
+  return `${hours} hours ${minutes} min`;
+}
+
+// src/interaction/timeline-virtual.ts
+var DEFAULT_OVERSCAN = 2;
+var VIRTUAL_THRESHOLD = 100;
+function shouldUseVirtualScrolling(totalCells, threshold = VIRTUAL_THRESHOLD) {
+  return totalCells > threshold;
+}
+function createVirtualScrollState(scrollLeft, containerWidth, totalWidth, overscan = DEFAULT_OVERSCAN) {
+  return {
+    scrollLeft,
+    containerWidth,
+    totalWidth,
+    overscan
+  };
+}
+function calculateVirtualRange(state, cells) {
+  if (cells.length === 0) {
+    return {
+      startIndex: 0,
+      endIndex: 0,
+      startOffset: 0,
+      visibleCells: []
+    };
+  }
+  const { scrollLeft, containerWidth, overscan } = state;
+  const viewportEnd = scrollLeft + containerWidth;
+  let startIndex = 0;
+  let endIndex = cells.length - 1;
+  let accumulated = 0;
+  for (let i = 0; i < cells.length; i++) {
+    const cellEnd = accumulated + cells[i].width;
+    if (cellEnd > scrollLeft) {
+      startIndex = Math.max(0, i - overscan);
+      break;
+    }
+    accumulated = cellEnd;
+  }
+  accumulated = 0;
+  for (let i = 0; i < cells.length; i++) {
+    accumulated += cells[i].width;
+    if (accumulated >= viewportEnd) {
+      endIndex = Math.min(cells.length - 1, i + overscan);
+      break;
+    }
+  }
+  let startOffset = 0;
+  for (let i = 0; i < startIndex; i++) {
+    startOffset += cells[i].width;
+  }
+  const visibleCells = cells.slice(startIndex, endIndex + 1);
+  return {
+    startIndex,
+    endIndex,
+    startOffset,
+    visibleCells
+  };
+}
+function calculateVisibleEvents(events, scrollLeft, containerWidth, bufferWidth = 100) {
+  const viewportStart = scrollLeft - bufferWidth;
+  const viewportEnd = scrollLeft + containerWidth + bufferWidth;
+  const visibleEvents = [];
+  const leftBuffer = [];
+  const rightBuffer = [];
+  for (const event of events) {
+    const eventStart = event.left;
+    const eventEnd = event.left + event.width;
+    if (eventEnd < viewportStart - bufferWidth) {
+      leftBuffer.push(event);
+    } else if (eventStart > viewportEnd + bufferWidth) {
+      rightBuffer.push(event);
+    } else if (eventEnd >= viewportStart && eventStart <= viewportEnd) {
+      visibleEvents.push(event);
+    }
+  }
+  return {
+    visibleEvents,
+    leftBuffer,
+    rightBuffer
+  };
+}
+function updateVirtualScrollState(state, scrollLeft) {
+  return {
+    ...state,
+    scrollLeft
+  };
+}
+function getScrollPositionForDate(targetDate, viewStart, totalWidth, totalDuration, containerWidth, centerInView = true) {
+  const targetMs = targetDate.getTime() - viewStart.getTime();
+  let scrollPosition = targetMs / totalDuration * totalWidth;
+  if (centerInView) {
+    scrollPosition -= containerWidth / 2;
+  }
+  return Math.max(0, Math.min(scrollPosition, totalWidth - containerWidth));
+}
+function getScrollPositionForNow(viewStart, viewEnd, totalWidth, containerWidth) {
+  const now = /* @__PURE__ */ new Date();
+  if (now < viewStart || now > viewEnd) {
+    return null;
+  }
+  const totalDuration = viewEnd.getTime() - viewStart.getTime();
+  return getScrollPositionForDate(now, viewStart, totalWidth, totalDuration, containerWidth, true);
+}
+function isDateInVisibleRange(date, viewStart, scrollLeft, containerWidth, totalWidth, totalDuration) {
+  const dateOffset = (date.getTime() - viewStart.getTime()) / totalDuration * totalWidth;
+  return dateOffset >= scrollLeft && dateOffset <= scrollLeft + containerWidth;
+}
+function createChunkedCells(cells, chunkSize = 20) {
+  const chunks = [];
+  let currentChunk = [];
+  let chunkWidth = 0;
+  for (const cell of cells) {
+    currentChunk.push(cell);
+    if (currentChunk.length >= chunkSize) {
+      chunks.push(currentChunk);
+      currentChunk = [];
+    }
+  }
+  if (currentChunk.length > 0) {
+    chunks.push(currentChunk);
+  }
+  if (chunks.length > 0 && chunks[0].length > 0) {
+    chunkWidth = chunks[0].reduce((sum, cell) => sum + cell.width, 0);
+  }
+  return {
+    chunks,
+    chunkWidth,
+    totalChunks: chunks.length
+  };
+}
+function getVisibleChunks(chunkedCells, scrollLeft, containerWidth, overscan = 1) {
+  const { chunks, chunkWidth } = chunkedCells;
+  if (chunks.length === 0) {
+    return { startChunk: 0, endChunk: 0, visibleCells: [] };
+  }
+  const startChunk = Math.max(0, Math.floor(scrollLeft / chunkWidth) - overscan);
+  const endChunk = Math.min(chunks.length - 1, Math.ceil((scrollLeft + containerWidth) / chunkWidth) + overscan);
+  const visibleCells = [];
+  for (let i = startChunk; i <= endChunk; i++) {
+    visibleCells.push(...chunks[i]);
+  }
+  return { startChunk, endChunk, visibleCells };
+}
+function calculateTotalWidth(cells) {
+  return cells.reduce((sum, cell) => sum + cell.width, 0);
+}
+function getEstimatedScrollPosition(targetIndex, averageCellWidth) {
+  return targetIndex * averageCellWidth;
+}
+function getCellAtPosition(scrollLeft, cells) {
+  let accumulated = 0;
+  for (let i = 0; i < cells.length; i++) {
+    accumulated += cells[i].width;
+    if (accumulated > scrollLeft) {
+      return { cell: cells[i], index: i };
+    }
+  }
+  return cells.length > 0 ? { cell: cells[cells.length - 1], index: cells.length - 1 } : null;
+}
+
+// src/interaction/quick-info.ts
+var DEFAULT_OPTIONS2 = {
+  enabled: false,
+  trigger: "click",
+  editorTrigger: "button",
+  showDelete: true,
+  showEdit: true,
+  autoClose: 0
+};
+function normalizeQuickInfoOptions(options) {
+  if (!options) {
+    return { ...DEFAULT_OPTIONS2, enabled: false };
+  }
+  if (options === true) {
+    return { ...DEFAULT_OPTIONS2, enabled: true };
+  }
+  return {
+    enabled: true,
+    trigger: options.trigger ?? DEFAULT_OPTIONS2.trigger,
+    editorTrigger: options.editorTrigger ?? DEFAULT_OPTIONS2.editorTrigger,
+    showDelete: options.showDelete ?? DEFAULT_OPTIONS2.showDelete,
+    showEdit: options.showEdit ?? DEFAULT_OPTIONS2.showEdit,
+    autoClose: options.autoClose ?? DEFAULT_OPTIONS2.autoClose
+  };
+}
+
+// src/interaction/inline-edit.ts
+var DEFAULT_OPTIONS3 = {
+  enabled: false,
+  trigger: "click",
+  fields: ["title"],
+  saveOnBlur: true,
+  saveOnEnter: true,
+  cancelOnEscape: true
+};
+function resolveInlineEditTrigger(trigger) {
+  return trigger === "dblclick" ? "dblclick" : "click";
+}
+function normalizeInlineEditOptions(options) {
+  if (!options) {
+    return { ...DEFAULT_OPTIONS3, enabled: false };
+  }
+  if (options === true) {
+    return { ...DEFAULT_OPTIONS3, enabled: true };
+  }
+  return {
+    enabled: true,
+    trigger: resolveInlineEditTrigger(options.trigger),
+    fields: options.fields ?? DEFAULT_OPTIONS3.fields,
+    saveOnBlur: options.saveOnBlur ?? DEFAULT_OPTIONS3.saveOnBlur,
+    saveOnEnter: options.saveOnEnter ?? DEFAULT_OPTIONS3.saveOnEnter,
+    cancelOnEscape: options.cancelOnEscape ?? DEFAULT_OPTIONS3.cancelOnEscape
+  };
+}
+
+// src/interaction/inline-edit-time.ts
+function toValidDate(value) {
+  if (!value) return null;
+  const date = value instanceof Date ? new Date(value) : new Date(value);
+  if (Number.isNaN(date.getTime())) {
+    return null;
+  }
+  return date;
+}
+function formatTimeToken(date) {
+  const hours = String(date.getHours()).padStart(2, "0");
+  const minutes = String(date.getMinutes()).padStart(2, "0");
+  return `${hours}:${minutes}`;
+}
+function parseInlineTimeToken(input) {
+  const normalized = input.trim().toLowerCase().replace(/\./g, "");
+  if (!normalized) return null;
+  const meridiemMatch = normalized.match(/(am?|pm?)$/i);
+  const meridiem = meridiemMatch ? meridiemMatch[1].toLowerCase() : null;
+  const baseTime = meridiem ? normalized.slice(0, -meridiem.length).trim() : normalized;
+  let hours;
+  let minutes;
+  if (baseTime.includes(":")) {
+    const [rawHours, rawMinutes = "0"] = baseTime.split(":");
+    hours = Number.parseInt(rawHours, 10);
+    minutes = Number.parseInt(rawMinutes, 10);
+  } else if (/^\d{3,4}$/.test(baseTime)) {
+    const cut = baseTime.length - 2;
+    hours = Number.parseInt(baseTime.slice(0, cut), 10);
+    minutes = Number.parseInt(baseTime.slice(cut), 10);
+  } else if (/^\d{1,2}$/.test(baseTime)) {
+    hours = Number.parseInt(baseTime, 10);
+    minutes = 0;
+  } else {
+    return null;
+  }
+  if (!Number.isFinite(hours) || !Number.isFinite(minutes) || minutes < 0 || minutes > 59) {
+    return null;
+  }
+  if (meridiem) {
+    if (hours < 1 || hours > 12) {
+      return null;
+    }
+    if (meridiem.startsWith("p") && hours < 12) {
+      hours += 12;
+    } else if (meridiem.startsWith("a") && hours === 12) {
+      hours = 0;
+    }
+  } else if (hours < 0 || hours > 23) {
+    return null;
+  }
+  return { hours, minutes };
+}
+function getInlineEditTimeValue(event) {
+  if (event.allDay) {
+    return "";
+  }
+  const startDate = toValidDate(event.start);
+  if (!startDate) {
+    return "";
+  }
+  const endDate = toValidDate(event.end);
+  if (!endDate) {
+    return formatTimeToken(startDate);
+  }
+  return `${formatTimeToken(startDate)} - ${formatTimeToken(endDate)}`;
+}
+function parseInlineEditTimeValue(input, event) {
+  if (event.allDay) {
+    return null;
+  }
+  const startReference = toValidDate(event.start);
+  if (!startReference) {
+    return null;
+  }
+  const endReference = toValidDate(event.end);
+  const trimmed = input.trim();
+  if (!trimmed) {
+    return null;
+  }
+  const rangeMatch = trimmed.match(/^(.+?)\s*(?:-|–|—|to)\s*(.+)$/i);
+  const startToken = rangeMatch ? rangeMatch[1] : trimmed;
+  const endToken = rangeMatch ? rangeMatch[2] : null;
+  const parsedStart = parseInlineTimeToken(startToken);
+  if (!parsedStart) {
+    return null;
+  }
+  const nextStart = new Date(startReference);
+  nextStart.setHours(parsedStart.hours, parsedStart.minutes, 0, 0);
+  let nextEnd;
+  if (endToken) {
+    const parsedEnd = parseInlineTimeToken(endToken);
+    if (!parsedEnd) {
+      return null;
+    }
+    const endBase = endReference ?? startReference;
+    nextEnd = new Date(endBase);
+    nextEnd.setHours(parsedEnd.hours, parsedEnd.minutes, 0, 0);
+    if (nextEnd.getTime() <= nextStart.getTime()) {
+      nextEnd = addDays(nextEnd, 1);
+    }
+  } else if (endReference) {
+    const duration = endReference.getTime() - startReference.getTime();
+    if (duration > 0) {
+      nextEnd = new Date(nextStart.getTime() + duration);
+    }
+  }
+  return {
+    start: nextStart,
+    end: nextEnd,
+    normalizedValue: nextEnd ? `${formatTimeToken(nextStart)} - ${formatTimeToken(nextEnd)}` : formatTimeToken(nextStart)
+  };
+}
+function hasInlineTimeChanged(event, start, end) {
+  const previousStart = toValidDate(event.start);
+  const previousEnd = toValidDate(event.end);
+  if (!previousStart) {
+    return true;
+  }
+  const previousEndTime = previousEnd ? previousEnd.getTime() : null;
+  const nextEndTime = end ? end.getTime() : null;
+  return previousStart.getTime() !== start.getTime() || previousEndTime !== nextEndTime;
+}
+
+// src/interaction/touch.ts
+function getPointerCoords(input) {
+  return { clientX: input.clientX, clientY: input.clientY };
+}
+
+// src/interaction/resource-conflict.ts
+function getEventResourceIds(event) {
+  if (event.resourceIds && event.resourceIds.length > 0) {
+    return event.resourceIds;
+  }
+  if (event.resourceId !== void 0) {
+    return [event.resourceId];
+  }
+  return [];
+}
+function dedupeConflicts(conflicts) {
+  const seen = /* @__PURE__ */ new Set();
+  const output = [];
+  for (const conflict of conflicts) {
+    const key = `${conflict.type}:${String(conflict.resourceId)}:${conflict.message}`;
+    if (seen.has(key)) {
+      continue;
+    }
+    seen.add(key);
+    output.push(conflict);
+  }
+  return output;
+}
+function projectEventsWithCandidate(events, event) {
+  const index = events.findIndex((item) => item.id === event.id);
+  if (index === -1) {
+    return [...events, event];
+  }
+  const projected = [...events];
+  projected[index] = event;
+  return projected;
+}
+function updateConflictedEventIds(conflictedEventIds, eventId, hasConflict) {
+  const hasExisting = conflictedEventIds.includes(eventId);
+  if (hasConflict && !hasExisting) {
+    return [...conflictedEventIds, eventId];
+  }
+  if (!hasConflict && hasExisting) {
+    return conflictedEventIds.filter((id) => id !== eventId);
+  }
+  return conflictedEventIds;
+}
+function evaluateResourceConflictDecision(input) {
+  if (!input.options.enabled) {
+    return { canProceed: true, conflicts: [] };
+  }
+  const resourceIds = input.targetResourceId !== void 0 ? [input.targetResourceId] : getEventResourceIds(input.event);
+  if (resourceIds.length === 0) {
+    return { canProceed: true, conflicts: [] };
+  }
+  let canProceed = true;
+  const conflicts = [];
+  for (const resourceId of resourceIds) {
+    const resource = findResourceById(input.resources, resourceId);
+    if (!resource) {
+      continue;
+    }
+    const result = canDropEventWithResourceConstraints(input.event, resource, input.events, input.options);
+    if (!result.canDrop) {
+      canProceed = false;
+    }
+    conflicts.push(...result.conflicts);
+  }
+  return {
+    canProceed,
+    conflicts: dedupeConflicts(conflicts)
+  };
+}
+function resolveCapacityExceededPayloads(event, conflicts, resources, events, currentDate) {
+  const projectedEvents = projectEventsWithCandidate(events, event);
+  const resourceIds = new Set(conflicts.filter((conflict) => conflict.type === "capacity").map((conflict) => conflict.resourceId));
+  const payloads = [];
+  for (const resourceId of resourceIds) {
+    const resource = findResourceById(resources, resourceId);
+    if (!resource) {
+      continue;
+    }
+    const capacity = getResourceCapacity(resource, currentDate, projectedEvents);
+    if (capacity.max === Infinity) {
+      continue;
+    }
+    payloads.push({
+      resourceId: resource.id,
+      current: capacity.current,
+      max: capacity.max
+    });
+  }
+  return payloads;
+}
+function resolveResourceConflictRuntime(input) {
+  if (!input.options.enabled) {
+    return {
+      conflictedEventIds: updateConflictedEventIds(input.conflictedEventIds, input.event.id, false),
+      capacityExceededPayloads: []
+    };
+  }
+  const hasConflict = input.decision.conflicts.length > 0;
+  const conflictedEventIds = updateConflictedEventIds(input.conflictedEventIds, input.event.id, hasConflict);
+  if (!hasConflict) {
+    return {
+      conflictedEventIds,
+      capacityExceededPayloads: []
+    };
+  }
+  return {
+    conflictedEventIds,
+    conflictDetectedPayload: {
+      conflicts: input.decision.conflicts,
+      event: input.event,
+      canProceed: input.decision.canProceed
+    },
+    capacityExceededPayloads: resolveCapacityExceededPayloads(input.event, input.decision.conflicts, input.resources, input.events, input.currentDate)
+  };
+}
+
+// src/interaction/conflict.controller.ts
+function processConflictDecision(input) {
+  const decision = evaluateResourceConflictDecision({
+    event: input.event,
+    options: input.options,
+    resources: input.resources,
+    events: input.events,
+    targetResourceId: input.targetResourceId
+  });
+  const runtime = resolveResourceConflictRuntime({
+    event: input.event,
+    options: input.options,
+    resources: input.resources,
+    events: input.events,
+    currentDate: input.currentDate,
+    conflictedEventIds: input.conflictedEventIds,
+    decision
+  });
+  return {
+    decision,
+    conflictedEventIds: runtime.conflictedEventIds,
+    emits: {
+      conflictDetected: runtime.conflictDetectedPayload,
+      capacityExceeded: runtime.capacityExceededPayloads
+    }
+  };
+}
+function evaluateDropConflict(input) {
+  if (!input.options.enabled) {
+    return true;
+  }
+  const projectedEvent = {
+    ...input.event,
+    start: input.dropStart,
+    end: input.dropEnd
+  };
+  const decision = evaluateResourceConflictDecision({
+    event: projectedEvent,
+    options: input.options,
+    resources: input.resources,
+    events: input.events,
+    targetResourceId: input.dropResourceId
+  });
+  return decision.canProceed;
+}
+function buildResourceCapacityMap(input) {
+  if (!input.options.enabled || !input.options.checkCapacity) {
+    return {};
+  }
+  const output = {};
+  for (const resource of input.flatResources) {
+    if (resource.constraints?.capacity === void 0 && resource.constraints?.maxEventsPerDay === void 0) {
+      continue;
+    }
+    output[String(resource.id)] = getResourceCapacity(resource, input.currentDate, input.events);
+  }
+  return output;
+}
+
+// src/interaction/scheduler-actions.controller.ts
+function resolveGlobalKeyAction(ctx) {
+  if (ctx.key === "Escape") {
+    if (ctx.morePopoverVisible) return { type: "dismiss-more-popover" };
+    if (ctx.popoverVisible) return { type: "dismiss-popover" };
+    if (ctx.quickInfoVisible) return { type: "dismiss-quickinfo" };
+  }
+  if (!ctx.isInsideRoot) return { type: "none" };
+  if (ctx.focusedEventId && (ctx.key === "Enter" || ctx.key === " ")) {
+    return { type: "activate-event", eventId: ctx.focusedEventId };
+  }
+  if (ctx.focusedEventId && ctx.key === "Escape") {
+    return { type: "escape-event-focus" };
+  }
+  if (ctx.isEditableElement) return { type: "none" };
+  if ((ctx.key === "Delete" || ctx.key === "Backspace") && ctx.selectedEventCount > 0) {
+    return { type: "delete-events" };
+  }
+  if (ctx.altKey && ctx.key >= "1" && ctx.key <= "9") {
+    const index = parseInt(ctx.key) - 1;
+    if (index < ctx.availableViewCount) {
+      return { type: "switch-view", viewIndex: index };
+    }
+    return { type: "none" };
+  }
+  const hasModifier = ctx.ctrlKey || ctx.metaKey;
+  if (hasModifier && ctx.key === "ArrowLeft") return { type: "navigate", direction: "prev" };
+  if (hasModifier && ctx.key === "ArrowRight") return { type: "navigate", direction: "next" };
+  if (hasModifier && ctx.key.toLowerCase() === "t") return { type: "go-today" };
+  if (!ctx.eventSelectionEnabled) return { type: "none" };
+  if (hasModifier && ctx.key.toLowerCase() === "a") return { type: "select-all" };
+  if (ctx.key === "Escape" && ctx.selectedEventCount > 0) {
+    return { type: "clear-event-selection" };
+  }
+  return { type: "none" };
+}
+function resolveOutsideClickAction(ctx) {
+  if (!ctx.isOutside || ctx.isDragging) {
+    return { clearFocus: false, clearDateSelection: false, clearEventSelection: false };
+  }
+  return {
+    clearFocus: ctx.hasFocus,
+    clearDateSelection: ctx.unselectOnOutsideClick && ctx.hasDateSelection,
+    clearEventSelection: ctx.unselectOnOutsideClick && ctx.eventSelectionEnabled && ctx.hasEventSelection
+  };
+}
+
+// src/interaction/multi-drag.ts
+function getTimeOfDayMs(date) {
+  return (date.getHours() * 3600 + date.getMinutes() * 60 + date.getSeconds()) * 1e3;
+}
+function getDayOffset(anchor, target) {
+  const a = new Date(anchor);
+  a.setHours(0, 0, 0, 0);
+  const b = new Date(target);
+  b.setHours(0, 0, 0, 0);
+  return Math.round((b.getTime() - a.getTime()) / 864e5);
+}
+function getSelectedEventsForMultiDrag(selectedIds, events) {
+  const idSet = new Set(selectedIds);
+  return events.filter((e) => idSet.has(e.id));
+}
+function isMultiDragCandidate(selectedIds, anchorId) {
+  return selectedIds.length > 1 && selectedIds.includes(anchorId);
+}
+function computeTimedMultiDragOffsets(anchorStart, selectedEvents) {
+  const anchorMs = anchorStart.getTime();
+  const offsets = /* @__PURE__ */ new Map();
+  for (const event of selectedEvents) {
+    const start = new Date(event.start);
+    offsets.set(event.id, start.getTime() - anchorMs);
+  }
+  return offsets;
+}
+function computeColumnTimedMultiDragOffsets(anchorStart, anchorColIndex, selectedEvents, getColumnIndex) {
+  const anchorTimeMs = getTimeOfDayMs(anchorStart);
+  const offsets = /* @__PURE__ */ new Map();
+  for (const event of selectedEvents) {
+    const start = new Date(event.start);
+    const colIndex = getColumnIndex(start);
+    offsets.set(event.id, {
+      colIndexOffset: colIndex - anchorColIndex,
+      milliseconds: getTimeOfDayMs(start) - anchorTimeMs
+    });
+  }
+  return offsets;
+}
+function computeDayMultiDragOffsets(anchorStart, selectedEvents) {
+  const offsets = /* @__PURE__ */ new Map();
+  for (const event of selectedEvents) {
+    const start = new Date(event.start);
+    offsets.set(event.id, getDayOffset(anchorStart, start));
+  }
+  return offsets;
+}
+
+// src/interaction/permissions.ts
+function isPermissionAllowed(resolver, ctx) {
+  if (!resolver) return true;
+  return resolver(ctx);
+}
+function filterEventsByPermission(events, action, resolver, view) {
+  if (!resolver) return events;
+  return events.filter((event) => resolver({ action, event, view }));
+}
+function isEventDraggableWithPermission(event, globalEditable, eventStartEditable, resolver, view) {
+  if (!isEventDraggable(event, globalEditable, eventStartEditable)) return false;
+  return isPermissionAllowed(resolver, { action: "drag", event, view });
+}
+function isEventResizableWithPermission(event, globalEditable, eventDurationEditable, resolver, view) {
+  if (!isEventResizable(event, globalEditable, eventDurationEditable)) return false;
+  return isPermissionAllowed(resolver, { action: "resize", event, view });
+}
+
+export { DEFAULT_DRAG_MIN_DISTANCE, DEFAULT_OVERSCAN, DEFAULT_SNAP_DURATION, RESIZE_HANDLE_SIZE, RESOURCE_VIEWS, VIRTUAL_THRESHOLD, applyDeltaToEvent, applyEventSelection, applyResizeToEvent, buildResourceCapacityMap, calculateDayDelta, calculateDragDelta, calculateNewEventTimes, calculateNewFocusedDate, calculateTimeDelta, calculateTotalWidth, calculateVirtualRange, calculateVisibleEvents, clampTime, clampTimeToSlotBounds, clearEventSelection, computeColumnTimedMultiDragOffsets, computeDayMultiDragOffsets, computeTimedMultiDragOffsets, createChunkedCells, createDragAutoScroller, createDragState, createResizeState, createSchedulerEventDropCandidate, createVirtualScrollState, dedupeConflicts, detectResizeEdge, evaluateDropConflict, evaluateResourceConflictDecision, eventBelongsToResource, filterEventsByPermission, filterVisibleIdsByResource, findCellForDate, findOverlappingEvents, formatEventDate, formatEventDuration, formatEventTimeRange, formatTimeToken, getCellAtPosition, getDayIndexFromX, getDayOffset, getDefaultFocusDate, getDefaultFocusDateForDay, getDefaultFocusDateForMonth, getDefaultFocusDateForWeek, getDefaultFocusDateForYear, getDisplayedMonthFromGrid, getEndOfWeek, getEndOfWeekForFocus, getEstimatedScrollPosition, getInlineEditTimeValue, getKeyboardAction, getNavigationDirectionForDay, getNavigationDirectionForMonth, getNavigationDirectionForWeek, getNavigationDirectionForYear, getPeriodNavigationDirection, getPointerCoords, getResizeCursor, getSchedulerEventDropDelta, getSchedulerTimedInteractionDeltaMs, getSchedulerTimedResizePreview, getSchedulerTimelineResizePreview, getScrollPositionForDate, getScrollPositionForNow, getSelectedEventsForMultiDrag, getStartOfWeek, getStartOfWeekForFocus, getTimeFromYPosition, getTimeOfDayMs, getVisibleChunks, getYPositionFromTime, handleKeyboardNavigation, hasInlineTimeChanged, invertSelection, isDateInDayView, isDateInMonthView, isDateInVisibleRange, isDateInWeekView, isDateInYearView, isEventDraggable, isEventDraggableWithPermission, isEventResizable, isEventResizableWithPermission, isMultiDragCandidate, isPermissionAllowed, isResourceView, normalizeEventSelectionOptions, normalizeInlineEditOptions, normalizeQuickInfoOptions, parseInlineEditTimeValue, parseInlineTimeToken, processConflictDecision, projectEventsWithCandidate, resolveAutoScrollDelta, resolveCapacityExceededPayloads, resolveGlobalKeyAction, resolveOutsideClickAction, resolveResourceConflictRuntime, selectAllVisibleEvents, shouldUseVirtualScrolling, snapTime, snapTimeToSlot, snapToSlot, toValidDate, updateConflictedEventIds, updateDragState, updateResizeState, updateVirtualScrollState, validateDragPosition, validateResize };