@primeui/scheduler-core 0.0.1-alpha.1

package/dist/chunk-NX46LPLF.mjs

@@ -0,0 +1,440 @@
+import { isRangeWithinBusinessHours } from './chunk-HPC5B3AR.mjs';
+import { addDays, isSameDay, startOfDay } from './chunk-WFUJWDST.mjs';
+
+// src/utils/resource-constraints.ts
+var DEFAULT_CONFLICT_OPTIONS = {
+  enabled: false,
+  mode: "highlight",
+  checkCapacity: true,
+  checkOverlap: true,
+  checkAvailability: true,
+  checkDailyHours: true,
+  checkEventDuration: true
+};
+function normalizeConflictOptions(options) {
+  if (options === false || options === void 0) {
+    return { ...DEFAULT_CONFLICT_OPTIONS, enabled: false };
+  }
+  if (options === true) {
+    return { ...DEFAULT_CONFLICT_OPTIONS, enabled: true };
+  }
+  return { ...DEFAULT_CONFLICT_OPTIONS, ...options, enabled: options.enabled ?? true };
+}
+function getEventDates(event) {
+  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() + (event.duration ?? 30) * 60 * 1e3);
+  return { start, end };
+}
+function getEventDuration(event) {
+  const { start, end } = getEventDates(event);
+  return (end.getTime() - start.getTime()) / (1e3 * 60);
+}
+function getEventResourceIds(event) {
+  if (Array.isArray(event.resourceIds) && event.resourceIds.length > 0) {
+    return event.resourceIds;
+  }
+  if (event.resourceId !== void 0) {
+    return [event.resourceId];
+  }
+  return [];
+}
+function eventBelongsToResource(event, resourceId) {
+  return getEventResourceIds(event).includes(resourceId);
+}
+function getDurationHoursInRange(start, end, rangeStart, rangeEnd) {
+  const effectiveStart = start.getTime() < rangeStart.getTime() ? rangeStart : start;
+  const effectiveEnd = end.getTime() > rangeEnd.getTime() ? rangeEnd : end;
+  const ms = effectiveEnd.getTime() - effectiveStart.getTime();
+  if (ms <= 0) {
+    return 0;
+  }
+  return ms / (1e3 * 60 * 60);
+}
+function getOverlappingDayStarts(start, end) {
+  if (end.getTime() <= start.getTime()) {
+    return [];
+  }
+  const days = [];
+  let cursor = startOfDay(start);
+  while (cursor.getTime() < end.getTime()) {
+    days.push(new Date(cursor));
+    cursor = addDays(cursor, 1);
+  }
+  return days;
+}
+function getEventsForResourceOnDate(resourceId, date, allEvents) {
+  const dayStart = startOfDay(date);
+  const dayEnd = addDays(dayStart, 1);
+  return allEvents.filter((event) => {
+    if (!eventBelongsToResource(event, resourceId)) return false;
+    const { start, end } = getEventDates(event);
+    return start < dayEnd && end > dayStart;
+  });
+}
+function getEventsOverlappingTimeRange(resourceId, start, end, allEvents, excludeEventId) {
+  return allEvents.filter((event) => {
+    if (excludeEventId && event.id === excludeEventId) return false;
+    if (!eventBelongsToResource(event, resourceId)) return false;
+    const eventDates = getEventDates(event);
+    return eventDates.start < end && eventDates.end > start;
+  });
+}
+function checkCapacityConstraint(resource, event, allEvents) {
+  const capacity = resource.constraints?.capacity;
+  if (capacity === void 0) return null;
+  const { start, end } = getEventDates(event);
+  const overlapping = getEventsOverlappingTimeRange(resource.id, start, end, allEvents, event.id);
+  if (overlapping.length >= capacity) {
+    return {
+      type: "capacity",
+      resourceId: resource.id,
+      eventId: event.id,
+      message: `Resource "${resource.title}" has reached its capacity of ${capacity} concurrent events`,
+      severity: "error"
+    };
+  }
+  return null;
+}
+function checkDailyHoursConstraint(resource, event, allEvents) {
+  const maxHours = resource.constraints?.maxHoursPerDay;
+  if (maxHours === void 0) return null;
+  const { start: eventStart, end: eventEnd } = getEventDates(event);
+  for (const dayStart of getOverlappingDayStarts(eventStart, eventEnd)) {
+    const dayEnd = addDays(dayStart, 1);
+    const dayEvents = getEventsForResourceOnDate(resource.id, dayStart, allEvents).filter((e) => e.id !== event.id);
+    const existingHours = dayEvents.reduce((sum, dayEvent) => {
+      const { start, end } = getEventDates(dayEvent);
+      return sum + getDurationHoursInRange(start, end, dayStart, dayEnd);
+    }, 0);
+    const candidateHours = getDurationHoursInRange(eventStart, eventEnd, dayStart, dayEnd);
+    if (existingHours + candidateHours > maxHours) {
+      const dayLabel = dayStart.toISOString().slice(0, 10);
+      return {
+        type: "hours-limit",
+        resourceId: resource.id,
+        eventId: event.id,
+        message: `Adding this event would exceed ${maxHours} hours on ${dayLabel} for "${resource.title}"`,
+        severity: "error"
+      };
+    }
+  }
+  return null;
+}
+function checkDailyEventsConstraint(resource, event, allEvents) {
+  const maxEvents = resource.constraints?.maxEventsPerDay;
+  if (maxEvents === void 0) return null;
+  const { start, end } = getEventDates(event);
+  for (const dayStart of getOverlappingDayStarts(start, end)) {
+    const dayEvents = getEventsForResourceOnDate(resource.id, dayStart, allEvents).filter((e) => e.id !== event.id);
+    if (dayEvents.length + 1 > maxEvents) {
+      const dayLabel = dayStart.toISOString().slice(0, 10);
+      return {
+        type: "capacity",
+        resourceId: resource.id,
+        eventId: event.id,
+        message: `Resource "${resource.title}" has reached its daily limit of ${maxEvents} events on ${dayLabel}`,
+        severity: "error"
+      };
+    }
+  }
+  return null;
+}
+function checkOverlapConstraint(resource, event, allEvents) {
+  const { start, end } = getEventDates(event);
+  const overlapping = getEventsOverlappingTimeRange(resource.id, start, end, allEvents, event.id);
+  if (overlapping.length > 0) {
+    return {
+      type: "overlap",
+      resourceId: resource.id,
+      eventId: event.id,
+      message: `Resource "${resource.title}" already has ${overlapping.length} overlapping event(s)`,
+      severity: "error"
+    };
+  }
+  return null;
+}
+function checkAvailabilityConstraint(resource, event) {
+  if (event.allDay) {
+    return null;
+  }
+  if (!resource.businessHours) {
+    return null;
+  }
+  const { start, end } = getEventDates(event);
+  if (!isRangeWithinBusinessHours(start, end, resource.businessHours)) {
+    return {
+      type: "availability",
+      resourceId: resource.id,
+      eventId: event.id,
+      message: `Event is outside availability hours for "${resource.title}"`,
+      severity: "error"
+    };
+  }
+  return null;
+}
+function checkEventDurationConstraint(resource, event) {
+  const constraints = resource.constraints;
+  if (!constraints) return null;
+  const duration = getEventDuration(event);
+  if (constraints.minEventDuration !== void 0 && duration < constraints.minEventDuration) {
+    return {
+      type: "duration",
+      resourceId: resource.id,
+      eventId: event.id,
+      message: `Event duration (${duration} min) is below minimum (${constraints.minEventDuration} min) for "${resource.title}"`,
+      severity: "error"
+    };
+  }
+  if (constraints.maxEventDuration !== void 0 && duration > constraints.maxEventDuration) {
+    return {
+      type: "duration",
+      resourceId: resource.id,
+      eventId: event.id,
+      message: `Event duration (${duration} min) exceeds maximum (${constraints.maxEventDuration} min) for "${resource.title}"`,
+      severity: "error"
+    };
+  }
+  return null;
+}
+function checkSkillConstraint(resource, event) {
+  const resourceSkills = resource.constraints?.skills;
+  if (!resourceSkills || resourceSkills.length === 0) return null;
+  const requiredSkills = event.metadata?.requiredSkills;
+  if (!requiredSkills || requiredSkills.length === 0) return null;
+  const missingSkills = requiredSkills.filter((skill) => !resourceSkills.includes(skill));
+  if (missingSkills.length > 0) {
+    return {
+      type: "skill-mismatch",
+      resourceId: resource.id,
+      eventId: event.id,
+      message: `Resource "${resource.title}" is missing required skills: ${missingSkills.join(", ")}`,
+      severity: "warning"
+    };
+  }
+  return null;
+}
+function validateResourceConstraints(event, resource, allEvents, options) {
+  const conflicts = [];
+  if (!options.enabled) return conflicts;
+  if (options.checkCapacity) {
+    const capacityConflict = checkCapacityConstraint(resource, event, allEvents);
+    if (capacityConflict) conflicts.push(capacityConflict);
+    const dailyEventsConflict = checkDailyEventsConstraint(resource, event, allEvents);
+    if (dailyEventsConflict) conflicts.push(dailyEventsConflict);
+  }
+  if (options.checkOverlap) {
+    const overlapConflict = checkOverlapConstraint(resource, event, allEvents);
+    if (overlapConflict) conflicts.push(overlapConflict);
+  }
+  if (options.checkAvailability) {
+    const availabilityConflict = checkAvailabilityConstraint(resource, event);
+    if (availabilityConflict) conflicts.push(availabilityConflict);
+  }
+  if (options.checkDailyHours) {
+    const hoursConflict = checkDailyHoursConstraint(resource, event, allEvents);
+    if (hoursConflict) conflicts.push(hoursConflict);
+  }
+  if (options.checkEventDuration) {
+    const durationConflict = checkEventDurationConstraint(resource, event);
+    if (durationConflict) conflicts.push(durationConflict);
+  }
+  const skillConflict = checkSkillConstraint(resource, event);
+  if (skillConflict) conflicts.push(skillConflict);
+  return conflicts;
+}
+function getResourceCapacity(resource, date, allEvents) {
+  const capacity = resource.constraints?.capacity ?? Infinity;
+  const maxEvents = resource.constraints?.maxEventsPerDay;
+  if (capacity === Infinity && maxEvents === void 0) {
+    return { current: 0, max: Infinity, available: Infinity, percentage: 0 };
+  }
+  const dayEvents = getEventsForResourceOnDate(resource.id, date, allEvents);
+  if (maxEvents !== void 0) {
+    const current = dayEvents.length;
+    return {
+      current,
+      max: maxEvents,
+      available: Math.max(0, maxEvents - current),
+      percentage: maxEvents > 0 ? current / maxEvents * 100 : 0
+    };
+  }
+  let maxConcurrent = 0;
+  const timePoints = /* @__PURE__ */ new Set();
+  dayEvents.forEach((event) => {
+    const { start, end } = getEventDates(event);
+    timePoints.add(start.getTime());
+    timePoints.add(end.getTime());
+  });
+  const sortedPoints = Array.from(timePoints).sort((a, b) => a - b);
+  for (const point of sortedPoints) {
+    const concurrent = dayEvents.filter((event) => {
+      const { start, end } = getEventDates(event);
+      return start.getTime() <= point && end.getTime() > point;
+    }).length;
+    maxConcurrent = Math.max(maxConcurrent, concurrent);
+  }
+  return {
+    current: maxConcurrent,
+    max: capacity,
+    available: Math.max(0, capacity - maxConcurrent),
+    percentage: capacity > 0 ? maxConcurrent / capacity * 100 : 0
+  };
+}
+function getCapacityStatus(info) {
+  if (info.max === Infinity) return "available";
+  if (info.current >= info.max) return "full";
+  if (info.percentage >= 80) return "near-full";
+  return "available";
+}
+function canDropEventWithResourceConstraints(event, resource, allEvents, options) {
+  if (!resource || !options.enabled) {
+    return { canDrop: true, conflicts: [] };
+  }
+  const conflicts = validateResourceConstraints(event, resource, allEvents, options);
+  if (conflicts.length === 0) {
+    return { canDrop: true, conflicts: [] };
+  }
+  if (options.mode === "prevent") {
+    const hasErrors = conflicts.some((c) => c.severity === "error");
+    return { canDrop: !hasErrors, conflicts };
+  }
+  if (options.onConflict) {
+    for (const conflict of conflicts) {
+      const result = options.onConflict(conflict);
+      if (result === "prevent") {
+        return { canDrop: false, conflicts };
+      }
+    }
+  }
+  return { canDrop: true, conflicts };
+}
+
+// src/interaction/selection.ts
+function handleDateSelection(date, mode, currentState) {
+  if (mode === "none") {
+    return {
+      selectedDates: currentState.selectedDates,
+      selectedRange: currentState.selectedRange,
+      selectedTimeRange: currentState.selectedTimeRange,
+      changed: false
+    };
+  }
+  if (mode === "single") {
+    return {
+      selectedDates: [date],
+      selectedRange: null,
+      selectedTimeRange: null,
+      changed: true
+    };
+  }
+  if (mode === "multiple") {
+    const existingIndex = currentState.selectedDates.findIndex((d) => d.getTime() === date.getTime());
+    if (existingIndex >= 0) {
+      return {
+        selectedDates: currentState.selectedDates.filter((_, i) => i !== existingIndex),
+        selectedRange: null,
+        selectedTimeRange: null,
+        changed: true
+      };
+    }
+    return {
+      selectedDates: [...currentState.selectedDates, date],
+      selectedRange: null,
+      selectedTimeRange: null,
+      changed: true
+    };
+  }
+  if (mode === "range") {
+    return {
+      selectedDates: [],
+      selectedRange: { start: date, end: date },
+      selectedTimeRange: null,
+      changed: true
+    };
+  }
+  return {
+    selectedDates: currentState.selectedDates,
+    selectedRange: currentState.selectedRange,
+    selectedTimeRange: currentState.selectedTimeRange,
+    changed: false
+  };
+}
+function handleTimeSelection(start, end, mode) {
+  if (mode === "none") {
+    return {
+      selectedDates: [],
+      selectedRange: null,
+      selectedTimeRange: null,
+      changed: false
+    };
+  }
+  return {
+    selectedDates: [],
+    selectedRange: null,
+    selectedTimeRange: { start, end },
+    changed: true
+  };
+}
+function startDragSelection(date) {
+  return {
+    isDragging: true,
+    dragStartDate: date,
+    previewRange: { start: date, end: date }
+  };
+}
+function calculateDragRange(startDate, currentDate) {
+  if (startDate <= currentDate) {
+    return { start: startDate, end: currentDate };
+  }
+  return { start: currentDate, end: startDate };
+}
+function updateDragPreview(startDate, currentDate) {
+  return {
+    previewRange: calculateDragRange(startDate, currentDate)
+  };
+}
+function finalizeDragSelection(startDate, endDate) {
+  const range = calculateDragRange(startDate, endDate);
+  return {
+    selectedDates: [],
+    selectedRange: range,
+    selectedTimeRange: null,
+    isDragging: false,
+    dragStartDate: null,
+    previewRange: null
+  };
+}
+function clearSelection() {
+  return {
+    selectedDates: [],
+    selectedRange: null,
+    selectedTimeRange: null
+  };
+}
+function hasSelection(state) {
+  return state.selectedDates.length > 0 || state.selectedRange !== null || state.selectedTimeRange !== null;
+}
+function isDateSelected(date, selectedDates) {
+  return selectedDates.some((d) => isSameDay(d, date));
+}
+function isDateInSelectionRange(date, range) {
+  if (!range) return false;
+  const time = date.getTime();
+  return time >= range.start.getTime() && time <= range.end.getTime();
+}
+function isRangeStart(date, range) {
+  if (!range) return false;
+  return isSameDay(date, range.start);
+}
+function isRangeEnd(date, range) {
+  if (!range) return false;
+  return isSameDay(date, range.end);
+}
+function getActiveRange(selectedRange, previewRange, isDragging) {
+  if (isDragging && previewRange) {
+    return previewRange;
+  }
+  return selectedRange;
+}
+
+export { DEFAULT_CONFLICT_OPTIONS, calculateDragRange, canDropEventWithResourceConstraints, checkAvailabilityConstraint, checkCapacityConstraint, checkDailyEventsConstraint, checkDailyHoursConstraint, checkEventDurationConstraint, checkOverlapConstraint, checkSkillConstraint, clearSelection, finalizeDragSelection, getActiveRange, getCapacityStatus, getResourceCapacity, handleDateSelection, handleTimeSelection, hasSelection, isDateInSelectionRange, isDateSelected, isRangeEnd, isRangeStart, normalizeConflictOptions, startDragSelection, updateDragPreview, validateResourceConstraints };