@mantine/schedule 9.6.2 → 9.7.0

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';

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

@@ -0,0 +1,22 @@
+import { DateTimeStringValue, PreventEventOverlap, ScheduleEventData } from '../../types';
+export interface IsEventPlacementAllowedInput {
+    /** Event that is being moved or resized */
+    event: ScheduleEventData;
+    /** Candidate start of the event */
+    start: DateTimeStringValue;
+    /** Candidate end of the event */
+    end: DateTimeStringValue;
+    /** Events the candidate range is checked against */
+    events: ScheduleEventData[];
+    /** If set, placements that overlap another event are rejected */
+    preventEventOverlap?: PreventEventOverlap;
+    /** Target resource, limits the check to events of that resource */
+    resourceId?: string | number;
+}
+export interface IsEventPlacementAllowedResult {
+    /** True if the candidate range does not conflict with any event */
+    allowed: boolean;
+    /** Events the candidate range collided with */
+    conflicts: ScheduleEventData[];
+}
+export declare function isEventPlacementAllowed({ event, start, end, events, preventEventOverlap, resourceId, }: IsEventPlacementAllowedInput): IsEventPlacementAllowedResult;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mantine/schedule",
-  "version": "9.6.2",
+  "version": "9.7.0",
   "description": "Schedule Mantine component",
   "homepage": "https://mantine.dev/",
   "license": "MIT",
@@ -35,9 +35,9 @@
     "directory": "packages/@mantine/schedule"
   },
   "peerDependencies": {
-    "@mantine/core": "9.6.2",
-    "@mantine/dates": "9.6.2",
-    "@mantine/hooks": "9.6.2",
+    "@mantine/core": "9.7.0",
+    "@mantine/dates": "9.7.0",
+    "@mantine/hooks": "9.7.0",
     "react": "^19.2.0",
     "react-dom": "^19.2.0"
   },
@@ -50,7 +50,7 @@
     "@mantine/dates": "workspace:*",
     "@mantine/hooks": "workspace:*",
     "dayjs": "^1.11.23",
-    "react": "19.2.8",
-    "react-dom": "19.2.8"
+    "react": "19.3.0",
+    "react-dom": "19.3.0"
   }
 }

package/styles.css

@@ -194,6 +194,11 @@
       cursor: grabbing;
     }
 
+  .m_1ac94670:where([data-invalid]) .m_71699dc6 {
+    border: 1px solid var(--mantine-color-error);
+    opacity: 0.6;
+  }
+
   .m_1ac94670:where([data-dragging]) {
     opacity: 0.2;
   }
@@ -1084,6 +1089,12 @@
   opacity: 0.6;
 }
 
+.m_2d4819df:where([data-invalid]) {
+    border-color: var(--mantine-color-error);
+    background-color: transparent;
+    opacity: 0.4;
+  }
+
 .m_70d87f99 {
   --mobile-month-view-radius: var(--schedule-radius, var(--mantine-radius-default));
   --week-numbers-offset: 0rem;
@@ -2216,6 +2227,12 @@
   opacity: 0.6;
 }
 
+.m_e0da287:where([data-invalid]) {
+    border-color: var(--mantine-color-error);
+    background-color: transparent;
+    opacity: 0.4;
+  }
+
 .m_7301354d {
   --year-view-radius: var(--schedule-radius, var(--mantine-radius-default));
   --year-view-font-size: var(--mantine-font-size-sm);
@@ -3093,6 +3110,12 @@
   opacity: 0.6;
 }
 
+.m_969d1c27:where([data-invalid]) {
+    border-color: var(--mantine-color-error);
+    background-color: transparent;
+    opacity: 0.4;
+  }
+
 .m_ed4c47cf {
   --resources-week-view-radius: var(--schedule-radius, var(--mantine-radius-default));
   --resources-week-view-resource-label-width: calc(7.5rem * var(--mantine-scale));
@@ -3647,6 +3670,12 @@
   opacity: 0.6;
 }
 
+.m_27f284a5:where([data-invalid]) {
+    border-color: var(--mantine-color-error);
+    background-color: transparent;
+    opacity: 0.4;
+  }
+
 .m_652b3acd {
   --resources-month-view-radius: var(--schedule-radius, var(--mantine-radius-default));
   --resources-month-view-resource-label-width: calc(7.5rem * var(--mantine-scale));

package/styles.layer.css

@@ -194,6 +194,11 @@
       cursor: grabbing;
     }
 
+  .m_1ac94670:where([data-invalid]) .m_71699dc6 {
+    border: 1px solid var(--mantine-color-error);
+    opacity: 0.6;
+  }
+
   .m_1ac94670:where([data-dragging]) {
     opacity: 0.2;
   }
@@ -1084,6 +1089,12 @@
   opacity: 0.6;
 }
 
+.m_2d4819df:where([data-invalid]) {
+    border-color: var(--mantine-color-error);
+    background-color: transparent;
+    opacity: 0.4;
+  }
+
 .m_70d87f99 {
   --mobile-month-view-radius: var(--schedule-radius, var(--mantine-radius-default));
   --week-numbers-offset: 0rem;
@@ -2216,6 +2227,12 @@
   opacity: 0.6;
 }
 
+.m_e0da287:where([data-invalid]) {
+    border-color: var(--mantine-color-error);
+    background-color: transparent;
+    opacity: 0.4;
+  }
+
 .m_7301354d {
   --year-view-radius: var(--schedule-radius, var(--mantine-radius-default));
   --year-view-font-size: var(--mantine-font-size-sm);
@@ -3093,6 +3110,12 @@
   opacity: 0.6;
 }
 
+.m_969d1c27:where([data-invalid]) {
+    border-color: var(--mantine-color-error);
+    background-color: transparent;
+    opacity: 0.4;
+  }
+
 .m_ed4c47cf {
   --resources-week-view-radius: var(--schedule-radius, var(--mantine-radius-default));
   --resources-week-view-resource-label-width: calc(7.5rem * var(--mantine-scale));
@@ -3647,6 +3670,12 @@
   opacity: 0.6;
 }
 
+.m_27f284a5:where([data-invalid]) {
+    border-color: var(--mantine-color-error);
+    background-color: transparent;
+    opacity: 0.4;
+  }
+
 .m_652b3acd {
   --resources-month-view-radius: var(--schedule-radius, var(--mantine-radius-default));
   --resources-month-view-resource-label-width: calc(7.5rem * var(--mantine-scale));