@mantine-vue/schedule 3.5.0 → 3.7.0

package/lib/component-props.d.ts

@@ -2,7 +2,7 @@ import type { CSSProperties, HTMLAttributes, VNodeChild } from 'vue';
 import type { EmitsToProps } from '@mantine-vue/core';
 import type { ViewSelectEmits, ViewSelectProps } from './components/ScheduleHeader/ViewSelect/ViewSelect.types';
 import type { ScheduleLabelsOverride } from './labels';
-import type { AnyDateValue, DateLabelFormat, DateStringValue, DateTimeStringValue, ScheduleEventData, ScheduleMode, ScheduleViewLevel } from './types';
+import type { AnyDateValue, DateLabelFormat, DateStringValue, DateTimeStringValue, PreventEventOverlap, ScheduleCanDropEventData, ScheduleCanDropExternalEventData, ScheduleCanResizeEventToData, ScheduleEventData, ScheduleEventPlacementRejectedData, ScheduleMode, ScheduleViewLevel } from './types';
 import type { BusinessHoursValue } from './utils';
 /**
  * Native attributes accepted by the header controls and the other button-like elements
@@ -177,6 +177,12 @@ export interface TimeViewOwnProps extends BaseViewOwnProps {
      * @default () => true
      */
     canDragEvent?: (event: ScheduleEventData) => boolean;
+    /** Returns false to reject a candidate internal event drop. */
+    canDropEvent?: (data: ScheduleCanDropEventData) => boolean;
+    /** Returns false to reject a candidate external drop. */
+    canDropExternalEvent?: (data: ScheduleCanDropExternalEventData) => boolean;
+    /** Rejects drops that overlap other events. */
+    preventEventOverlap?: PreventEventOverlap;
     /**
      * If set, dragging across time slots selects a range.
      * @default false
@@ -200,6 +206,8 @@ export interface TimeViewOwnProps extends BaseViewOwnProps {
      * @default () => true
      */
     canResizeEvent?: (event: ScheduleEventData) => boolean;
+    /** Returns false to reject a candidate resize. */
+    canResizeEventTo?: (data: ScheduleCanResizeEventToData) => boolean;
 }
 /**
  * Events emitted by every schedule view. Not a component of its own: `DayViewEmits`,
@@ -234,6 +242,8 @@ export interface TimeViewEmits extends BaseViewEmits {
     externalEventDrop: [dataTransfer: DataTransfer, dropDateTime: DateTimeStringValue];
     /** Emitted when an event is resized. */
     eventResize: [data: EventDropData];
+    /** Emitted when a drop or resize is rejected. */
+    eventPlacementRejected: [data: ScheduleEventPlacementRejectedData];
 }
 /** Scoped slots that mirror the `renderEvent` and `renderEventBody` props. */
 export interface EventSlots {

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

@@ -31,6 +31,7 @@ declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<DayVie
     slotDragEnd: (rangeStart: string, rangeEnd: string) => any;
     externalEventDrop: (dataTransfer: DataTransfer, dropDateTime: string) => any;
     eventResize: (data: import("../..").EventDropData) => any;
+    eventPlacementRejected: (data: import("../..").ScheduleEventPlacementRejectedData) => any;
 }, string, import("vue").PublicProps, Readonly<DayViewOwnProps> & Readonly<{
     onDateChange?: ((date: string) => any) | undefined;
     onEventDragStart?: ((event: ScheduleEventData) => any) | undefined;
@@ -43,6 +44,7 @@ declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<DayVie
     onSlotDragEnd?: ((rangeStart: string, rangeEnd: string) => any) | undefined;
     onExternalEventDrop?: ((dataTransfer: DataTransfer, dropDateTime: string) => any) | undefined;
     onEventResize?: ((data: import("../..").EventDropData) => any) | undefined;
+    onEventPlacementRejected?: ((data: import("../..").ScheduleEventPlacementRejectedData) => any) | undefined;
 }>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, import("../..").EventSlots>;
 type __VLS_WithSlots<T, S> = T & {
     new (): {

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

@@ -1,7 +1,7 @@
 import type { BoxProps, Factory, ScrollAreaProps } from '@mantine-vue/core';
 import type { StylesApiProps } from '@mantine-vue/core/styles-api';
 import type { BaseViewEmits, BaseViewOwnProps, EventDropData, EventSlots, ForwardedProps, NativeButtonProps } from '../../component-props';
-import type { DateLabelFormat, DateStringValue, DateTimeStringValue, DayOfWeek, ScheduleEventData } from '../../types';
+import type { DateLabelFormat, DateStringValue, DateTimeStringValue, DayOfWeek, ScheduleEventData, ScheduleEventPlacementRejectedData, ScheduleCanDropEventData, ScheduleCanDropExternalEventData, PreventEventOverlap } from '../../types';
 import type { MoreEventsEmits, MoreEventsProps, MoreEventsStylesNames } from '../MoreEvents/MoreEvents.types';
 import type { ScheduleEventStylesNames } from '../ScheduleEvent/ScheduleEvent.types';
 import type { CombinedScheduleHeaderStylesNames } from '../ScheduleHeader/ScheduleHeader.types';
@@ -78,6 +78,12 @@ export interface MonthViewOwnProps extends BaseViewOwnProps, StylesApiProps<Mont
      * @default () => true
      */
     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;
     /**
      * If set, items dragged in from outside the schedule can be dropped on a day, which emits
      * `externalEventDrop`. Enabling event drag and drop turns this on as well.
@@ -113,6 +119,8 @@ export interface MonthViewEmits extends BaseViewEmits {
     externalEventDrop: [dataTransfer: DataTransfer, date: DateStringValue];
     /** Emitted when a day range is selected by dragging. */
     slotDragEnd: [rangeStart: DateTimeStringValue, rangeEnd: DateTimeStringValue];
+    /** Emitted when a drop is rejected. */
+    eventPlacementRejected: [data: ScheduleEventPlacementRejectedData];
 }
 export type MonthViewFactory = Factory<{
     props: Omit<MonthViewProps, 'rootRef'>;

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

@@ -36,6 +36,7 @@ declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<MonthV
     eventDrop: (data: import("../..").EventDropData) => any;
     slotDragEnd: (rangeStart: string, rangeEnd: string) => any;
     externalEventDrop: (dataTransfer: DataTransfer, date: string) => any;
+    eventPlacementRejected: (data: import("../..").ScheduleEventPlacementRejectedData) => any;
     weekNumberClick: (date: string, nativeEvent: MouseEvent) => any;
 }, string, import("vue").PublicProps, Readonly<MonthViewOwnProps> & Readonly<{
     onDateChange?: ((date: string) => any) | undefined;
@@ -47,6 +48,7 @@ declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<MonthV
     onEventDrop?: ((data: import("../..").EventDropData) => any) | undefined;
     onSlotDragEnd?: ((rangeStart: string, rangeEnd: string) => any) | undefined;
     onExternalEventDrop?: ((dataTransfer: DataTransfer, date: string) => any) | undefined;
+    onEventPlacementRejected?: ((data: import("../..").ScheduleEventPlacementRejectedData) => any) | undefined;
     onWeekNumberClick?: ((date: string, nativeEvent: MouseEvent) => any) | undefined;
 }>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, import("../..").EventSlots>;
 type __VLS_WithSlots<T, S> = T & {

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.types.d.ts

@@ -3,7 +3,7 @@ import type { BoxProps, Factory, ScrollAreaProps } from '@mantine-vue/core';
 import type { StylesApiProps } from '@mantine-vue/core/styles-api';
 import type { EventDropData, EventSlots, ForwardedProps, NativeButtonProps, RenderEvent, RenderEventBody } from '../../component-props';
 import type { ScheduleLabelsOverride } from '../../labels';
-import type { AnyDateValue, DateLabelFormat, DateStringValue, DateTimeStringValue, ScheduleEventData, ScheduleMode, ScheduleResourceData, ScheduleResourceGroup, ScheduleViewLevel } from '../../types';
+import type { AnyDateValue, DateLabelFormat, DateStringValue, DateTimeStringValue, ScheduleEventData, ScheduleCanDropEventData, ScheduleCanDropExternalEventData, ScheduleCanResizeEventToData, ScheduleEventPlacementRejectedData, PreventEventOverlap, ScheduleMode, ScheduleResourceData, ScheduleResourceGroup, ScheduleViewLevel } from '../../types';
 import type { BusinessHoursValue } from '../../utils';
 import type { MoreEventsEmits, MoreEventsProps, MoreEventsStylesNames } from '../MoreEvents/MoreEvents.types';
 import type { ScheduleEventStylesNames } from '../ScheduleEvent/ScheduleEvent.types';
@@ -266,6 +266,14 @@ export interface ResourcesDayViewOwnProps extends StylesApiProps<ResourcesDayVie
      * @default () => true
      */
     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;
     /**
      * Maximum number of instances generated per recurring series.
      * @default 2000
@@ -302,6 +310,7 @@ export interface ResourcesDayViewEmits {
     externalEventDrop: [data: ResourceExternalDropData];
     /** Emitted when an event is resized. */
     eventResize: [data: EventDropData];
+    eventPlacementRejected: [data: ScheduleEventPlacementRejectedData];
 }
 export type ResourcesDayViewFactory = Factory<{
     props: Omit<ResourcesDayViewProps, 'rootRef'>;

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

@@ -34,6 +34,7 @@ declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<Resour
     slotDragEnd: (data: import("./ResourcesDayView.types").ResourceSlotDragEndData) => any;
     externalEventDrop: (data: import("./ResourcesDayView.types").ResourceExternalDropData) => any;
     eventResize: (data: import("../..").EventDropData) => any;
+    eventPlacementRejected: (data: import("../..").ScheduleEventPlacementRejectedData) => any;
 }, string, import("vue").PublicProps, Readonly<ResourcesDayViewOwnProps> & Readonly<{
     onDateChange?: ((date: string) => any) | undefined;
     onEventDragStart?: ((event: ScheduleEventData) => any) | undefined;
@@ -45,6 +46,7 @@ declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<Resour
     onSlotDragEnd?: ((data: import("./ResourcesDayView.types").ResourceSlotDragEndData) => any) | undefined;
     onExternalEventDrop?: ((data: import("./ResourcesDayView.types").ResourceExternalDropData) => any) | undefined;
     onEventResize?: ((data: import("../..").EventDropData) => any) | undefined;
+    onEventPlacementRejected?: ((data: import("../..").ScheduleEventPlacementRejectedData) => any) | undefined;
 }>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, ResourcesDayViewSlots>;
 type __VLS_WithSlots<T, S> = T & {
     new (): {

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

@@ -3,7 +3,7 @@ import type { BoxProps, Factory, ScrollAreaProps } from '@mantine-vue/core';
 import type { StylesApiProps } from '@mantine-vue/core/styles-api';
 import type { EventSlots, EventDropData, ForwardedProps, NativeButtonProps, RenderEvent, RenderEventBody } from '../../component-props';
 import type { ScheduleLabelsOverride } from '../../labels';
-import type { DateLabelFormat, DateStringValue, DayOfWeek, ScheduleEventData, ScheduleMode, ScheduleResourceData, ScheduleResourceGroup, ScheduleViewLevel } from '../../types';
+import type { DateLabelFormat, DateStringValue, DayOfWeek, ScheduleEventData, ScheduleCanDropEventData, ScheduleCanDropExternalEventData, ScheduleCanResizeEventToData, ScheduleEventPlacementRejectedData, PreventEventOverlap, ScheduleMode, ScheduleResourceData, ScheduleResourceGroup, ScheduleViewLevel } from '../../types';
 import type { MoreEventsEmits, MoreEventsProps, MoreEventsStylesNames } from '../MoreEvents/MoreEvents.types';
 import type { ScheduleEventStylesNames } from '../ScheduleEvent/ScheduleEvent.types';
 import type { CombinedScheduleHeaderStylesNames } from '../ScheduleHeader/ScheduleHeader.types';
@@ -170,6 +170,14 @@ export interface ResourcesMonthViewOwnProps extends StylesApiProps<ResourcesMont
     withEventResize?: boolean;
     /** Returns whether the given event may be resized. @default () => true */
     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;
     /**
      * If set, items dragged in from outside the schedule can be dropped on a day cell, which emits
      * `externalEventDrop`. Enabling event drag and drop turns this on as well.
@@ -227,6 +235,7 @@ export interface ResourcesMonthViewEmits {
     externalEventDrop: [data: ResourceExternalDropData];
     /** Emitted when an event resize gesture completes. */
     eventResize: [data: EventDropData];
+    eventPlacementRejected: [data: ScheduleEventPlacementRejectedData];
 }
 export type ResourcesMonthViewFactory = Factory<{
     props: Omit<ResourcesMonthViewProps, 'rootRef'>;

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

@@ -36,6 +36,7 @@ declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<Resour
     slotDragEnd: (data: import("../ResourcesDayView").ResourceSlotDragEndData) => any;
     externalEventDrop: (data: import("../ResourcesDayView").ResourceExternalDropData) => any;
     eventResize: (data: import("../..").EventDropData) => any;
+    eventPlacementRejected: (data: import("../..").ScheduleEventPlacementRejectedData) => any;
 }, string, import("vue").PublicProps, Readonly<ResourcesMonthViewOwnProps> & Readonly<{
     onDateChange?: ((date: string) => any) | undefined;
     onDayClick?: ((data: import("./ResourcesMonthView.types").ResourcesMonthViewDayClickData) => any) | undefined;
@@ -47,6 +48,7 @@ declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<Resour
     onSlotDragEnd?: ((data: import("../ResourcesDayView").ResourceSlotDragEndData) => any) | undefined;
     onExternalEventDrop?: ((data: import("../ResourcesDayView").ResourceExternalDropData) => any) | undefined;
     onEventResize?: ((data: import("../..").EventDropData) => any) | undefined;
+    onEventPlacementRejected?: ((data: import("../..").ScheduleEventPlacementRejectedData) => any) | undefined;
 }>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, ResourcesMonthViewSlots>;
 type __VLS_WithSlots<T, S> = T & {
     new (): {

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

@@ -3,7 +3,7 @@ import type { BoxProps, Factory } from '@mantine-vue/core';
 import type { StylesApiProps } from '@mantine-vue/core/styles-api';
 import type { EventDropData, EventSlots, RenderEventBody } from '../../component-props';
 import type { ScheduleLabelsOverride } from '../../labels';
-import type { DateStringValue, ScheduleEventData, ScheduleMode, ScheduleResourceData, ScheduleResourceGroup } from '../../types';
+import type { DateStringValue, ScheduleEventData, ScheduleCanDropEventData, ScheduleCanDropExternalEventData, ScheduleCanResizeEventToData, ScheduleEventPlacementRejectedData, PreventEventOverlap, ScheduleMode, ScheduleResourceData, ScheduleResourceGroup } from '../../types';
 import type { ResourceExternalDropData, ResourceSlotDragEndData, ResourceTimeSlotClickData, ResourceViewDropData, ResourcesDayViewProps, ResourcesDayViewStylesNames } from '../ResourcesDayView/ResourcesDayView.types';
 import type { ResourcesMonthViewDayClickData, ResourcesMonthViewProps, ResourcesMonthViewStylesNames } from '../ResourcesMonthView/ResourcesMonthView.types';
 import type { ResourcesWeekViewProps, ResourcesWeekViewStylesNames } from '../ResourcesWeekView/ResourcesWeekView.types';
@@ -106,6 +106,14 @@ export interface ResourcesScheduleOwnProps extends StylesApiProps<ResourcesSched
      * @default () => true
      */
     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;
     /** If set, background events can be focused and clicked in day and week views. */
     withInteractiveBackgroundEvents?: boolean;
     /**
@@ -149,6 +157,7 @@ export interface ResourcesScheduleEmits {
     externalEventDrop: [data: ResourceExternalDropData];
     /** Emitted when an event is resized. */
     eventResize: [data: EventDropData];
+    eventPlacementRejected: [data: ScheduleEventPlacementRejectedData];
 }
 export type ResourcesScheduleFactory = Factory<{
     props: Omit<ResourcesScheduleProps, 'rootRef'>;

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

@@ -21,6 +21,7 @@ declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<Resour
     slotDragEnd: (data: import("../ResourcesDayView").ResourceSlotDragEndData) => any;
     externalEventDrop: (data: import("../ResourcesDayView").ResourceExternalDropData) => any;
     eventResize: (data: import("../..").EventDropData) => any;
+    eventPlacementRejected: (data: import("../..").ScheduleEventPlacementRejectedData) => any;
     "update:view": (view: ResourcesScheduleViewLevel) => any;
 }, string, import("vue").PublicProps, Readonly<ResourcesScheduleOwnProps> & Readonly<{
     "onUpdate:date"?: ((date: string) => any) | undefined;
@@ -35,6 +36,7 @@ declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<Resour
     onSlotDragEnd?: ((data: import("../ResourcesDayView").ResourceSlotDragEndData) => any) | undefined;
     onExternalEventDrop?: ((data: import("../ResourcesDayView").ResourceExternalDropData) => any) | undefined;
     onEventResize?: ((data: import("../..").EventDropData) => any) | undefined;
+    onEventPlacementRejected?: ((data: import("../..").ScheduleEventPlacementRejectedData) => any) | undefined;
     "onUpdate:view"?: ((view: ResourcesScheduleViewLevel) => any) | undefined;
 }>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, ResourcesScheduleSlots>;
 type __VLS_WithSlots<T, S> = T & {

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

@@ -3,7 +3,7 @@ import type { BoxProps, Factory, ScrollAreaProps } from '@mantine-vue/core';
 import type { StylesApiProps } from '@mantine-vue/core/styles-api';
 import type { EventDropData, EventSlots, ForwardedProps, NativeButtonProps, RenderEvent, RenderEventBody } from '../../component-props';
 import type { ScheduleLabelsOverride } from '../../labels';
-import type { AnyDateValue, DateLabelFormat, DateStringValue, DayOfWeek, ScheduleEventData, ScheduleMode, ScheduleResourceData, ScheduleResourceGroup, ScheduleViewLevel } from '../../types';
+import type { AnyDateValue, DateLabelFormat, DateStringValue, DayOfWeek, ScheduleEventData, ScheduleCanDropEventData, ScheduleCanDropExternalEventData, ScheduleCanResizeEventToData, ScheduleEventPlacementRejectedData, PreventEventOverlap, ScheduleMode, ScheduleResourceData, ScheduleResourceGroup, ScheduleViewLevel } from '../../types';
 import type { BusinessHoursValue } from '../../utils';
 import type { MoreEventsEmits, MoreEventsProps, MoreEventsStylesNames } from '../MoreEvents/MoreEvents.types';
 import type { ScheduleEventStylesNames } from '../ScheduleEvent/ScheduleEvent.types';
@@ -247,6 +247,14 @@ export interface ResourcesWeekViewOwnProps extends StylesApiProps<ResourcesWeekV
      * @default () => true
      */
     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;
     /**
      * Maximum number of instances generated per recurring series.
      * @default 2000
@@ -308,6 +316,7 @@ export interface ResourcesWeekViewEmits {
     externalEventDrop: [data: ResourceExternalDropData];
     /** Emitted when an event is resized. */
     eventResize: [data: EventDropData];
+    eventPlacementRejected: [data: ScheduleEventPlacementRejectedData];
 }
 export type ResourcesWeekViewFactory = Factory<{
     props: Omit<ResourcesWeekViewProps, 'rootRef'>;

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

@@ -39,6 +39,7 @@ declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<Resour
     slotDragEnd: (data: import("../ResourcesDayView").ResourceSlotDragEndData) => any;
     externalEventDrop: (data: import("../ResourcesDayView").ResourceExternalDropData) => any;
     eventResize: (data: import("../..").EventDropData) => any;
+    eventPlacementRejected: (data: import("../..").ScheduleEventPlacementRejectedData) => any;
 }, string, import("vue").PublicProps, Readonly<ResourcesWeekViewOwnProps> & Readonly<{
     onDateChange?: ((date: string) => any) | undefined;
     onEventDragStart?: ((event: ScheduleEventData) => any) | undefined;
@@ -50,6 +51,7 @@ declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<Resour
     onSlotDragEnd?: ((data: import("../ResourcesDayView").ResourceSlotDragEndData) => any) | undefined;
     onExternalEventDrop?: ((data: import("../ResourcesDayView").ResourceExternalDropData) => any) | undefined;
     onEventResize?: ((data: import("../..").EventDropData) => any) | undefined;
+    onEventPlacementRejected?: ((data: import("../..").ScheduleEventPlacementRejectedData) => any) | undefined;
 }>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, ResourcesWeekViewSlots>;
 type __VLS_WithSlots<T, S> = T & {
     new (): {

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

@@ -3,7 +3,7 @@ import type { BoxProps, Factory } from '@mantine-vue/core';
 import type { StylesApiProps } from '@mantine-vue/core/styles-api';
 import type { EventDropData, EventSlots, ForwardedProps, RenderEventBody, TimeSlotClickData } from '../../component-props';
 import type { ScheduleLabelsOverride } from '../../labels';
-import type { DateStringValue, DateTimeStringValue, ScheduleEventData, ScheduleMode, ScheduleViewLevel } from '../../types';
+import type { DateStringValue, DateTimeStringValue, ScheduleEventData, ScheduleEventPlacementRejectedData, ScheduleCanDropEventData, ScheduleCanDropExternalEventData, ScheduleCanResizeEventToData, PreventEventOverlap, ScheduleMode, ScheduleViewLevel } from '../../types';
 import type { DayViewEmits, DayViewProps, DayViewStylesNames } from '../DayView/DayView.types';
 import type { MobileMonthViewHeaderPayload, MobileMonthViewEmits, MobileMonthViewProps, MobileMonthViewStylesNames } from '../MobileMonthView/MobileMonthView.types';
 import type { MonthViewEmits, MonthViewProps, MonthViewStylesNames } from '../MonthView/MonthView.types';
@@ -88,6 +88,14 @@ export interface ScheduleOwnProps extends StylesApiProps<ScheduleFactory> {
      * @default () => true
      */
     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;
     /** If set, background events can be focused and clicked. Combined with event resize, timed background events in day and week views can also be resized. */
     withInteractiveBackgroundEvents?: boolean;
     /**
@@ -144,6 +152,8 @@ export interface ScheduleEmits {
     externalEventDrop: [dataTransfer: DataTransfer, dateTime: DateTimeStringValue];
     /** Emitted when an event is resized. */
     eventResize: [data: EventDropData];
+    /** Emitted when a drop or resize is rejected. */
+    eventPlacementRejected: [data: ScheduleEventPlacementRejectedData];
 }
 export type ScheduleFactory = Factory<{
     props: Omit<ScheduleProps, 'rootRef'>;

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

@@ -24,6 +24,7 @@ declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<Schedu
     slotDragEnd: (rangeStart: string, rangeEnd: string) => any;
     externalEventDrop: (dataTransfer: DataTransfer, dateTime: string) => any;
     eventResize: (data: import("../..").EventDropData) => any;
+    eventPlacementRejected: (data: import("../..").ScheduleEventPlacementRejectedData) => any;
     monthClick: (month: string) => any;
     "update:view": (view: ScheduleViewLevel) => any;
 }, string, import("vue").PublicProps, Readonly<ScheduleOwnProps> & Readonly<{
@@ -40,6 +41,7 @@ declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<Schedu
     onSlotDragEnd?: ((rangeStart: string, rangeEnd: string) => any) | undefined;
     onExternalEventDrop?: ((dataTransfer: DataTransfer, dateTime: string) => any) | undefined;
     onEventResize?: ((data: import("../..").EventDropData) => any) | undefined;
+    onEventPlacementRejected?: ((data: import("../..").ScheduleEventPlacementRejectedData) => any) | undefined;
     onMonthClick?: ((month: string) => any) | undefined;
     "onUpdate:view"?: ((view: ScheduleViewLevel) => any) | undefined;
 }>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, ScheduleSlots>;

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

@@ -40,6 +40,7 @@ declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<WeekVi
     slotDragEnd: (rangeStart: string, rangeEnd: string) => any;
     externalEventDrop: (dataTransfer: DataTransfer, dropDateTime: string) => any;
     eventResize: (data: import("../..").EventDropData) => any;
+    eventPlacementRejected: (data: import("../..").ScheduleEventPlacementRejectedData) => any;
 }, string, import("vue").PublicProps, Readonly<WeekViewOwnProps> & Readonly<{
     onDateChange?: ((date: string) => any) | undefined;
     onEventDragStart?: ((event: ScheduleEventData) => any) | undefined;
@@ -52,6 +53,7 @@ declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<WeekVi
     onSlotDragEnd?: ((rangeStart: string, rangeEnd: string) => any) | undefined;
     onExternalEventDrop?: ((dataTransfer: DataTransfer, dropDateTime: string) => any) | undefined;
     onEventResize?: ((data: import("../..").EventDropData) => any) | undefined;
+    onEventPlacementRejected?: ((data: import("../..").ScheduleEventPlacementRejectedData) => any) | undefined;
 }>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, WeekViewSlots>;
 type __VLS_WithSlots<T, S> = T & {
     new (): {

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

@@ -1,5 +1,5 @@
 import type { EventDropData } from '../component-props';
-import type { ScheduleEventData, ScheduleMode } from '../types';
+import type { PreventEventOverlap, ScheduleCanResizeEventToData, ScheduleEventData, ScheduleEventPlacementRejectedData, ScheduleMode } from '../types';
 type ResizeEdge = 'top' | 'bottom';
 interface HandleResizeStartInput {
     event: ScheduleEventData;
@@ -20,6 +20,10 @@ export interface UseEventResizeInput {
     onEventResize: (data: EventDropData) => void;
     canResizeEvent: () => ((event: ScheduleEventData) => boolean) | undefined;
     withBackgroundEvents?: () => boolean;
+    events?: () => ScheduleEventData[];
+    preventEventOverlap?: () => PreventEventOverlap | undefined;
+    canResizeEventTo?: () => ((data: ScheduleCanResizeEventToData) => boolean) | undefined;
+    onEventPlacementRejected?: (data: ScheduleEventPlacementRejectedData) => void;
 }
 export declare function useEventResize(input: UseEventResizeInput): {
     handleResizeStart: ({ event, edge, container, originalTop, originalHeight, eventDate, pointerEvent, }: HandleResizeStartInput) => void;
@@ -31,5 +35,6 @@ export declare function useEventResize(input: UseEventResizeInput): {
     } | null;
     isResizableEvent: (event: ScheduleEventData) => boolean;
     wasResizing: () => boolean;
+    resizeValid: import("vue").ComputedRef<boolean>;
 };
 export {};

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

@@ -1,5 +1,6 @@
 import type { EventDropData } from '../component-props';
 import type { DateTimeStringValue, ScheduleEventData, ScheduleMode } from '../types';
+import type { PreventEventOverlap, ScheduleCanResizeEventToData, ScheduleEventPlacementRejectedData } from '../types';
 type ResizeEdge = 'start' | 'end';
 interface ResizeState {
     event: ScheduleEventData;
@@ -25,8 +26,13 @@ export declare function useHorizontalEventResize(input: {
     onEventResize: (data: EventDropData) => void;
     canResizeEvent: () => ((event: ScheduleEventData) => boolean) | undefined;
     withBackgroundEvents?: () => boolean;
+    events?: () => ScheduleEventData[];
+    preventEventOverlap?: () => PreventEventOverlap | undefined;
+    canResizeEventTo?: () => ((data: ScheduleCanResizeEventToData) => boolean) | undefined;
+    onEventPlacementRejected?: (data: ScheduleEventPlacementRejectedData) => void;
 }): {
     state: import("vue").ShallowRef<ResizeState | null, ResizeState | null>;
+    resizeValid: import("vue").Ref<boolean, boolean>;
     readonly resizingEdge: ResizeEdge | null;
     handleResizeStart: (params: {
         event: ScheduleEventData;

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

@@ -0,0 +1,26 @@
+import type { DateTimeStringValue, PreventEventOverlap, ScheduleCanResizeEventToData, ScheduleEventData, ScheduleEventPlacementRejectedData } from '../types';
+export interface EventResizeValidationOptions {
+    events?: ScheduleEventData[];
+    preventEventOverlap?: PreventEventOverlap;
+    canResizeEventTo?: (data: ScheduleCanResizeEventToData) => boolean;
+    onEventPlacementRejected?: (data: ScheduleEventPlacementRejectedData) => void;
+}
+export declare function validateEventResize({ event, start, end, edge, events, preventEventOverlap, canResizeEventTo, resourceId, }: EventResizeValidationOptions & {
+    event: ScheduleEventData;
+    start: DateTimeStringValue;
+    end: DateTimeStringValue;
+    edge: 'start' | 'end';
+    resourceId?: string | number;
+}): {
+    valid: boolean;
+    conflicts: ScheduleEventData[];
+    reason: "overlap";
+} | {
+    valid: boolean;
+    conflicts: never[];
+    reason: "rejected";
+} | {
+    valid: boolean;
+    conflicts: never[];
+    reason: null;
+};

package/lib/types.d.ts

@@ -155,4 +155,42 @@ export interface DropTarget {
     /** Target slot index (for DayView/WeekView) */
     slotIndex?: number;
 }
+export type PreventEventOverlap = boolean | ((stillEvent: ScheduleEventData, movingEvent: ScheduleEventData) => boolean);
+export interface ScheduleCanDropEventData {
+    event: ScheduleEventData;
+    start: DateTimeStringValue;
+    end: DateTimeStringValue;
+    resourceId?: string | number;
+}
+export interface ScheduleCanDropExternalEventData {
+    dataTransfer: DataTransfer;
+    start: DateTimeStringValue;
+    resourceId?: string | number;
+}
+export interface ScheduleCanResizeEventToData {
+    event: ScheduleEventData;
+    start: DateTimeStringValue;
+    end: DateTimeStringValue;
+    edge: 'start' | 'end';
+}
+interface ScheduleEventPlacementRejectedBase {
+    start: DateTimeStringValue;
+    end: DateTimeStringValue;
+    conflicts: ScheduleEventData[];
+    reason: 'overlap' | 'rejected';
+    resourceId?: string | number;
+}
+export type ScheduleEventPlacementRejectedData = (ScheduleEventPlacementRejectedBase & {
+    action: 'drop';
+    event: ScheduleEventData;
+}) | (ScheduleEventPlacementRejectedBase & {
+    action: 'resize';
+    event: ScheduleEventData;
+    edge: 'start' | 'end';
+}) | (Omit<ScheduleEventPlacementRejectedBase, 'end'> & {
+    action: 'external-drop';
+    dataTransfer: DataTransfer;
+    reason: 'rejected';
+    conflicts: [];
+});
 export {};

package/lib/utils/index.d.ts

@@ -22,6 +22,8 @@ export { isAllDayEvent } from './is-all-day-event/is-all-day-event';
 export { validateEvent } from './validate-event/validate-event';
 export { sortEvents } from './sort-events/sort-events';
 export { isEventsOverlap } from './is-events-overlap/is-events-overlap';
+export { isEventPlacementAllowed } from './is-event-placement-allowed/is-event-placement-allowed';
+export type { IsEventPlacementAllowedInput } from './is-event-placement-allowed/is-event-placement-allowed';
 export { getVisibleEvents } from './get-visible-events/get-visible-events';
 export { isMultidayEvent } from './is-multiday-event/is-multiday-event';
 export { isEventInTimeRange } from './is-event-in-time-range/is-event-in-time-range';

package/lib/utils/is-event-placement-allowed/is-event-placement-allowed.d.ts

@@ -0,0 +1,13 @@
+import type { DateTimeStringValue, PreventEventOverlap, ScheduleEventData } from '../../types';
+export interface IsEventPlacementAllowedInput {
+    event: ScheduleEventData;
+    start: DateTimeStringValue;
+    end: DateTimeStringValue;
+    events: ScheduleEventData[];
+    preventEventOverlap?: PreventEventOverlap;
+    resourceId?: string | number;
+}
+export declare function isEventPlacementAllowed({ event, start, end, events, preventEventOverlap, resourceId, }: IsEventPlacementAllowedInput): {
+    allowed: boolean;
+    conflicts: ScheduleEventData[];
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mantine-vue/schedule",
-  "version": "3.5.0",
+  "version": "3.7.0",
   "description": "Vue schedule and calendar components equivalent to @mantine/schedule",
   "license": "MIT",
   "files": [
@@ -44,9 +44,9 @@
     "vue": "^3.5.0"
   },
   "peerDependencies": {
-    "@mantine-vue/core": "3.5.0",
-    "@mantine-vue/dates": "3.5.0",
-    "@mantine-vue/hooks": "3.5.0",
+    "@mantine-vue/core": "3.7.0",
+    "@mantine-vue/dates": "3.7.0",
+    "@mantine-vue/hooks": "3.7.0",
     "dayjs": ">=1.0.0",
     "vue": "^3.5.0"
   }