@primeui/scheduler-core 0.0.1-alpha.1

package/dist/chunk-5N4ZOBJV.mjs

@@ -0,0 +1,866 @@
+import { DEFAULT_DRAG_MIN_DISTANCE, applyDeltaToEvent, findOverlappingEvents, applyResizeToEvent, detectResizeEdge, createResizeState, createDragState, snapToSlot, getYPositionFromTime, getSchedulerTimelineResizePreview } from './chunk-2THQAZ26.mjs';
+import { hasOverlapInAnyAssignedResource, getEventResourceIds } from './chunk-SYJ5O4KH.mjs';
+import { updateSlotsAvailability, getSlotsForTimeRange } from './chunk-NZGJN7HG.mjs';
+import { canDropEvent } from './chunk-HPC5B3AR.mjs';
+import { getSchedulerEventSurfaceStyle } from './chunk-5KORIWDT.mjs';
+import { addDays, isSameDay } from './chunk-WFUJWDST.mjs';
+import { differenceInCalendarDays, addCalendarDaysToDate, moveDateToCalendarDay } from './chunk-DYW6WUHE.mjs';
+import { flattenResourceTree } from './chunk-QR2SVYAD.mjs';
+
+// src/controllers/month.controller.ts
+var RESIZE_EDGE_SIZE = 12;
+function detectResizeEdgeForAllDay(relativeX, elementWidth, threshold = RESIZE_EDGE_SIZE) {
+  if (relativeX <= threshold) return "start";
+  if (relativeX >= elementWidth - threshold) return "end";
+  return null;
+}
+function calculateDragClickOffset(eventStart, clickedDate, calendarOptions) {
+  return differenceInCalendarDays(eventStart, clickedDate, calendarOptions);
+}
+function processMonthDragMove(state, targetDate, dragClickDayOffset, mouseX, mouseY, calendarOptions) {
+  const result = {
+    dragGhostPosition: {
+      x: mouseX - state.offsetX,
+      y: mouseY - state.offsetY
+    },
+    dropTargetDate: targetDate,
+    delta: state.delta,
+    previewEvent: null,
+    shouldEmitDragStart: !state.isDragging && state.hasMovedMinDistance,
+    shouldEmitDrag: false
+  };
+  if (targetDate) {
+    const originalEvent = state.originalEvent;
+    const originalStart = typeof originalEvent.start === "string" ? new Date(originalEvent.start) : originalEvent.start;
+    const targetStartDate = addCalendarDaysToDate(targetDate, -dragClickDayOffset, calendarOptions);
+    const daysDelta = differenceInCalendarDays(originalStart, targetStartDate, calendarOptions);
+    result.delta = { days: daysDelta, milliseconds: 0 };
+    result.previewEvent = applyDeltaToEvent(originalEvent, result.delta, calendarOptions);
+    result.shouldEmitDrag = true;
+  }
+  return result;
+}
+function finalizeMonthDrag(state, context, calendarOptions) {
+  const { originalEvent, delta, isDragging } = state;
+  if (!isDragging || delta.days === 0) {
+    return {
+      success: false,
+      newEvent: null,
+      delta,
+      wasBlocked: false
+    };
+  }
+  const newEvent = applyDeltaToEvent(originalEvent, delta, calendarOptions);
+  if (!context.eventOverlap) {
+    const overlapping = findOverlappingEvents(newEvent, context.parsedEvents);
+    if (overlapping.length > 0) {
+      return {
+        success: false,
+        newEvent: null,
+        delta,
+        wasBlocked: true
+      };
+    }
+  }
+  return {
+    success: true,
+    newEvent,
+    delta,
+    wasBlocked: false
+  };
+}
+function calculateResizeDeltas(originalEvent, targetDate, resizeEdge, calendarOptions) {
+  const originalStart = typeof originalEvent.start === "string" ? new Date(originalEvent.start) : originalEvent.start;
+  const originalEnd = originalEvent.end ? typeof originalEvent.end === "string" ? new Date(originalEvent.end) : originalEvent.end : new Date(originalStart);
+  let startDelta = 0;
+  let endDelta = 0;
+  if (resizeEdge === "start") {
+    const newStart = moveDateToCalendarDay(originalStart, targetDate, calendarOptions);
+    startDelta = newStart.getTime() - originalStart.getTime();
+    if (newStart > originalEnd) {
+      startDelta = originalEnd.getTime() - originalStart.getTime();
+    }
+  } else {
+    const newEnd = moveDateToCalendarDay(originalEnd, targetDate, calendarOptions);
+    endDelta = newEnd.getTime() - originalEnd.getTime();
+    if (newEnd < originalStart) {
+      endDelta = originalStart.getTime() - originalEnd.getTime();
+    }
+  }
+  return { startDelta, endDelta };
+}
+function calculateResizePreviewPosition(previewEvent, grid, originalRow) {
+  const previewStart = typeof previewEvent.start === "string" ? new Date(previewEvent.start) : previewEvent.start;
+  const previewEnd = previewEvent.end ? typeof previewEvent.end === "string" ? new Date(previewEvent.end) : previewEvent.end : previewStart;
+  const results = [];
+  for (let weekIndex = 0; weekIndex < grid.length; weekIndex++) {
+    const week = grid[weekIndex];
+    const weekStart = week[0].date;
+    const weekEnd = addDays(weekStart, 6);
+    weekEnd.setHours(23, 59, 59, 999);
+    if (previewStart <= weekEnd && previewEnd >= weekStart) {
+      let startCol = -1;
+      let endCol = 6;
+      for (let col = 0; col < 7; col++) {
+        const cellDate = week[col].date;
+        if (startCol === -1 && (isSameDay(cellDate, previewStart) || cellDate > previewStart)) {
+          startCol = col;
+        }
+        if (isSameDay(cellDate, previewEnd) || cellDate >= previewEnd) {
+          endCol = col;
+          break;
+        }
+      }
+      if (previewStart < weekStart) startCol = 0;
+      if (startCol === -1) startCol = 0;
+      if (previewEnd > weekEnd) endCol = 6;
+      results.push({
+        weekIndex,
+        startCol,
+        endCol,
+        row: originalRow,
+        event: previewEvent
+      });
+    }
+  }
+  return results;
+}
+function processMonthResizeMove(state, targetDate, grid, calendarOptions) {
+  const { startDelta, endDelta } = calculateResizeDeltas(state.originalEvent, targetDate, state.resizeEdge, calendarOptions);
+  const previewEvent = applyResizeToEvent(state.originalEvent, startDelta, endDelta);
+  const previewData = calculateResizePreviewPosition(previewEvent, grid, state.originalRow ?? 0);
+  return {
+    resizeTargetDate: targetDate,
+    startDelta,
+    endDelta,
+    previewEvent,
+    previewData
+  };
+}
+function finalizeMonthResize(state, context) {
+  const { originalEvent, startDelta, endDelta, isResizing } = state;
+  if (!isResizing || startDelta === 0 && endDelta === 0) {
+    return {
+      success: false,
+      newEvent: null,
+      wasBlocked: false
+    };
+  }
+  const newEvent = applyResizeToEvent(originalEvent, startDelta, endDelta);
+  if (!context.eventOverlap) {
+    const overlapping = findOverlappingEvents(newEvent, context.parsedEvents);
+    if (overlapping.length > 0) {
+      return {
+        success: false,
+        newEvent: null,
+        wasBlocked: true
+      };
+    }
+  }
+  return {
+    success: true,
+    newEvent,
+    wasBlocked: false
+  };
+}
+function findEventPositionInGrid(event, grid, getWeekEventPositions) {
+  for (let weekIndex = 0; weekIndex < grid.length; weekIndex++) {
+    const week = grid[weekIndex];
+    const positions = getWeekEventPositions(week);
+    for (const pos of positions) {
+      if (pos.event.id === event.id) {
+        return { weekIndex, startCol: pos.startCol, endCol: pos.endCol, row: pos.row };
+      }
+    }
+  }
+  return null;
+}
+function getDragGhostStyle(position, dimensions, event) {
+  return {
+    position: "fixed",
+    left: `${position.x}px`,
+    top: `${position.y}px`,
+    width: dimensions ? `${dimensions.width}px` : "auto",
+    height: dimensions ? `${dimensions.height}px` : "auto",
+    ...getSchedulerEventSurfaceStyle(event, {}),
+    background: "var(--p-scheduler-event-background)",
+    color: "var(--p-scheduler-event-color)",
+    padding: "0.25rem 0.5rem",
+    borderRadius: "var(--p-scheduler-event-border-radius)",
+    fontSize: "0.75rem",
+    fontWeight: "500",
+    lineHeight: "1.2",
+    pointerEvents: "none",
+    zIndex: "9999",
+    opacity: "0.9",
+    boxShadow: "var(--p-scheduler-event-shadow)",
+    whiteSpace: "nowrap",
+    overflow: "hidden",
+    textOverflow: "ellipsis",
+    display: "flex",
+    alignItems: "center",
+    boxSizing: "border-box"
+  };
+}
+
+// src/controllers/timed.controller.ts
+function resolveTimedPointerStart(input) {
+  if (!input.canDrag && !input.canResize) {
+    return { mode: "none" };
+  }
+  if (!input.rect) {
+    return { mode: "none" };
+  }
+  const rect = input.rect;
+  const relativeY = input.pointer.clientY - rect.top;
+  const resizeEdge = input.canResize ? detectResizeEdge(relativeY, 0, rect.height) : null;
+  if (resizeEdge) {
+    return {
+      mode: "resize",
+      resizeState: createResizeState(input.event, resizeEdge, input.pointer.clientY)
+    };
+  }
+  if (!input.canDrag) {
+    return { mode: "none" };
+  }
+  const offsetX = input.pointer.clientX - rect.left;
+  const offsetY = input.pointer.clientY - rect.top;
+  return {
+    mode: "drag",
+    dragState: createDragState(input.event, input.pointer.clientX, input.pointer.clientY, offsetX, offsetY)
+  };
+}
+function dispatchTimedPointerMove(hasDragState, hasResizeState, handlers, pointer) {
+  if (hasDragState) {
+    handlers.onDrag(pointer);
+    return;
+  }
+  if (hasResizeState) {
+    handlers.onResize(pointer);
+  }
+}
+function dispatchTimedPointerEnd(hasDragState, hasResizeState, handlers, pointer) {
+  if (hasDragState) {
+    handlers.onDrag(pointer);
+    return;
+  }
+  if (hasResizeState) {
+    handlers.onResize(pointer);
+  }
+}
+function calculateTimedDragDelta(state, columnWidth, slotHeight, slotDuration, snapDuration) {
+  const dxPixels = state.currentX - state.startX;
+  const dyPixels = state.currentY - state.startY;
+  const daysDelta = Math.round(dxPixels / columnWidth);
+  const minutesDelta = dyPixels / slotHeight * slotDuration;
+  const snappedMinutes = snapToSlot(minutesDelta, snapDuration);
+  const msDelta = snappedMinutes * 60 * 1e3;
+  return {
+    daysDelta,
+    millisecondsDelta: msDelta,
+    delta: { days: daysDelta, milliseconds: msDelta }
+  };
+}
+function findColumnIndexForDate(date, columns) {
+  return columns.findIndex((col) => {
+    const d1 = col.date;
+    return d1.getFullYear() === date.getFullYear() && d1.getMonth() === date.getMonth() && d1.getDate() === date.getDate();
+  });
+}
+function calculateTimedDragPreview(previewEvent, columns, slotMinTime, slotDuration, slotHeight) {
+  const previewStart = typeof previewEvent.start === "string" ? new Date(previewEvent.start) : previewEvent.start;
+  const previewColIndex = findColumnIndexForDate(previewStart, columns);
+  if (previewColIndex < 0 || previewColIndex >= columns.length) {
+    return null;
+  }
+  const previewEnd = previewEvent.end ? typeof previewEvent.end === "string" ? new Date(previewEvent.end) : previewEvent.end : new Date(previewStart.getTime() + 30 * 60 * 1e3);
+  const top = getYPositionFromTime(previewStart, slotMinTime, slotDuration, slotHeight);
+  const endY = getYPositionFromTime(previewEnd, slotMinTime, slotDuration, slotHeight);
+  const height = endY - top;
+  return {
+    colIndex: previewColIndex,
+    top,
+    height: Math.max(height, slotHeight / 2)
+  };
+}
+function processTimedDragMove(state, columnWidth, columns, context, snapDuration, calendarOptions) {
+  const { delta } = calculateTimedDragDelta(state, columnWidth, context.slotHeight, context.slotDuration, snapDuration);
+  const previewEvent = applyDeltaToEvent(state.originalEvent, delta, calendarOptions);
+  const preview = calculateTimedDragPreview(previewEvent, columns, context.slotMinTime, context.slotDuration, context.slotHeight);
+  if (!preview) {
+    return null;
+  }
+  return {
+    delta,
+    previewEvent,
+    previewColIndex: preview.colIndex,
+    previewTop: preview.top,
+    previewHeight: preview.height
+  };
+}
+function finalizeTimedDrag(state, context, calendarOptions) {
+  const { originalEvent, delta, isDragging } = state;
+  if (!isDragging || delta.days === 0 && delta.milliseconds === 0) {
+    return {
+      success: false,
+      newEvent: null,
+      delta,
+      wasBlocked: false
+    };
+  }
+  const newEvent = applyDeltaToEvent(originalEvent, delta, calendarOptions);
+  if (!context.eventOverlap) {
+    const overlapping = findOverlappingEvents(newEvent, context.parsedEvents);
+    if (overlapping.length > 0) {
+      return {
+        success: false,
+        newEvent: null,
+        delta,
+        wasBlocked: true
+      };
+    }
+  }
+  return {
+    success: true,
+    newEvent,
+    delta,
+    wasBlocked: false
+  };
+}
+function calculateTimedResizePreview(previewEvent, columns, slotMinTime, slotDuration, slotHeight) {
+  const previewStart = typeof previewEvent.start === "string" ? new Date(previewEvent.start) : previewEvent.start;
+  const previewColIndex = findColumnIndexForDate(previewStart, columns);
+  if (previewColIndex < 0) {
+    return null;
+  }
+  const previewEnd = previewEvent.end ? typeof previewEvent.end === "string" ? new Date(previewEvent.end) : previewEvent.end : new Date(previewStart.getTime() + 30 * 60 * 1e3);
+  const top = getYPositionFromTime(previewStart, slotMinTime, slotDuration, slotHeight);
+  const endY = getYPositionFromTime(previewEnd, slotMinTime, slotDuration, slotHeight);
+  const height = endY - top;
+  return {
+    colIndex: previewColIndex,
+    top,
+    height: Math.max(height, slotHeight / 2)
+  };
+}
+function processTimedResizeMove(state, columns, context) {
+  const { originalEvent, startDelta, endDelta } = state;
+  const previewEvent = applyResizeToEvent(originalEvent, startDelta, endDelta);
+  const preview = calculateTimedResizePreview(previewEvent, columns, context.slotMinTime, context.slotDuration, context.slotHeight);
+  if (!preview) {
+    return null;
+  }
+  return {
+    previewEvent,
+    previewColIndex: preview.colIndex,
+    previewTop: preview.top,
+    previewHeight: preview.height
+  };
+}
+function finalizeTimedResize(state, context) {
+  const { originalEvent, startDelta, endDelta, isResizing } = state;
+  if (!isResizing || startDelta === 0 && endDelta === 0) {
+    return {
+      success: false,
+      newEvent: null,
+      startDelta,
+      endDelta,
+      wasBlocked: false
+    };
+  }
+  const newEvent = applyResizeToEvent(originalEvent, startDelta, endDelta);
+  if (!context.eventOverlap) {
+    const overlapping = findOverlappingEvents(newEvent, context.parsedEvents);
+    if (overlapping.length > 0) {
+      return {
+        success: false,
+        newEvent: null,
+        startDelta,
+        endDelta,
+        wasBlocked: true
+      };
+    }
+  }
+  return {
+    success: true,
+    newEvent,
+    startDelta,
+    endDelta,
+    wasBlocked: false
+  };
+}
+function getTimedPreviewStyle(top, height, event) {
+  return {
+    position: "absolute",
+    top: `${top}px`,
+    height: `${height}px`,
+    left: "var(--p-scheduler-timed-event-inset-inline-start, 2px)",
+    right: "var(--p-scheduler-timed-event-inset-inline-end, 4px)",
+    zIndex: "100",
+    pointerEvents: "none",
+    opacity: "0.7",
+    ...getSchedulerEventSurfaceStyle(event, {}),
+    background: "var(--p-scheduler-event-background)",
+    borderColor: "var(--p-scheduler-event-border-color)",
+    color: "var(--p-scheduler-event-color)"
+  };
+}
+function hasTimedDropConstraints(eventConstraint, eventAllow, blockedIntervals) {
+  return Boolean(eventConstraint || eventAllow || blockedIntervals);
+}
+function toEventDate(value) {
+  if (!value) {
+    return null;
+  }
+  if (value instanceof Date) {
+    return new Date(value);
+  }
+  const parsed = new Date(value);
+  if (Number.isNaN(parsed.getTime())) {
+    return null;
+  }
+  return parsed;
+}
+function canDropTimedPreviewEvent(input) {
+  if (!input.previewEvent || !input.originalEvent) {
+    return true;
+  }
+  const start = toEventDate(input.previewEvent.start);
+  if (!start) {
+    return true;
+  }
+  const end = toEventDate(input.previewEvent.end) ?? start;
+  const resourceId = input.resourceId ?? input.previewEvent.resourceId;
+  return canDropEvent(start, end, false, input.view, input.originalEvent, input.eventConstraint, input.eventAllow, input.businessHours, input.blockedIntervals, resourceId);
+}
+
+// src/controllers/timeline.controller.ts
+function resolveTimelineSnapDuration(slotDuration, explicitSnapDuration) {
+  if (explicitSnapDuration !== void 0) return explicitSnapDuration;
+  if (slotDuration >= 60 && slotDuration % 30 === 0) return 30;
+  if (slotDuration >= 30 && slotDuration % 15 === 0) return 15;
+  return slotDuration;
+}
+var TIMELINE_RESIZE_EDGE_SIZE = 12;
+function detectResizeEdgeForTimeline(relativeX, elementWidth, threshold = TIMELINE_RESIZE_EDGE_SIZE) {
+  if (relativeX <= threshold) return "start";
+  if (relativeX >= elementWidth - threshold) return "end";
+  return null;
+}
+function createTimelineDragState(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 updateTimelineDragState(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 calculateTimelineDragDelta(state, context) {
+  const { viewStart, viewEnd, totalWidth, slotDuration, snapDuration, minTimeMinutes, maxTimeMinutes } = context;
+  let totalDuration;
+  if (minTimeMinutes !== void 0 && maxTimeMinutes !== void 0) {
+    const businessMinutesPerDay = maxTimeMinutes - minTimeMinutes;
+    const dayCount = Math.ceil((viewEnd.getTime() - viewStart.getTime()) / (24 * 60 * 60 * 1e3));
+    totalDuration = dayCount * businessMinutesPerDay * 60 * 1e3;
+  } else {
+    totalDuration = viewEnd.getTime() - viewStart.getTime();
+  }
+  const dxPixels = state.currentX - state.startX;
+  const msPerPixel = totalDuration / totalWidth;
+  const rawTimeDelta = dxPixels * msPerPixel;
+  const slotMs = (snapDuration ?? slotDuration) * 60 * 1e3;
+  const snappedTimeDelta = Math.round(rawTimeDelta / slotMs) * slotMs;
+  return { days: 0, milliseconds: snappedTimeDelta };
+}
+function processTimelineDragMove(state, mouseX, mouseY, context, minDistance = DEFAULT_DRAG_MIN_DISTANCE) {
+  const updatedState = updateTimelineDragState(state, mouseX, mouseY, minDistance);
+  const delta = calculateTimelineDragDelta(updatedState, context);
+  const result = {
+    dragGhostPosition: {
+      x: mouseX - updatedState.offsetX,
+      y: mouseY - updatedState.offsetY
+    },
+    delta,
+    previewEvent: null,
+    shouldEmitDragStart: !state.isDragging && updatedState.hasMovedMinDistance,
+    shouldEmitDrag: false
+  };
+  if (updatedState.hasMovedMinDistance) {
+    result.previewEvent = applyDeltaToEvent(state.originalEvent, delta, context);
+    result.shouldEmitDrag = true;
+  }
+  return result;
+}
+function finalizeTimelineDrag(state, delta, context) {
+  const { originalEvent, isDragging } = state;
+  const hasTimeDelta = delta.days !== 0 || delta.milliseconds !== 0;
+  const hasResourceTargetDelta = context.targetResourceId !== void 0 && context.targetResourceId !== originalEvent.resourceId || context.targetResourceIds !== void 0 && (context.targetResourceIds.length !== (originalEvent.resourceIds?.length ?? 0) || context.targetResourceIds.some((resourceId, index) => resourceId !== originalEvent.resourceIds?.[index]));
+  if (!isDragging || !hasTimeDelta && !hasResourceTargetDelta) {
+    return { success: false, newEvent: null, delta, wasBlocked: false };
+  }
+  const newEvent = applyDeltaToEvent(originalEvent, delta, context);
+  if (context.overlapPolicy === "prevent" && context.allEvents) {
+    const candidateEvent = {
+      ...newEvent,
+      resourceId: context.targetResourceId ?? newEvent.resourceId,
+      resourceIds: context.targetResourceIds ?? newEvent.resourceIds
+    };
+    if (hasOverlapInAnyAssignedResource(candidateEvent, context.allEvents)) {
+      return { success: false, newEvent: null, delta, wasBlocked: true };
+    }
+  } else if (!context.eventOverlap) {
+    const overlapping = findOverlappingEvents(newEvent, context.parsedEvents);
+    if (overlapping.length > 0) {
+      return { success: false, newEvent: null, delta, wasBlocked: true };
+    }
+  }
+  return { success: true, newEvent, delta, wasBlocked: false };
+}
+function createTimelineResizeState(event, edge, startX, startY) {
+  return {
+    event: { ...event },
+    originalEvent: { ...event },
+    edge,
+    startX,
+    currentX: startX,
+    startY,
+    currentY: startY,
+    startDelta: 0,
+    endDelta: 0,
+    visualStartPx: 0,
+    visualEndPx: 0,
+    isResizing: false
+  };
+}
+function calculateTimelineResizeDeltas(state, context) {
+  const { viewStart, viewEnd, totalWidth, slotDuration, snapDuration, minTimeMinutes, maxTimeMinutes } = context;
+  let totalDuration;
+  if (minTimeMinutes !== void 0 && maxTimeMinutes !== void 0) {
+    const businessMinutesPerDay = maxTimeMinutes - minTimeMinutes;
+    const dayCount = Math.ceil((viewEnd.getTime() - viewStart.getTime()) / (24 * 60 * 60 * 1e3));
+    totalDuration = dayCount * businessMinutesPerDay * 60 * 1e3;
+  } else {
+    totalDuration = viewEnd.getTime() - viewStart.getTime();
+  }
+  const dxPixels = state.currentX - state.startX;
+  const msPerPixel = totalDuration / totalWidth;
+  const rawTimeDelta = dxPixels * msPerPixel;
+  const snapMs = (snapDuration ?? slotDuration) * 60 * 1e3;
+  const snappedTimeDelta = Math.round(rawTimeDelta / snapMs) * snapMs;
+  const originalEvent = state.originalEvent;
+  const originalStart = typeof originalEvent.start === "string" ? new Date(originalEvent.start) : originalEvent.start;
+  const originalEnd = originalEvent.end ? typeof originalEvent.end === "string" ? new Date(originalEvent.end) : originalEvent.end : new Date(originalStart.getTime() + 60 * 60 * 1e3);
+  const preview = getSchedulerTimelineResizePreview({
+    edge: state.edge,
+    event: originalEvent,
+    start: originalStart,
+    end: originalEnd,
+    deltaMs: snappedTimeDelta,
+    snapMinutes: snapMs / 6e4
+  });
+  return { startDelta: preview.startDelta, endDelta: preview.endDelta };
+}
+function calculateBusinessTimeOffset(datetime, viewStart, minTimeMinutes, maxTimeMinutes) {
+  const msPerDay = 24 * 60 * 60 * 1e3;
+  const businessMinutesPerDay = maxTimeMinutes - minTimeMinutes;
+  const msPerBusinessDay = businessMinutesPerDay * 60 * 1e3;
+  const viewStartDay = new Date(viewStart);
+  viewStartDay.setHours(0, 0, 0, 0);
+  const targetDay = new Date(datetime);
+  targetDay.setHours(0, 0, 0, 0);
+  const daysDiff = Math.floor((targetDay.getTime() - viewStartDay.getTime()) / msPerDay);
+  const fullDaysOffset = daysDiff * msPerBusinessDay;
+  const timeMinutes = datetime.getHours() * 60 + datetime.getMinutes();
+  const clampedMinutes = Math.max(minTimeMinutes, Math.min(maxTimeMinutes, timeMinutes));
+  const minutesIntoBusinessDay = clampedMinutes - minTimeMinutes;
+  return fullDaysOffset + minutesIntoBusinessDay * 60 * 1e3;
+}
+function calculateResizePreviewStyle(originalEvent, startDelta, endDelta, context) {
+  const { viewStart, viewEnd, minTimeMinutes, maxTimeMinutes } = context;
+  const originalStart = typeof originalEvent.start === "string" ? new Date(originalEvent.start) : originalEvent.start;
+  const originalEnd = originalEvent.end ? typeof originalEvent.end === "string" ? new Date(originalEvent.end) : originalEvent.end : new Date(originalStart.getTime() + 60 * 60 * 1e3);
+  const newStart = new Date(originalStart.getTime() + startDelta);
+  const newEnd = new Date(originalEnd.getTime() + endDelta);
+  let leftPercent;
+  let widthPercent;
+  if (minTimeMinutes !== void 0 && maxTimeMinutes !== void 0) {
+    const businessMinutesPerDay = maxTimeMinutes - minTimeMinutes;
+    const dayCount = Math.ceil((viewEnd.getTime() - viewStart.getTime()) / (24 * 60 * 60 * 1e3));
+    const totalBusinessMs = dayCount * businessMinutesPerDay * 60 * 1e3;
+    const startOffset = calculateBusinessTimeOffset(newStart, viewStart, minTimeMinutes, maxTimeMinutes);
+    const endOffset = calculateBusinessTimeOffset(newEnd, viewStart, minTimeMinutes, maxTimeMinutes);
+    leftPercent = startOffset / totalBusinessMs * 100;
+    widthPercent = (endOffset - startOffset) / totalBusinessMs * 100;
+  } else {
+    const totalDuration = viewEnd.getTime() - viewStart.getTime();
+    leftPercent = (newStart.getTime() - viewStart.getTime()) / totalDuration * 100;
+    widthPercent = (newEnd.getTime() - newStart.getTime()) / totalDuration * 100;
+  }
+  return {
+    left: `calc(${leftPercent}% + 2px)`,
+    width: `calc(${Math.max(widthPercent, 1)}% - 4px)`
+  };
+}
+function processTimelineResizeMove(state, mouseX, context) {
+  const updatedState = {
+    ...state,
+    currentX: mouseX,
+    isResizing: Math.abs(mouseX - state.startX) > 2
+  };
+  const { startDelta, endDelta } = calculateTimelineResizeDeltas(updatedState, context);
+  const previewEvent = applyResizeToEvent(state.originalEvent, startDelta, endDelta);
+  const previewStyle = calculateResizePreviewStyle(state.originalEvent, startDelta, endDelta, context);
+  return {
+    startDelta,
+    endDelta,
+    previewEvent,
+    previewStyle
+  };
+}
+function finalizeTimelineResize(state, startDelta, endDelta, context) {
+  const { originalEvent, isResizing } = state;
+  if (!isResizing || startDelta === 0 && endDelta === 0) {
+    return { success: false, newEvent: null, wasBlocked: false };
+  }
+  const newEvent = applyResizeToEvent(originalEvent, startDelta, endDelta);
+  if (context.overlapPolicy === "prevent" && context.allEvents) {
+    const candidateEvent = {
+      ...newEvent,
+      resourceId: context.targetResourceId ?? newEvent.resourceId,
+      resourceIds: context.targetResourceIds ?? newEvent.resourceIds
+    };
+    if (hasOverlapInAnyAssignedResource(candidateEvent, context.allEvents)) {
+      return { success: false, newEvent: null, wasBlocked: true };
+    }
+  } else if (!context.eventOverlap) {
+    const overlapping = findOverlappingEvents(newEvent, context.parsedEvents);
+    if (overlapping.length > 0) {
+      return { success: false, newEvent: null, wasBlocked: true };
+    }
+  }
+  return { success: true, newEvent, wasBlocked: false };
+}
+function getTimelineDragGhostStyle(position, dimensions, event) {
+  return {
+    position: "fixed",
+    left: `${position.x}px`,
+    top: `${position.y}px`,
+    width: dimensions ? `${dimensions.width}px` : "auto",
+    height: dimensions ? `${dimensions.height}px` : "auto",
+    ...getSchedulerEventSurfaceStyle(event, {}),
+    background: "var(--p-scheduler-event-background)",
+    color: "var(--p-scheduler-event-color)",
+    padding: "0.25rem 0.375rem",
+    borderRadius: "var(--p-scheduler-event-border-radius)",
+    borderInlineStart: "var(--p-scheduler-event-accent-width) solid var(--p-scheduler-event-border-accent)",
+    pointerEvents: "none",
+    zIndex: "9999",
+    opacity: "0.9",
+    boxShadow: "var(--p-scheduler-event-shadow)",
+    overflow: "hidden",
+    display: "flex",
+    flexDirection: "column",
+    justifyContent: "center",
+    alignItems: "flex-start",
+    gap: "0.125rem",
+    boxSizing: "border-box"
+  };
+}
+
+// src/controllers/slot-tracking.controller.ts
+var APPOINTMENT_SLOT_TIMED_VIEWS = /* @__PURE__ */ new Set(["day", "week", "resourceDay", "resourceWeek", "dateDay", "dateWeek"]);
+var RESOURCE_SCOPED_SLOT_TRACKING_VIEWS = /* @__PURE__ */ new Set(["resourceDay", "resourceWeek", "dateDay", "dateWeek"]);
+function createAppointmentSlotTrackingState() {
+  return {
+    initialized: false,
+    snapshots: /* @__PURE__ */ new Map(),
+    previousEvents: []
+  };
+}
+function isAppointmentSlotTrackingView(view) {
+  return APPOINTMENT_SLOT_TIMED_VIEWS.has(view);
+}
+function requiresResourceScopedSlotTracking(view) {
+  return RESOURCE_SCOPED_SLOT_TRACKING_VIEWS.has(view);
+}
+function getSlotTrackingKey(slot) {
+  const slotStart = slot.start instanceof Date ? slot.start : new Date(slot.start);
+  const slotEnd = slot.end instanceof Date ? slot.end : new Date(slot.end);
+  const resourceKey = slot.resourceId === void 0 ? "" : String(slot.resourceId);
+  return `${String(slot.id)}|${slotStart.getTime()}|${slotEnd.getTime()}|${resourceKey}`;
+}
+function cloneEventForSlotTracking(event) {
+  return {
+    ...event,
+    start: event.start instanceof Date ? new Date(event.start) : event.start,
+    end: event.end instanceof Date ? new Date(event.end) : event.end,
+    resourceIds: event.resourceIds ? [...event.resourceIds] : event.resourceIds
+  };
+}
+function resolveEventDate(value) {
+  if (!value) return null;
+  const parsed = value instanceof Date ? new Date(value) : new Date(value);
+  return Number.isNaN(parsed.getTime()) ? null : parsed;
+}
+function resolveEventRangeForSlotTracking(event) {
+  const start = resolveEventDate(event.start);
+  if (!start) return null;
+  const end = resolveEventDate(event.end);
+  if (end) {
+    return { start, end };
+  }
+  const durationMinutes = typeof event.duration === "number" && event.duration > 0 ? event.duration : 30;
+  return { start, end: new Date(start.getTime() + durationMinutes * 6e4) };
+}
+function getEventScheduleSignature(event) {
+  const range = resolveEventRangeForSlotTracking(event);
+  const resources = getEventResourceIds(event).map((id) => String(id)).sort().join(",");
+  const startKey = range ? range.start.getTime() : "invalid";
+  const endKey = range ? range.end.getTime() : "invalid";
+  return `${startKey}|${endKey}|${resources}`;
+}
+function doesEventOverlapSlot(event, slot) {
+  const range = resolveEventRangeForSlotTracking(event);
+  if (!range) return false;
+  const slotStart = slot.start instanceof Date ? slot.start : new Date(slot.start);
+  const slotEnd = slot.end instanceof Date ? slot.end : new Date(slot.end);
+  const overlaps = range.start < slotEnd && range.end > slotStart;
+  if (!overlaps) {
+    return false;
+  }
+  if (slot.resourceId === void 0) {
+    return true;
+  }
+  const eventResourceIds = getEventResourceIds(event);
+  return eventResourceIds.includes(slot.resourceId);
+}
+function resolveResourceScopes(context) {
+  if (!requiresResourceScopedSlotTracking(context.view)) {
+    return [void 0];
+  }
+  const leaves = flattenResourceTree(context.resources).filter((resource) => !resource.children || resource.children.length === 0);
+  return leaves.length > 0 ? leaves : [void 0];
+}
+function collectVisibleAppointmentSlots(context) {
+  const resourceScopes = resolveResourceScopes(context);
+  const slots = [];
+  for (const resource of resourceScopes) {
+    slots.push(...getSlotsForTimeRange(context.options, context.viewRange.start, context.viewRange.end, resource, context.slotMinTime, context.slotMaxTime));
+  }
+  return slots;
+}
+function buildSlotTrackingSnapshot(context, eventList) {
+  const slots = collectVisibleAppointmentSlots(context);
+  const updatedSlots = updateSlotsAvailability(slots, eventList);
+  const snapshot = /* @__PURE__ */ new Map();
+  for (const slot of updatedSlots) {
+    snapshot.set(getSlotTrackingKey(slot), {
+      slot,
+      bookedCount: slot.bookedCount ?? 0
+    });
+  }
+  return snapshot;
+}
+function findBookingCandidate(slot, currentEvents, previousEvents) {
+  const previousById = new Map(previousEvents.map((event) => [event.id, getEventScheduleSignature(event)]));
+  for (const event of currentEvents) {
+    const previousSignature = previousById.get(event.id);
+    const currentSignature = getEventScheduleSignature(event);
+    if (previousSignature === currentSignature) {
+      continue;
+    }
+    if (doesEventOverlapSlot(event, slot)) {
+      return event;
+    }
+  }
+  return null;
+}
+function findCancellationCandidate(slot, currentEvents, previousEvents) {
+  const currentById = new Map(currentEvents.map((event) => [event.id, getEventScheduleSignature(event)]));
+  for (const event of previousEvents) {
+    const currentSignature = currentById.get(event.id);
+    const previousSignature = getEventScheduleSignature(event);
+    if (currentSignature === previousSignature) {
+      continue;
+    }
+    if (doesEventOverlapSlot(event, slot)) {
+      return event;
+    }
+  }
+  return null;
+}
+function syncAppointmentSlotTracking(state, context, currentEvents) {
+  if (!context.options.enabled || !isAppointmentSlotTrackingView(context.view)) {
+    return {
+      state: createAppointmentSlotTrackingState(),
+      changes: []
+    };
+  }
+  const currentSnapshot = buildSlotTrackingSnapshot(context, currentEvents);
+  if (!state.initialized) {
+    return {
+      state: {
+        initialized: true,
+        snapshots: currentSnapshot,
+        previousEvents: currentEvents.map(cloneEventForSlotTracking)
+      },
+      changes: []
+    };
+  }
+  const changes = [];
+  const previousSnapshot = state.snapshots;
+  const previousEvents = state.previousEvents;
+  for (const [slotKey, currentState] of currentSnapshot.entries()) {
+    const previousState = previousSnapshot.get(slotKey);
+    const previousBookedCount = previousState?.bookedCount ?? 0;
+    const currentBookedCount = currentState.bookedCount;
+    if (currentBookedCount > previousBookedCount) {
+      const bookingEvent = findBookingCandidate(currentState.slot, currentEvents, previousEvents);
+      if (bookingEvent) {
+        changes.push({
+          type: "book",
+          slot: currentState.slot,
+          event: bookingEvent
+        });
+      }
+    } else if (currentBookedCount < previousBookedCount) {
+      const canceledEvent = findCancellationCandidate(currentState.slot, currentEvents, previousEvents);
+      if (canceledEvent) {
+        changes.push({
+          type: "cancel",
+          slot: currentState.slot,
+          event: canceledEvent
+        });
+      }
+    }
+  }
+  return {
+    state: {
+      initialized: true,
+      snapshots: currentSnapshot,
+      previousEvents: currentEvents.map(cloneEventForSlotTracking)
+    },
+    changes
+  };
+}
+
+export { RESIZE_EDGE_SIZE, TIMELINE_RESIZE_EDGE_SIZE, calculateDragClickOffset, calculateResizeDeltas, calculateResizePreviewPosition, calculateResizePreviewStyle, calculateTimedDragDelta, calculateTimedDragPreview, calculateTimedResizePreview, calculateTimelineDragDelta, calculateTimelineResizeDeltas, canDropTimedPreviewEvent, cloneEventForSlotTracking, createAppointmentSlotTrackingState, createTimelineDragState, createTimelineResizeState, detectResizeEdgeForAllDay, detectResizeEdgeForTimeline, dispatchTimedPointerEnd, dispatchTimedPointerMove, finalizeMonthDrag, finalizeMonthResize, finalizeTimedDrag, finalizeTimedResize, finalizeTimelineDrag, finalizeTimelineResize, findColumnIndexForDate, findEventPositionInGrid, getDragGhostStyle, getSlotTrackingKey, getTimedPreviewStyle, getTimelineDragGhostStyle, hasTimedDropConstraints, isAppointmentSlotTrackingView, processMonthDragMove, processMonthResizeMove, processTimedDragMove, processTimedResizeMove, processTimelineDragMove, processTimelineResizeMove, resolveTimedPointerStart, resolveTimelineSnapDuration, syncAppointmentSlotTracking, updateTimelineDragState };