@mantine/schedule 9.6.3 → 9.7.1

package/esm/hooks/validate-event-resize.mjs

@@ -0,0 +1,37 @@
+"use client";
+import { isEventPlacementAllowed } from "../utils/is-event-placement-allowed/is-event-placement-allowed.mjs";
+//#region packages/@mantine/schedule/src/hooks/validate-event-resize.ts
+function validateEventResize({ event, start, end, edge, events, preventEventOverlap, canResizeEventTo, resourceId }) {
+	const { allowed, conflicts } = isEventPlacementAllowed({
+		event,
+		start,
+		end,
+		events: events || [],
+		preventEventOverlap,
+		resourceId
+	});
+	if (!allowed) return {
+		valid: false,
+		conflicts,
+		reason: "overlap"
+	};
+	if (canResizeEventTo && canResizeEventTo({
+		event,
+		start,
+		end,
+		edge
+	}) === false) return {
+		valid: false,
+		conflicts: [],
+		reason: "rejected"
+	};
+	return {
+		valid: true,
+		conflicts: [],
+		reason: null
+	};
+}
+//#endregion
+export { validateEventResize };
+
+//# sourceMappingURL=validate-event-resize.mjs.map

package/esm/hooks/validate-event-resize.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate-event-resize.mjs","names":[],"sources":["../../src/hooks/validate-event-resize.ts"],"sourcesContent":["import {\n  DateTimeStringValue,\n  PreventEventOverlap,\n  ScheduleCanResizeEventToData,\n  ScheduleEventData,\n} from '../types';\nimport { isEventPlacementAllowed } from '../utils/is-event-placement-allowed/is-event-placement-allowed';\n\nexport interface EventResizeValidationOptions {\n  /** Events the candidate range is checked against when `preventEventOverlap` is set */\n  events?: ScheduleEventData[];\n\n  /** If set, resizes that would make the event overlap another event are rejected */\n  preventEventOverlap?: PreventEventOverlap;\n\n  /** Called on every pointer move to compute live feedback and again before the resize is committed, return `false` to reject the new size */\n  canResizeEventTo?: (data: ScheduleCanResizeEventToData) => boolean;\n\n  /** Called when a resize is rejected */\n  onEventPlacementRejected?: (data: {\n    action: 'resize';\n    event: ScheduleEventData;\n    start: DateTimeStringValue;\n    end: DateTimeStringValue;\n    edge: 'start' | 'end';\n    resourceId?: string | number;\n    conflicts: ScheduleEventData[];\n    reason: 'overlap' | 'rejected';\n  }) => void;\n}\n\nexport interface ValidateEventResizeInput extends EventResizeValidationOptions {\n  event: ScheduleEventData;\n  start: DateTimeStringValue;\n  end: DateTimeStringValue;\n  edge: 'start' | 'end';\n  resourceId?: string | number;\n}\n\nexport interface ValidateEventResizeResult {\n  valid: boolean;\n  conflicts: ScheduleEventData[];\n  reason: 'overlap' | 'rejected' | null;\n}\n\nexport function validateEventResize({\n  event,\n  start,\n  end,\n  edge,\n  events,\n  preventEventOverlap,\n  canResizeEventTo,\n  resourceId,\n}: ValidateEventResizeInput): ValidateEventResizeResult {\n  const { allowed, conflicts } = isEventPlacementAllowed({\n    event,\n    start,\n    end,\n    events: events || [],\n    preventEventOverlap,\n    resourceId,\n  });\n\n  if (!allowed) {\n    return { valid: false, conflicts, reason: 'overlap' };\n  }\n\n  if (canResizeEventTo && canResizeEventTo({ event, start, end, edge }) === false) {\n    return { valid: false, conflicts: [], reason: 'rejected' };\n  }\n\n  return { valid: true, conflicts: [], reason: null };\n}\n"],"mappings":";;;AA6CA,SAAgB,oBAAoB,EAClC,OACA,OACA,KACA,MACA,QACA,qBACA,kBACA,cACsD;CACtD,MAAM,EAAE,SAAS,cAAc,wBAAwB;EACrD;EACA;EACA;EACA,QAAQ,UAAU,CAAC;EACnB;EACA;CACF,CAAC;CAED,IAAI,CAAC,SACH,OAAO;EAAE,OAAO;EAAO;EAAW,QAAQ;CAAU;CAGtD,IAAI,oBAAoB,iBAAiB;EAAE;EAAO;EAAO;EAAK;CAAK,CAAC,MAAM,OACxE,OAAO;EAAE,OAAO;EAAO,WAAW,CAAC;EAAG,QAAQ;CAAW;CAG3D,OAAO;EAAE,OAAO;EAAM,WAAW,CAAC;EAAG,QAAQ;CAAK;AACpD"}

package/esm/index.mjs

@@ -43,6 +43,7 @@ import { getIndexFromDragPoint } from "./utils/get-index-from-drag-point/get-ind
 import { getDayRelativePercent } from "./utils/get-day-relative-percent/get-day-relative-percent.mjs";
 import { getOverlapClusters } from "./utils/get-overlap-clusters/get-overlap-clusters.mjs";
 import { applyCascadeLayout } from "./utils/apply-cascade-layout/apply-cascade-layout.mjs";
+import { isEventPlacementAllowed } from "./utils/is-event-placement-allowed/is-event-placement-allowed.mjs";
 import { AgendaView } from "./components/AgendaView/AgendaView.mjs";
 import { CurrentTimeIndicator } from "./components/CurrentTimeIndicator/CurrentTimeIndicator.mjs";
 import { DragContext } from "./components/DragContext/DragContext.mjs";
@@ -60,4 +61,4 @@ import { ResourcesDayView } from "./components/ResourcesDayView/ResourcesDayView
 import { ResourcesWeekView } from "./components/ResourcesWeekView/ResourcesWeekView.mjs";
 import { ResourcesMonthView } from "./components/ResourcesMonthView/ResourcesMonthView.mjs";
 import { ResourcesSchedule } from "./components/ResourcesSchedule/ResourcesSchedule.mjs";
-export { AgendaView, CurrentTimeIndicator, DEFAULT_SCHEDULE_LABELS, DayView, DragContext, MobileMonthView, MonthView, MoreEvents, ResourcesDayView, ResourcesMonthView, ResourcesSchedule, ResourcesWeekView, Schedule, ScheduleBackgroundEvent, ScheduleEvent, ScheduleHeader, WeekView, YearView, applyCascadeLayout, calculateDropTime, calculateMonthDropDate, clampIntervalMinutes, expandRecurringEvents, formatDate, getBusinessHoursMod, getCurrentTimePosition, getDayPosition, getDayRelativePercent, getDayTimeIntervals, getEndOfWeek, getGroupToResourceIdMap, getIndexFromDragPoint, getLabel, getMonthDays, getMonthRange, getMonthsByQuarter, getMonthsList, getOrderedResources, getOverlapClusters, getStartOfWeek, getTimeAxisEventStyle, getVisibleEvents, getWeekDays, getWeekNumber, getWeekdaysNames, getYearsList, handleResourcesGridKeyDown, isAfterMinDate, isAllDayEvent, isBeforeMaxDate, isEventInTimeRange, isEventsOverlap, isInTimeRange, isMultidayEvent, isSameMonth, isWithinWeek, nextWeek, parseTimeString, previousWeek, sortEvents, toDateString, toTimeString, validateEvent };
+export { AgendaView, CurrentTimeIndicator, DEFAULT_SCHEDULE_LABELS, DayView, DragContext, MobileMonthView, MonthView, MoreEvents, ResourcesDayView, ResourcesMonthView, ResourcesSchedule, ResourcesWeekView, Schedule, ScheduleBackgroundEvent, ScheduleEvent, ScheduleHeader, WeekView, YearView, applyCascadeLayout, calculateDropTime, calculateMonthDropDate, clampIntervalMinutes, expandRecurringEvents, formatDate, getBusinessHoursMod, getCurrentTimePosition, getDayPosition, getDayRelativePercent, getDayTimeIntervals, getEndOfWeek, getGroupToResourceIdMap, getIndexFromDragPoint, getLabel, getMonthDays, getMonthRange, getMonthsByQuarter, getMonthsList, getOrderedResources, getOverlapClusters, getStartOfWeek, getTimeAxisEventStyle, getVisibleEvents, getWeekDays, getWeekNumber, getWeekdaysNames, getYearsList, handleResourcesGridKeyDown, isAfterMinDate, isAllDayEvent, isBeforeMaxDate, isEventInTimeRange, isEventPlacementAllowed, isEventsOverlap, isInTimeRange, isMultidayEvent, isSameMonth, isWithinWeek, nextWeek, parseTimeString, previousWeek, sortEvents, toDateString, toTimeString, validateEvent };

package/esm/utils/is-event-placement-allowed/is-event-placement-allowed.mjs

@@ -0,0 +1,50 @@
+"use client";
+import { isEventsOverlap } from "../is-events-overlap/is-events-overlap.mjs";
+import dayjs from "dayjs";
+//#region packages/@mantine/schedule/src/utils/is-event-placement-allowed/is-event-placement-allowed.ts
+function isSameEvent(event, other) {
+	if (event.id === other.id) return true;
+	const eventSeriesId = event.recurringEventId ?? event.recurringInstance?.recurringEventId;
+	const otherSeriesId = other.recurringEventId ?? other.recurringInstance?.recurringEventId;
+	if (eventSeriesId === void 0 || otherSeriesId === void 0) return false;
+	const eventOccurrenceId = event.recurrenceId ?? event.recurringInstance?.recurrenceId;
+	const otherOccurrenceId = other.recurrenceId ?? other.recurringInstance?.recurrenceId;
+	return eventSeriesId === otherSeriesId && eventOccurrenceId !== void 0 && eventOccurrenceId === otherOccurrenceId;
+}
+function isMidnight(value) {
+	return value.hour() === 0 && value.minute() === 0 && value.second() === 0;
+}
+function spansWholeDays(event) {
+	const start = dayjs(event.start);
+	const end = dayjs(event.end);
+	if (!isMidnight(start)) return false;
+	return isMidnight(end) || end.hour() === 23 && end.minute() === 59 && end.second() === 59;
+}
+function isEventPlacementAllowed({ event, start, end, events, preventEventOverlap, resourceId }) {
+	if (!preventEventOverlap) return {
+		allowed: true,
+		conflicts: []
+	};
+	const candidate = {
+		...event,
+		start,
+		end,
+		...resourceId !== void 0 ? { resourceId } : {}
+	};
+	const candidateIsAllDay = spansWholeDays(candidate);
+	const conflicts = events.filter((other) => {
+		if (other.display === "background" || isSameEvent(event, other)) return false;
+		if (resourceId !== void 0 && other.resourceId !== resourceId) return false;
+		if (spansWholeDays(other) !== candidateIsAllDay) return false;
+		if (!isEventsOverlap(other, candidate)) return false;
+		return typeof preventEventOverlap === "function" ? preventEventOverlap(other, candidate) : true;
+	});
+	return {
+		allowed: conflicts.length === 0,
+		conflicts
+	};
+}
+//#endregion
+export { isEventPlacementAllowed };
+
+//# sourceMappingURL=is-event-placement-allowed.mjs.map

package/esm/utils/is-event-placement-allowed/is-event-placement-allowed.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-event-placement-allowed.mjs","names":[],"sources":["../../../src/utils/is-event-placement-allowed/is-event-placement-allowed.ts"],"sourcesContent":["import dayjs from 'dayjs';\nimport { DateTimeStringValue, PreventEventOverlap, ScheduleEventData } from '../../types';\nimport { isEventsOverlap } from '../is-events-overlap/is-events-overlap';\n\nexport interface IsEventPlacementAllowedInput {\n  /** Event that is being moved or resized */\n  event: ScheduleEventData;\n\n  /** Candidate start of the event */\n  start: DateTimeStringValue;\n\n  /** Candidate end of the event */\n  end: DateTimeStringValue;\n\n  /** Events the candidate range is checked against */\n  events: ScheduleEventData[];\n\n  /** If set, placements that overlap another event are rejected */\n  preventEventOverlap?: PreventEventOverlap;\n\n  /** Target resource, limits the check to events of that resource */\n  resourceId?: string | number;\n}\n\nexport interface IsEventPlacementAllowedResult {\n  /** True if the candidate range does not conflict with any event */\n  allowed: boolean;\n\n  /** Events the candidate range collided with */\n  conflicts: ScheduleEventData[];\n}\n\nfunction isSameEvent(event: ScheduleEventData, other: ScheduleEventData) {\n  if (event.id === other.id) {\n    return true;\n  }\n\n  const eventSeriesId = event.recurringEventId ?? event.recurringInstance?.recurringEventId;\n  const otherSeriesId = other.recurringEventId ?? other.recurringInstance?.recurringEventId;\n\n  if (eventSeriesId === undefined || otherSeriesId === undefined) {\n    return false;\n  }\n\n  const eventOccurrenceId = event.recurrenceId ?? event.recurringInstance?.recurrenceId;\n  const otherOccurrenceId = other.recurrenceId ?? other.recurringInstance?.recurrenceId;\n\n  return (\n    eventSeriesId === otherSeriesId &&\n    eventOccurrenceId !== undefined &&\n    eventOccurrenceId === otherOccurrenceId\n  );\n}\n\nfunction isMidnight(value: dayjs.Dayjs) {\n  return value.hour() === 0 && value.minute() === 0 && value.second() === 0;\n}\n\nfunction spansWholeDays(event: ScheduleEventData) {\n  const start = dayjs(event.start);\n  const end = dayjs(event.end);\n\n  if (!isMidnight(start)) {\n    return false;\n  }\n\n  return isMidnight(end) || (end.hour() === 23 && end.minute() === 59 && end.second() === 59);\n}\n\nexport function isEventPlacementAllowed({\n  event,\n  start,\n  end,\n  events,\n  preventEventOverlap,\n  resourceId,\n}: IsEventPlacementAllowedInput): IsEventPlacementAllowedResult {\n  if (!preventEventOverlap) {\n    return { allowed: true, conflicts: [] };\n  }\n\n  const candidate = {\n    ...event,\n    start,\n    end,\n    ...(resourceId !== undefined ? { resourceId } : {}),\n  } as ScheduleEventData;\n  const candidateIsAllDay = spansWholeDays(candidate);\n  const conflicts = events.filter((other) => {\n    if (other.display === 'background' || isSameEvent(event, other)) {\n      return false;\n    }\n\n    if (resourceId !== undefined && other.resourceId !== resourceId) {\n      return false;\n    }\n\n    if (spansWholeDays(other) !== candidateIsAllDay) {\n      return false;\n    }\n\n    if (!isEventsOverlap(other, candidate)) {\n      return false;\n    }\n\n    return typeof preventEventOverlap === 'function' ? preventEventOverlap(other, candidate) : true;\n  });\n\n  return { allowed: conflicts.length === 0, conflicts };\n}\n"],"mappings":";;;;AAgCA,SAAS,YAAY,OAA0B,OAA0B;CACvE,IAAI,MAAM,OAAO,MAAM,IACrB,OAAO;CAGT,MAAM,gBAAgB,MAAM,oBAAoB,MAAM,mBAAmB;CACzE,MAAM,gBAAgB,MAAM,oBAAoB,MAAM,mBAAmB;CAEzE,IAAI,kBAAkB,KAAA,KAAa,kBAAkB,KAAA,GACnD,OAAO;CAGT,MAAM,oBAAoB,MAAM,gBAAgB,MAAM,mBAAmB;CACzE,MAAM,oBAAoB,MAAM,gBAAgB,MAAM,mBAAmB;CAEzE,OACE,kBAAkB,iBAClB,sBAAsB,KAAA,KACtB,sBAAsB;AAE1B;AAEA,SAAS,WAAW,OAAoB;CACtC,OAAO,MAAM,KAAK,MAAM,KAAK,MAAM,OAAO,MAAM,KAAK,MAAM,OAAO,MAAM;AAC1E;AAEA,SAAS,eAAe,OAA0B;CAChD,MAAM,QAAQ,MAAM,MAAM,KAAK;CAC/B,MAAM,MAAM,MAAM,MAAM,GAAG;CAE3B,IAAI,CAAC,WAAW,KAAK,GACnB,OAAO;CAGT,OAAO,WAAW,GAAG,KAAM,IAAI,KAAK,MAAM,MAAM,IAAI,OAAO,MAAM,MAAM,IAAI,OAAO,MAAM;AAC1F;AAEA,SAAgB,wBAAwB,EACtC,OACA,OACA,KACA,QACA,qBACA,cAC8D;CAC9D,IAAI,CAAC,qBACH,OAAO;EAAE,SAAS;EAAM,WAAW,CAAC;CAAE;CAGxC,MAAM,YAAY;EAChB,GAAG;EACH;EACA;EACA,GAAI,eAAe,KAAA,IAAY,EAAE,WAAW,IAAI,CAAC;CACnD;CACA,MAAM,oBAAoB,eAAe,SAAS;CAClD,MAAM,YAAY,OAAO,QAAQ,UAAU;EACzC,IAAI,MAAM,YAAY,gBAAgB,YAAY,OAAO,KAAK,GAC5D,OAAO;EAGT,IAAI,eAAe,KAAA,KAAa,MAAM,eAAe,YACnD,OAAO;EAGT,IAAI,eAAe,KAAK,MAAM,mBAC5B,OAAO;EAGT,IAAI,CAAC,gBAAgB,OAAO,SAAS,GACnC,OAAO;EAGT,OAAO,OAAO,wBAAwB,aAAa,oBAAoB,OAAO,SAAS,IAAI;CAC7F,CAAC;CAED,OAAO;EAAE,SAAS,UAAU,WAAW;EAAG;CAAU;AACtD"}

package/lib/components/DayView/DayView.d.ts

@@ -1,6 +1,6 @@
 import { BoxProps, DataAttributes, ElementProps, Factory, MantineRadius, ScrollAreaAutosizeProps, StylesApiProps } from '@mantine/core';
 import { ScheduleLabelsOverride } from '../../labels';
-import { AnyDateValue, DateLabelFormat, DateStringValue, DateTimeStringValue, ScheduleEventData, ScheduleEventOverlapMode, ScheduleMode, ScheduleViewLevel } from '../../types';
+import { AnyDateValue, DateLabelFormat, DateStringValue, DateTimeStringValue, PreventEventOverlap, ScheduleCanDropEventData, ScheduleCanDropExternalEventData, ScheduleCanResizeEventToData, ScheduleEventData, ScheduleEventOverlapMode, ScheduleEventPlacementRejectedData, ScheduleMode, ScheduleViewLevel } from '../../types';
 import { AgendaViewStylesNames } from '../AgendaView/AgendaView';
 import { CurrentTimeIndicatorStylesNames } from '../CurrentTimeIndicator/CurrentTimeIndicator';
 import { MoreEventsProps, MoreEventsStylesNames } from '../MoreEvents/MoreEvents';
@@ -128,6 +128,16 @@ export interface DayViewProps extends BoxProps, StylesApiProps<DayViewFactory>,
     }) => void;
     /** Function to determine if event can be resized */
     canResizeEvent?: (event: ScheduleEventData) => boolean;
+    /** Called while an event is dragged over a target to compute live feedback and again before the drop is committed, return `false` to reject the drop. Must be pure and cheap. */
+    canDropEvent?: (data: ScheduleCanDropEventData) => boolean;
+    /** Called while an external item is dragged over a target to compute live feedback and again before the drop is committed, return `false` to reject the drop. Must be pure and cheap. Only `dataTransfer.types` can be read while the drag is in progress. */
+    canDropExternalEvent?: (data: ScheduleCanDropExternalEventData) => boolean;
+    /** Called on every pointer move while an event is resized to compute live feedback and again before the resize is committed, return `false` to reject the new size. Must be pure and cheap. */
+    canResizeEventTo?: (data: ScheduleCanResizeEventToData) => boolean;
+    /** If set, drops and resizes that would make the event overlap another event are rejected. Pass a function to decide per pair of events: return `true` to forbid the overlap. The function runs while dragging and resizing to compute live feedback, it must be pure and cheap. @default false */
+    preventEventOverlap?: PreventEventOverlap;
+    /** Called when a drop or resize is rejected */
+    onEventPlacementRejected?: (data: ScheduleEventPlacementRejectedData) => void;
     /** Snap step for resizing events, in minutes. Must divide evenly into an hour (e.g. `15`, `30`) or be a whole number of hours. When not set, `intervalMinutes` is used. @default intervalMinutes */
     eventResizeInterval?: number;
     /** Max number of generated recurring instances per recurring series @default 2000 */

package/lib/components/MonthView/MonthView.d.ts

@@ -1,6 +1,6 @@
 import { BoxProps, DataAttributes, ElementProps, Factory, MantineRadius, ScrollAreaProps, StylesApiProps } from '@mantine/core';
 import { ScheduleLabelsOverride } from '../../labels';
-import { DateLabelFormat, DateStringValue, DateTimeStringValue, DayOfWeek, ScheduleEventData, ScheduleMode, ScheduleViewLevel } from '../../types';
+import { DateLabelFormat, DateStringValue, DateTimeStringValue, DayOfWeek, PreventEventOverlap, ScheduleCanDropEventData, ScheduleCanDropExternalEventData, ScheduleEventData, ScheduleEventPlacementRejectedData, ScheduleMode, ScheduleViewLevel } from '../../types';
 import { AgendaViewStylesNames } from '../AgendaView/AgendaView';
 import { MoreEventsProps } from '../MoreEvents/MoreEvents';
 import { RenderEvent, RenderEventBody } from '../ScheduleEvent/ScheduleEvent';
@@ -80,6 +80,14 @@ export interface MonthViewProps extends BoxProps, StylesApiProps<MonthViewFactor
     }) => void;
     /** Function to determine if event can be dragged */
     canDragEvent?: (event: ScheduleEventData) => boolean;
+    /** Called while an event is dragged over a target to compute live feedback and again before the drop is committed, return `false` to reject the drop. Must be pure and cheap. */
+    canDropEvent?: (data: ScheduleCanDropEventData) => boolean;
+    /** Called while an external item is dragged over a target to compute live feedback and again before the drop is committed, return `false` to reject the drop. Must be pure and cheap. Only `dataTransfer.types` can be read while the drag is in progress. */
+    canDropExternalEvent?: (data: ScheduleCanDropExternalEventData) => boolean;
+    /** If set, drops that would make the event overlap another event are rejected. Pass a function to decide per pair of events: return `true` to forbid the overlap. The function runs while dragging to compute live feedback, it must be pure and cheap. @default false */
+    preventEventOverlap?: PreventEventOverlap;
+    /** Called when a drop is rejected */
+    onEventPlacementRejected?: (data: ScheduleEventPlacementRejectedData) => void;
     /** Called when any event drag starts */
     onEventDragStart?: (event: ScheduleEventData) => void;
     /** Called when any event drag ends */

package/lib/components/MonthView/get-month-view-events/reserve-row.d.ts

@@ -0,0 +1,7 @@
+interface ReserveRowInput {
+    nextRowByDay: number[];
+    startDayIndex: number;
+    daysSpanned: number;
+}
+export declare function reserveRow({ nextRowByDay, startDayIndex, daysSpanned }: ReserveRowInput): number;
+export {};

package/lib/components/ResourcesDayView/ResourcesDayView.d.ts

@@ -1,6 +1,6 @@
 import { BoxProps, DataAttributes, ElementProps, Factory, MantineRadius, ScrollAreaProps, StylesApiProps } from '@mantine/core';
 import { ScheduleLabelsOverride } from '../../labels';
-import { AnyDateValue, DateLabelFormat, DateStringValue, DateTimeStringValue, ScheduleEventData, ScheduleMode, ScheduleResourceData, ScheduleResourceGroup, ScheduleViewLevel } from '../../types';
+import { AnyDateValue, DateLabelFormat, DateStringValue, DateTimeStringValue, PreventEventOverlap, ScheduleCanDropEventData, ScheduleCanDropExternalEventData, ScheduleCanResizeEventToData, ScheduleEventData, ScheduleEventPlacementRejectedData, ScheduleMode, ScheduleResourceData, ScheduleResourceGroup, ScheduleViewLevel } from '../../types';
 import { MoreEventsProps, MoreEventsStylesNames } from '../MoreEvents/MoreEvents';
 import { RenderEvent, RenderEventBody } from '../ScheduleEvent/ScheduleEvent';
 import { CombinedScheduleHeaderStylesNames } from '../ScheduleHeader/ScheduleHeader';
@@ -135,6 +135,16 @@ export interface ResourcesDayViewProps extends BoxProps, StylesApiProps<Resource
     }) => void;
     /** Function to determine if event can be resized */
     canResizeEvent?: (event: ScheduleEventData) => boolean;
+    /** Called while an event is dragged over a target to compute live feedback and again before the drop is committed, return `false` to reject the drop. Must be pure and cheap. */
+    canDropEvent?: (data: ScheduleCanDropEventData) => boolean;
+    /** Called while an external item is dragged over a target to compute live feedback and again before the drop is committed, return `false` to reject the drop. Must be pure and cheap. Only `dataTransfer.types` can be read while the drag is in progress. */
+    canDropExternalEvent?: (data: ScheduleCanDropExternalEventData) => boolean;
+    /** Called on every pointer move while an event is resized to compute live feedback and again before the resize is committed, return `false` to reject the new size. Must be pure and cheap. */
+    canResizeEventTo?: (data: ScheduleCanResizeEventToData) => boolean;
+    /** If set, drops and resizes that would make the event overlap another event are rejected. Pass a function to decide per pair of events: return `true` to forbid the overlap. The function runs while dragging and resizing to compute live feedback, it must be pure and cheap. @default false */
+    preventEventOverlap?: PreventEventOverlap;
+    /** Called when a drop or resize is rejected */
+    onEventPlacementRejected?: (data: ScheduleEventPlacementRejectedData) => void;
     /** Snap step for resizing events, in minutes. Must divide evenly into an hour (e.g. `15`, `30`) or be a whole number of hours. When not set, `intervalMinutes` is used. @default intervalMinutes */
     eventResizeInterval?: number;
     /** Max number of generated recurring instances per recurring series @default 2000 */

package/lib/components/ResourcesMonthView/ResourcesMonthView.d.ts

@@ -1,6 +1,6 @@
 import { BoxProps, DataAttributes, ElementProps, Factory, MantineRadius, ScrollAreaProps, StylesApiProps } from '@mantine/core';
 import { ScheduleLabelsOverride } from '../../labels';
-import { DateLabelFormat, DateStringValue, DateTimeStringValue, DayOfWeek, ScheduleEventData, ScheduleMode, ScheduleResourceData, ScheduleResourceGroup, ScheduleViewLevel } from '../../types';
+import { DateLabelFormat, DateStringValue, DateTimeStringValue, DayOfWeek, PreventEventOverlap, ScheduleCanDropEventData, ScheduleCanDropExternalEventData, ScheduleCanResizeEventToData, ScheduleEventData, ScheduleEventPlacementRejectedData, ScheduleMode, ScheduleResourceData, ScheduleResourceGroup, ScheduleViewLevel } from '../../types';
 import { MoreEventsProps, MoreEventsStylesNames } from '../MoreEvents/MoreEvents';
 import { RenderEvent, RenderEventBody } from '../ScheduleEvent/ScheduleEvent';
 import { MonthYearSelectProps } from '../ScheduleHeader/MonthYearSelect/MonthYearSelect';
@@ -97,6 +97,16 @@ export interface ResourcesMonthViewProps extends BoxProps, StylesApiProps<Resour
     }) => void;
     /** Function to determine if event can be resized */
     canResizeEvent?: (event: ScheduleEventData) => boolean;
+    /** Called while an event is dragged over a target to compute live feedback and again before the drop is committed, return `false` to reject the drop. Must be pure and cheap. */
+    canDropEvent?: (data: ScheduleCanDropEventData) => boolean;
+    /** Called while an external item is dragged over a target to compute live feedback and again before the drop is committed, return `false` to reject the drop. Must be pure and cheap. Only `dataTransfer.types` can be read while the drag is in progress. */
+    canDropExternalEvent?: (data: ScheduleCanDropExternalEventData) => boolean;
+    /** Called on every pointer move while an event is resized to compute live feedback and again before the resize is committed, return `false` to reject the new size. Must be pure and cheap. */
+    canResizeEventTo?: (data: ScheduleCanResizeEventToData) => boolean;
+    /** If set, drops and resizes that would make the event overlap another event are rejected. Pass a function to decide per pair of events: return `true` to forbid the overlap. The function runs while dragging and resizing to compute live feedback, it must be pure and cheap. @default false */
+    preventEventOverlap?: PreventEventOverlap;
+    /** Called when a drop or resize is rejected */
+    onEventPlacementRejected?: (data: ScheduleEventPlacementRejectedData) => void;
     /** Called when event is clicked */
     onEventClick?: (event: ScheduleEventData, e: React.MouseEvent<HTMLButtonElement>) => void;
     /** If set, enables drag-to-select day ranges @default false */

package/lib/components/ResourcesSchedule/ResourcesSchedule.d.ts

@@ -1,13 +1,13 @@
 import { BoxProps, ElementProps, Factory, MantineRadius, StylesApiProps } from '@mantine/core';
 import { ScheduleLabelsOverride } from '../../labels';
-import { DateStringValue, DateTimeStringValue, ScheduleEventData, ScheduleMode, ScheduleResourceData } from '../../types';
+import { DateStringValue, DateTimeStringValue, PreventEventOverlap, ScheduleCanDropEventData, ScheduleCanDropExternalEventData, ScheduleCanResizeEventToData, ScheduleEventData, ScheduleEventPlacementRejectedData, ScheduleMode, ScheduleResourceData } from '../../types';
 import { ResourcesDayViewProps, ResourcesDayViewStylesNames } from '../ResourcesDayView/ResourcesDayView';
 import { ResourcesMonthViewProps, ResourcesMonthViewStylesNames } from '../ResourcesMonthView/ResourcesMonthView';
 import { ResourcesWeekViewProps, ResourcesWeekViewStylesNames } from '../ResourcesWeekView/ResourcesWeekView';
 import { RenderEventBody } from '../ScheduleEvent/ScheduleEvent';
 export type ResourcesScheduleStylesNames = 'root' | ResourcesDayViewStylesNames | ResourcesWeekViewStylesNames | ResourcesMonthViewStylesNames;
 export type ResourcesScheduleViewLevel = 'day' | 'week' | 'month';
-type ResourcesScheduleCommonProps = 'date' | 'onDateChange' | 'resources' | 'events' | 'locale' | 'radius' | 'labels' | 'renderEventBody' | 'renderResourceLabel' | 'withEventsDragAndDrop' | 'onEventDrop' | 'canDragEvent' | 'onEventDragStart' | 'onEventDragEnd' | 'onTimeSlotClick' | 'onEventClick' | 'onDayClick' | 'withDragSlotSelect' | 'onSlotDragEnd' | 'view' | 'onViewChange' | 'mode' | 'onExternalEventDrop' | 'withEventResize' | 'onEventResize' | 'canResizeEvent' | 'recurrenceExpansionLimit' | 'withInteractiveBackgroundEvents';
+type ResourcesScheduleCommonProps = 'date' | 'onDateChange' | 'resources' | 'events' | 'locale' | 'radius' | 'labels' | 'renderEventBody' | 'renderResourceLabel' | 'withEventsDragAndDrop' | 'onEventDrop' | 'canDragEvent' | 'onEventDragStart' | 'onEventDragEnd' | 'onTimeSlotClick' | 'onEventClick' | 'onDayClick' | 'withDragSlotSelect' | 'onSlotDragEnd' | 'view' | 'onViewChange' | 'mode' | 'onExternalEventDrop' | 'withEventResize' | 'onEventResize' | 'canResizeEvent' | 'canDropEvent' | 'canDropExternalEvent' | 'canResizeEventTo' | 'preventEventOverlap' | 'onEventPlacementRejected' | 'recurrenceExpansionLimit' | 'withInteractiveBackgroundEvents';
 type ResourcesScheduleViewProps<T> = Partial<Omit<T, ResourcesScheduleCommonProps>>;
 export interface ResourcesScheduleProps extends BoxProps, StylesApiProps<ResourcesScheduleFactory>, ElementProps<'div'> {
     __staticSelector?: string;
@@ -95,6 +95,16 @@ export interface ResourcesScheduleProps extends BoxProps, StylesApiProps<Resourc
     }) => void;
     /** Function to determine if event can be resized */
     canResizeEvent?: (event: ScheduleEventData) => boolean;
+    /** Called while an event is dragged over a target to compute live feedback and again before the drop is committed, return `false` to reject the drop. Must be pure and cheap. */
+    canDropEvent?: (data: ScheduleCanDropEventData) => boolean;
+    /** Called while an external item is dragged over a target to compute live feedback and again before the drop is committed, return `false` to reject the drop. Must be pure and cheap. Only `dataTransfer.types` can be read while the drag is in progress. */
+    canDropExternalEvent?: (data: ScheduleCanDropExternalEventData) => boolean;
+    /** Called on every pointer move while an event is resized to compute live feedback and again before the resize is committed, return `false` to reject the new size. Must be pure and cheap. */
+    canResizeEventTo?: (data: ScheduleCanResizeEventToData) => boolean;
+    /** If set, drops and resizes that would make the event overlap another event are rejected. Pass a function to decide per pair of events: return `true` to forbid the overlap. The function runs while dragging and resizing to compute live feedback, it must be pure and cheap. @default false */
+    preventEventOverlap?: PreventEventOverlap;
+    /** Called when a drop or resize is rejected */
+    onEventPlacementRejected?: (data: ScheduleEventPlacementRejectedData) => void;
     /** If set, background events (`display: 'background'`) can be clicked and trigger `onEventClick`. Applies to `day` and `week` views only – `ResourcesMonthView` does not render background events separately. Combined with `withEventResize`, timed background events can also be resized by dragging their edges. @default false */
     withInteractiveBackgroundEvents?: boolean;
     /** Max number of generated recurring instances @default 2000 */

package/lib/components/ResourcesWeekView/ResourcesWeekView.d.ts

@@ -1,6 +1,6 @@
 import { BoxProps, DataAttributes, ElementProps, Factory, MantineRadius, ScrollAreaProps, StylesApiProps } from '@mantine/core';
 import { ScheduleLabelsOverride } from '../../labels';
-import { AnyDateValue, DateLabelFormat, DateStringValue, DateTimeStringValue, DayOfWeek, ScheduleEventData, ScheduleMode, ScheduleResourceData, ScheduleResourceGroup, ScheduleViewLevel } from '../../types';
+import { AnyDateValue, DateLabelFormat, DateStringValue, DateTimeStringValue, DayOfWeek, PreventEventOverlap, ScheduleCanDropEventData, ScheduleCanDropExternalEventData, ScheduleCanResizeEventToData, ScheduleEventData, ScheduleEventPlacementRejectedData, ScheduleMode, ScheduleResourceData, ScheduleResourceGroup, ScheduleViewLevel } from '../../types';
 import { MoreEventsProps, MoreEventsStylesNames } from '../MoreEvents/MoreEvents';
 import { RenderEvent, RenderEventBody } from '../ScheduleEvent/ScheduleEvent';
 import { CombinedScheduleHeaderStylesNames } from '../ScheduleHeader/ScheduleHeader';
@@ -101,6 +101,16 @@ export interface ResourcesWeekViewProps extends BoxProps, StylesApiProps<Resourc
     }) => void;
     /** Function to determine if event can be resized */
     canResizeEvent?: (event: ScheduleEventData) => boolean;
+    /** Called while an event is dragged over a target to compute live feedback and again before the drop is committed, return `false` to reject the drop. Must be pure and cheap. */
+    canDropEvent?: (data: ScheduleCanDropEventData) => boolean;
+    /** Called while an external item is dragged over a target to compute live feedback and again before the drop is committed, return `false` to reject the drop. Must be pure and cheap. Only `dataTransfer.types` can be read while the drag is in progress. */
+    canDropExternalEvent?: (data: ScheduleCanDropExternalEventData) => boolean;
+    /** Called on every pointer move while an event is resized to compute live feedback and again before the resize is committed, return `false` to reject the new size. Must be pure and cheap. */
+    canResizeEventTo?: (data: ScheduleCanResizeEventToData) => boolean;
+    /** If set, drops and resizes that would make the event overlap another event are rejected. Pass a function to decide per pair of events: return `true` to forbid the overlap. The function runs while dragging and resizing to compute live feedback, it must be pure and cheap. @default false */
+    preventEventOverlap?: PreventEventOverlap;
+    /** Called when a drop or resize is rejected */
+    onEventPlacementRejected?: (data: ScheduleEventPlacementRejectedData) => void;
     /** Snap step for resizing events, in minutes. Must divide evenly into an hour (e.g. `15`, `30`) or be a whole number of hours. When not set, `intervalMinutes` is used. @default intervalMinutes */
     eventResizeInterval?: number;
     recurrenceExpansionLimit?: number;

package/lib/components/Schedule/Schedule.d.ts

@@ -1,6 +1,6 @@
 import { BoxProps, ElementProps, Factory, MantineRadius, StylesApiProps } from '@mantine/core';
 import { ScheduleLabelsOverride } from '../../labels';
-import { DateStringValue, DateTimeStringValue, ScheduleEventData, ScheduleMode, ScheduleViewLevel } from '../../types';
+import { DateStringValue, DateTimeStringValue, PreventEventOverlap, ScheduleCanDropEventData, ScheduleCanDropExternalEventData, ScheduleCanResizeEventToData, ScheduleEventData, ScheduleEventPlacementRejectedData, ScheduleMode, ScheduleViewLevel } from '../../types';
 import { DayViewProps, DayViewStylesNames } from '../DayView/DayView';
 import { MobileMonthViewProps, MobileMonthViewStylesNames } from '../MobileMonthView/MobileMonthView';
 import { MonthViewProps, MonthViewStylesNames } from '../MonthView/MonthView';
@@ -9,7 +9,7 @@ import { WeekViewProps, WeekViewStylesNames } from '../WeekView/WeekView';
 import { YearViewProps, YearViewStylesNames } from '../YearView/YearView';
 export type ScheduleStylesNames = 'root' | 'desktopView' | 'mobileView' | DayViewStylesNames | WeekViewStylesNames | MonthViewStylesNames | YearViewStylesNames | MobileMonthViewStylesNames;
 export type ScheduleLayout = 'default' | 'responsive';
-type ScheduleCommonProps = 'date' | 'onDateChange' | 'events' | 'locale' | 'radius' | 'labels' | 'renderEventBody' | 'withEventsDragAndDrop' | 'onEventDrop' | 'canDragEvent' | 'onEventDragStart' | 'onEventDragEnd' | 'onTimeSlotClick' | 'onAllDaySlotClick' | 'onEventClick' | 'onDayClick' | 'onMonthClick' | 'withDragSlotSelect' | 'onSlotDragEnd' | 'view' | 'onViewChange' | 'mode' | 'withAgenda' | 'onExternalEventDrop' | 'withEventResize' | 'onEventResize' | 'canResizeEvent' | 'recurrenceExpansionLimit' | 'withInteractiveBackgroundEvents';
+type ScheduleCommonProps = 'date' | 'onDateChange' | 'events' | 'locale' | 'radius' | 'labels' | 'renderEventBody' | 'withEventsDragAndDrop' | 'onEventDrop' | 'canDragEvent' | 'onEventDragStart' | 'onEventDragEnd' | 'onTimeSlotClick' | 'onAllDaySlotClick' | 'onEventClick' | 'onDayClick' | 'onMonthClick' | 'withDragSlotSelect' | 'onSlotDragEnd' | 'view' | 'onViewChange' | 'mode' | 'withAgenda' | 'onExternalEventDrop' | 'withEventResize' | 'onEventResize' | 'canResizeEvent' | 'canDropEvent' | 'canDropExternalEvent' | 'canResizeEventTo' | 'preventEventOverlap' | 'onEventPlacementRejected' | 'recurrenceExpansionLimit' | 'withInteractiveBackgroundEvents';
 type ScheduleViewProps<T> = Partial<Omit<T, ScheduleCommonProps>>;
 export interface ScheduleProps extends BoxProps, StylesApiProps<ScheduleFactory>, ElementProps<'div'> {
     __staticSelector?: string;
@@ -84,6 +84,16 @@ export interface ScheduleProps extends BoxProps, StylesApiProps<ScheduleFactory>
     }) => void;
     /** Function to determine if event can be resized */
     canResizeEvent?: (event: ScheduleEventData) => boolean;
+    /** Called while an event is dragged over a target to compute live feedback and again before the drop is committed, return `false` to reject the drop. Must be pure and cheap. */
+    canDropEvent?: (data: ScheduleCanDropEventData) => boolean;
+    /** Called while an external item is dragged over a target to compute live feedback and again before the drop is committed, return `false` to reject the drop. Must be pure and cheap. Only `dataTransfer.types` can be read while the drag is in progress. */
+    canDropExternalEvent?: (data: ScheduleCanDropExternalEventData) => boolean;
+    /** Called on every pointer move while an event is resized to compute live feedback and again before the resize is committed, return `false` to reject the new size. Must be pure and cheap. */
+    canResizeEventTo?: (data: ScheduleCanResizeEventToData) => boolean;
+    /** If set, drops and resizes that would make the event overlap another event are rejected. Pass a function to decide per pair of events: return `true` to forbid the overlap. The function runs while dragging and resizing to compute live feedback, it must be pure and cheap. @default false */
+    preventEventOverlap?: PreventEventOverlap;
+    /** Called when a drop or resize is rejected */
+    onEventPlacementRejected?: (data: ScheduleEventPlacementRejectedData) => void;
     /** If set, background events (`display: 'background'`) can be clicked and trigger `onEventClick`. Applies to `day`, `week` and `month` views only – `YearView` and the `MobileMonthView` used by `layout="responsive"` on small screens do not render background events at all. Combined with `withEventResize`, timed background events in `day` and `week` views can also be resized by dragging their edges. @default false */
     withInteractiveBackgroundEvents?: boolean;
     /** Max number of generated recurring instances per recurring series @default 2000 */

package/lib/components/WeekView/WeekView.d.ts

@@ -1,6 +1,6 @@
 import { BoxProps, DataAttributes, ElementProps, Factory, MantineRadius, ScrollAreaAutosizeProps, StylesApiProps } from '@mantine/core';
 import { ScheduleLabelsOverride } from '../../labels';
-import { AnyDateValue, DateLabelFormat, DateStringValue, DateTimeStringValue, DayOfWeek, ScheduleEventData, ScheduleEventOverlapMode, ScheduleMode, ScheduleViewLevel } from '../../types';
+import { AnyDateValue, DateLabelFormat, DateStringValue, DateTimeStringValue, DayOfWeek, PreventEventOverlap, ScheduleCanDropEventData, ScheduleCanDropExternalEventData, ScheduleCanResizeEventToData, ScheduleEventData, ScheduleEventOverlapMode, ScheduleEventPlacementRejectedData, ScheduleMode, ScheduleViewLevel } from '../../types';
 import { BusinessHoursValue } from '../../utils';
 import { AgendaViewStylesNames } from '../AgendaView/AgendaView';
 import { CurrentTimeIndicatorStylesNames } from '../CurrentTimeIndicator/CurrentTimeIndicator';
@@ -144,6 +144,16 @@ export interface WeekViewProps extends BoxProps, StylesApiProps<WeekViewFactory>
     }) => void;
     /** Function to determine if event can be resized */
     canResizeEvent?: (event: ScheduleEventData) => boolean;
+    /** Called while an event is dragged over a target to compute live feedback and again before the drop is committed, return `false` to reject the drop. Must be pure and cheap. */
+    canDropEvent?: (data: ScheduleCanDropEventData) => boolean;
+    /** Called while an external item is dragged over a target to compute live feedback and again before the drop is committed, return `false` to reject the drop. Must be pure and cheap. Only `dataTransfer.types` can be read while the drag is in progress. */
+    canDropExternalEvent?: (data: ScheduleCanDropExternalEventData) => boolean;
+    /** Called on every pointer move while an event is resized to compute live feedback and again before the resize is committed, return `false` to reject the new size. Must be pure and cheap. */
+    canResizeEventTo?: (data: ScheduleCanResizeEventToData) => boolean;
+    /** If set, drops and resizes that would make the event overlap another event are rejected. Pass a function to decide per pair of events: return `true` to forbid the overlap. The function runs while dragging and resizing to compute live feedback, it must be pure and cheap. @default false */
+    preventEventOverlap?: PreventEventOverlap;
+    /** Called when a drop or resize is rejected */
+    onEventPlacementRejected?: (data: ScheduleEventPlacementRejectedData) => void;
     /** Snap step for resizing events, in minutes. Must divide evenly into an hour (e.g. `15`, `30`) or be a whole number of hours. When not set, `intervalMinutes` is used. @default intervalMinutes */
     eventResizeInterval?: number;
     /** Max number of generated recurring instances per recurring series @default 2000 */

package/lib/hooks/use-day-grid-event-resize.d.ts

@@ -1,6 +1,7 @@
 import { DateStringValue, DateTimeStringValue, ScheduleEventData, ScheduleMode } from '../types';
 import { MonthResizeEdge } from '../utils/calculate-month-resize-dates/calculate-month-resize-dates';
-export interface UseDayGridEventResizeInput {
+import { EventResizeValidationOptions } from './validate-event-resize';
+export interface UseDayGridEventResizeInput extends EventResizeValidationOptions {
     enabled?: boolean;
     mode?: ScheduleMode;
     onEventResize?: (data: {
@@ -23,7 +24,7 @@ export interface DayGridResizeStartInput {
  * The target day is resolved by hit-testing `cells` with the pointer position, so
  * the hook works for any layout that renders one element per day in a single row.
  */
-export declare function useDayGridEventResize({ enabled, mode, onEventResize, canResizeEvent, }: UseDayGridEventResizeInput): {
+export declare function useDayGridEventResize({ enabled, mode, onEventResize, canResizeEvent, events, preventEventOverlap, canResizeEventTo, onEventPlacementRejected, }: UseDayGridEventResizeInput): {
     handleResizeStart: ({ event, edge, cells, days, pointerEvent }: DayGridResizeStartInput) => void;
     isResizing: boolean;
     resizingEventId: string | number | null;
@@ -32,4 +33,5 @@ export declare function useDayGridEventResize({ enabled, mode, onEventResize, ca
     previewEnd: string | null;
     isResizableEvent: (event: ScheduleEventData) => boolean;
     wasResizing: () => boolean;
+    resizeValid: boolean;
 };

package/lib/hooks/use-drag-drop-handlers.d.ts

@@ -1,5 +1,5 @@
 import { DragContextValue } from '../components/DragContext/DragContext';
-import { DateTimeStringValue, ScheduleEventData, ScheduleMode } from '../types';
+import { DateTimeStringValue, PreventEventOverlap, ScheduleCanDropEventData, ScheduleCanDropExternalEventData, ScheduleEventData, ScheduleEventPlacementRejectedData, ScheduleMode } from '../types';
 export interface DragPreview<T = any> {
     start: DateTimeStringValue;
     end: DateTimeStringValue;
@@ -33,6 +33,20 @@ export interface UseDragDropHandlersOptions<T = any> {
     };
     /** Called when an external item is dropped onto the schedule */
     onExternalDrop?: (e: React.DragEvent, target: T) => void;
+    /** Events the candidate range is checked against when `preventEventOverlap` is set */
+    events?: ScheduleEventData[];
+    /** If set, drops that would make the event overlap another event are rejected */
+    preventEventOverlap?: PreventEventOverlap;
+    /** Called on every `dragover` to compute live feedback and again before the drop is committed, return `false` to reject the drop */
+    canDropEvent?: (data: ScheduleCanDropEventData) => boolean;
+    /** Called on every `dragover` of an external item to compute live feedback and again before the drop is committed, return `false` to reject the drop */
+    canDropExternalEvent?: (data: ScheduleCanDropExternalEventData) => boolean;
+    /** Called when a drop is rejected */
+    onEventPlacementRejected?: (data: ScheduleEventPlacementRejectedData) => void;
+    /** Resolves the target resource from the drop target, used by `Resources*` views */
+    getTargetResourceId?: (target: T) => string | number | undefined;
+    /** Resolves the datetime an external item would be dropped at, `null` when the target has no datetime */
+    getExternalDropDateTime?: (target: T) => DateTimeStringValue | null;
 }
 export interface DragDropHandlers<T = any> {
     /** Context value for DragContext.Provider */
@@ -57,6 +71,8 @@ export interface DragDropHandlers<T = any> {
     dragPreview: DragPreview<T> | null;
     /** Sets the current drag preview */
     setDragPreview: (preview: DragPreview<T> | null) => void;
+    /** False while the pointer is over a target that would be rejected */
+    dropValid: boolean;
 }
 /**
  * Hook that provides unified drag-drop handlers for Schedule views.

package/lib/hooks/use-event-resize.d.ts

@@ -1,6 +1,7 @@
 import { DateTimeStringValue, ScheduleEventData, ScheduleMode } from '../types';
+import { EventResizeValidationOptions } from './validate-event-resize';
 type ResizeEdge = 'top' | 'bottom';
-export interface UseEventResizeInput {
+export interface UseEventResizeInput extends EventResizeValidationOptions {
     enabled?: boolean;
     mode?: ScheduleMode;
     startTime: string;
@@ -16,7 +17,7 @@ export interface UseEventResizeInput {
     canResizeEvent?: (event: ScheduleEventData) => boolean;
     withBackgroundEvents?: boolean;
 }
-export declare function useEventResize({ enabled, mode, startTime, endTime, intervalMinutes, resizeIntervalMinutes, onEventResize, canResizeEvent, withBackgroundEvents, }: UseEventResizeInput): {
+export declare function useEventResize({ enabled, mode, startTime, endTime, intervalMinutes, resizeIntervalMinutes, onEventResize, canResizeEvent, events, preventEventOverlap, canResizeEventTo, onEventPlacementRejected, withBackgroundEvents, }: UseEventResizeInput): {
     handleResizeStart: ({ event, edge, container, originalTop, originalHeight, eventDate, pointerEvent, }: {
         event: ScheduleEventData;
         edge: ResizeEdge;
@@ -34,5 +35,6 @@ export declare function useEventResize({ enabled, mode, startTime, endTime, inte
     } | null;
     isResizableEvent: (event: ScheduleEventData) => boolean;
     wasResizing: () => boolean;
+    resizeValid: boolean;
 };
 export {};

package/lib/hooks/use-horizontal-event-resize.d.ts

@@ -1,6 +1,7 @@
 import { DateTimeStringValue, ScheduleEventData, ScheduleMode } from '../types';
+import { EventResizeValidationOptions } from './validate-event-resize';
 type ResizeEdge = 'start' | 'end';
-export interface UseHorizontalEventResizeInput {
+export interface UseHorizontalEventResizeInput extends EventResizeValidationOptions {
     enabled?: boolean;
     mode?: ScheduleMode;
     startTime: string;
@@ -16,7 +17,7 @@ export interface UseHorizontalEventResizeInput {
     canResizeEvent?: (event: ScheduleEventData) => boolean;
     withBackgroundEvents?: boolean;
 }
-export declare function useHorizontalEventResize({ enabled, mode, startTime, endTime, intervalMinutes, resizeIntervalMinutes, onEventResize, canResizeEvent, withBackgroundEvents, }: UseHorizontalEventResizeInput): {
+export declare function useHorizontalEventResize({ enabled, mode, startTime, endTime, intervalMinutes, resizeIntervalMinutes, onEventResize, canResizeEvent, events, preventEventOverlap, canResizeEventTo, onEventPlacementRejected, withBackgroundEvents, }: UseHorizontalEventResizeInput): {
     handleResizeStart: ({ event, edge, container, originalLeft, originalWidth, eventDate, dayIndex, dayCount, pointerEvent, }: {
         event: ScheduleEventData;
         edge: ResizeEdge;
@@ -37,5 +38,6 @@ export declare function useHorizontalEventResize({ enabled, mode, startTime, end
     } | null;
     isResizableEvent: (event: ScheduleEventData) => boolean;
     wasResizing: () => boolean;
+    resizeValid: boolean;
 };
 export {};

package/lib/hooks/validate-event-resize.d.ts

@@ -0,0 +1,33 @@
+import { DateTimeStringValue, PreventEventOverlap, ScheduleCanResizeEventToData, ScheduleEventData } from '../types';
+export interface EventResizeValidationOptions {
+    /** Events the candidate range is checked against when `preventEventOverlap` is set */
+    events?: ScheduleEventData[];
+    /** If set, resizes that would make the event overlap another event are rejected */
+    preventEventOverlap?: PreventEventOverlap;
+    /** Called on every pointer move to compute live feedback and again before the resize is committed, return `false` to reject the new size */
+    canResizeEventTo?: (data: ScheduleCanResizeEventToData) => boolean;
+    /** Called when a resize is rejected */
+    onEventPlacementRejected?: (data: {
+        action: 'resize';
+        event: ScheduleEventData;
+        start: DateTimeStringValue;
+        end: DateTimeStringValue;
+        edge: 'start' | 'end';
+        resourceId?: string | number;
+        conflicts: ScheduleEventData[];
+        reason: 'overlap' | 'rejected';
+    }) => void;
+}
+export interface ValidateEventResizeInput extends EventResizeValidationOptions {
+    event: ScheduleEventData;
+    start: DateTimeStringValue;
+    end: DateTimeStringValue;
+    edge: 'start' | 'end';
+    resourceId?: string | number;
+}
+export interface ValidateEventResizeResult {
+    valid: boolean;
+    conflicts: ScheduleEventData[];
+    reason: 'overlap' | 'rejected' | null;
+}
+export declare function validateEventResize({ event, start, end, edge, events, preventEventOverlap, canResizeEventTo, resourceId, }: ValidateEventResizeInput): ValidateEventResizeResult;

package/lib/types.d.ts

@@ -160,4 +160,69 @@ export interface DropTarget {
     /** Target slot index (for DayView/WeekView) */
     slotIndex?: number;
 }
+/** Controls whether a drop or resize that would overlap another event is rejected */
+export type PreventEventOverlap = boolean | ((stillEvent: ScheduleEventData, movingEvent: ScheduleEventData) => boolean);
+/** Data passed to `canDropEvent` while an event is dragged over a target and again before the drop is committed */
+export interface ScheduleCanDropEventData {
+    /** Event that is being dragged */
+    event: ScheduleEventData;
+    /** Candidate start of the event */
+    start: DateTimeStringValue;
+    /** Candidate end of the event */
+    end: DateTimeStringValue;
+    /** Target resource, only in `Resources*` views */
+    resourceId?: string | number;
+}
+/** Data passed to `canDropExternalEvent` while an external item is dragged over a target and again before the drop is committed */
+export interface ScheduleCanDropExternalEventData {
+    /** Data transfer of the drag event */
+    dataTransfer: DataTransfer;
+    /** Datetime the external item is dropped at */
+    start: DateTimeStringValue;
+    /** Target resource, only in `Resources*` views */
+    resourceId?: string | number;
+}
+/** Data passed to `canResizeEventTo` on every pointer move while an event is resized and again before the resize is committed */
+export interface ScheduleCanResizeEventToData {
+    /** Event that is being resized */
+    event: ScheduleEventData;
+    /** Candidate start of the event */
+    start: DateTimeStringValue;
+    /** Candidate end of the event */
+    end: DateTimeStringValue;
+    /** Edge of the event that is being dragged */
+    edge: 'start' | 'end';
+}
+interface ScheduleEventPlacementRejectedBase {
+    /** Candidate start of the event, for `external-drop` the datetime the item was dropped at */
+    start: DateTimeStringValue;
+    /** Candidate end of the event, not present on `external-drop` */
+    end: DateTimeStringValue;
+    /** Events the placement collided with, empty when the rejection came from a callback */
+    conflicts: ScheduleEventData[];
+    /** `'overlap'` when `preventEventOverlap` found a conflict, `'rejected'` when a callback returned `false` */
+    reason: 'overlap' | 'rejected';
+    /** Only in `Resources*` views: the target resource for `drop` and `external-drop`, the resized event resource for `resize` */
+    resourceId?: string | number;
+}
+/** Data passed to `onEventPlacementRejected` when a drop, resize or external drop is rejected. External drops have no `end`: the schedule does not know the duration of an external item. */
+export type ScheduleEventPlacementRejectedData = (ScheduleEventPlacementRejectedBase & {
+    action: 'drop';
+    /** Event that was being dragged */
+    event: ScheduleEventData;
+}) | (ScheduleEventPlacementRejectedBase & {
+    action: 'resize';
+    /** Event that was being resized */
+    event: ScheduleEventData;
+    /** Edge of the event that was being dragged */
+    edge: 'start' | 'end';
+}) | (Omit<ScheduleEventPlacementRejectedBase, 'end'> & {
+    action: 'external-drop';
+    /** Data transfer of the drag event */
+    dataTransfer: DataTransfer;
+    /** Always `'rejected'`, `preventEventOverlap` does not apply to external drops */
+    reason: 'rejected';
+    /** Always empty, external drops carry no duration and are not checked for overlap */
+    conflicts: [];
+});
 export {};

package/lib/utils/index.d.ts

@@ -50,3 +50,5 @@ export { getDayRelativePercent } from './get-day-relative-percent/get-day-relati
 export { getOverlapClusters } from './get-overlap-clusters/get-overlap-clusters';
 export { applyCascadeLayout } from './apply-cascade-layout/apply-cascade-layout';
 export type { CascadePositionedEvent } from './apply-cascade-layout/apply-cascade-layout';
+export { isEventPlacementAllowed } from './is-event-placement-allowed/is-event-placement-allowed';
+export type { IsEventPlacementAllowedInput, IsEventPlacementAllowedResult, } from './is-event-placement-allowed/is-event-placement-allowed';