@mantine-vue/schedule 3.4.0 → 3.6.0

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;
@@ -24,8 +25,15 @@ export declare function useHorizontalEventResize(input: {
     resizeIntervalMinutes?: () => number | undefined;
     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;
         edge: ResizeEdge;
@@ -37,7 +45,7 @@ export declare function useHorizontalEventResize(input: {
         dayIndex?: number;
         dayCount?: number;
     }) => void;
-    getResizePosition: (id: string | number) => {
+    getResizePosition: (id: string | number, eventDate?: string) => {
         left: number;
         width: number;
     } | null;

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

@@ -97,6 +97,8 @@ interface ScheduleEventRuntimeMeta {
 }
 /** Event data object passed to all `@mantine/schedule` components */
 export type ScheduleEventData<Payload extends EventPayload = EventPayload> = (ScheduleSingleEventData<Payload> & ScheduleEventRuntimeMeta) | (ScheduleRecurringSeriesEventData<Payload> & ScheduleEventRuntimeMeta) | (ScheduleRecurringOverrideEventData<Payload> & ScheduleEventRuntimeMeta);
+/** Controls how events that overlap in time are laid out along the horizontal axis. */
+export type ScheduleEventOverlapMode = 'columns' | 'cascade';
 export interface DayEventPositionData {
     /** All day events */
     allDay: boolean;
@@ -153,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/apply-cascade-layout/apply-cascade-layout.d.ts

@@ -0,0 +1,5 @@
+import type { DayEventPositionData, ScheduleEventData } from '../../types';
+export type CascadePositionedEvent = ScheduleEventData & {
+    position: Pick<DayEventPositionData, 'allDay' | 'column' | 'width' | 'offset' | 'overlaps'>;
+};
+export declare function applyCascadeLayout<T extends CascadePositionedEvent>(events: T[]): void;

package/lib/utils/get-overlap-clusters/get-overlap-clusters.d.ts

@@ -0,0 +1,2 @@
+import type { ScheduleEventData } from '../../types';
+export declare function getOverlapClusters<T extends ScheduleEventData>(events: T[]): T[][];

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';
@@ -34,6 +36,8 @@ export { calculateDropTime } from './calculate-drop-time/calculate-drop-time';
 export { calculateMonthDropDate } from './calculate-month-drop-date/calculate-month-drop-date';
 export { getBusinessHoursMod } from './get-business-hours-mod/get-business-hours-mod';
 export { expandRecurringEvents } from './expand-recurring-events/expand-recurring-events';
+export { applyCascadeLayout } from './apply-cascade-layout/apply-cascade-layout';
+export { getOverlapClusters } from './get-overlap-clusters/get-overlap-clusters';
 export type { DayTimeInterval } from './get-day-time-intervals/get-day-time-intervals';
 export type { ParsedTime } from './parse-time-string/parse-time-string';
 export type { CalculateDropTimeInput, CalculateDropTimeResult, } from './calculate-drop-time/calculate-drop-time';

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.4.0",
+  "version": "3.6.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.4.0",
-    "@mantine-vue/dates": "3.4.0",
-    "@mantine-vue/hooks": "3.4.0",
+    "@mantine-vue/core": "3.6.0",
+    "@mantine-vue/dates": "3.6.0",
+    "@mantine-vue/hooks": "3.6.0",
     "dayjs": ">=1.0.0",
     "vue": "^3.5.0"
   }