@mantine-vue/schedule 2.1.0 → 2.2.1

package/cjs/index.cjs

@@ -50,7 +50,10 @@ var DEFAULT_SCHEDULE_LABELS = {
 	switchToYearView: "Switch to year view",
 	viewSelectLabel: "Calendar view",
 	noEvents: "No events",
-	moreLabel: (hiddenEventsCount) => `+${hiddenEventsCount} more`
+	moreLabel: (hiddenEventsCount) => `+${hiddenEventsCount} more`,
+	resource: "Resource",
+	resources: "Resources",
+	resourceSlot: "Resource time slot"
 };
 function getLabel(key, override) {
 	if (override) return {
@@ -633,6 +636,85 @@ function expandRecurringEvents({ events, rangeStart, rangeEnd, expansionLimit =
 	return output;
 }
 //#endregion
+//#region src/utils/get-ordered-resources/get-ordered-resources.ts
+function getOrderedResources(resources, groups) {
+	if (!groups?.length) return {
+		orderedResources: resources,
+		groupRanges: [],
+		resourceGroupMap: []
+	};
+	const resourceMap = new Map(resources.map((resource) => [resource.id, resource]));
+	const usedIds = /* @__PURE__ */ new Set();
+	const orderedResources = [];
+	const groupRanges = [];
+	groups.forEach((group) => {
+		const startIndex = orderedResources.length;
+		group.resourceIds.forEach((id) => {
+			const resource = resourceMap.get(id);
+			if (resource && !usedIds.has(id)) {
+				orderedResources.push(resource);
+				usedIds.add(id);
+			}
+		});
+		const count = orderedResources.length - startIndex;
+		if (count) groupRanges.push({
+			group,
+			startIndex,
+			count
+		});
+	});
+	resources.forEach((resource) => {
+		if (!usedIds.has(resource.id)) orderedResources.push(resource);
+	});
+	const resourceGroupMap = Array(orderedResources.length).fill(null);
+	groupRanges.forEach(({ group, startIndex, count }) => {
+		for (let index = 0; index < count; index += 1) {
+			const position = count === 1 ? "only" : index === 0 ? "first" : index === count - 1 ? "last" : "middle";
+			resourceGroupMap[startIndex + index] = {
+				group,
+				position,
+				count
+			};
+		}
+	});
+	return {
+		orderedResources,
+		groupRanges,
+		resourceGroupMap
+	};
+}
+//#endregion
+//#region src/utils/get-group-to-resource-id-map/get-group-to-resource-id-map.ts
+function getGroupToResourceIdMap(resources) {
+	return new Map(resources.map((resource) => [String(resource.id), resource.id]));
+}
+//#endregion
+//#region src/utils/handle-resources-grid-key-down/handle-resources-grid-key-down.ts
+function handleResourcesGridKeyDown({ controls, resourceIndex, slotIndex, event }) {
+	const delta = {
+		ArrowLeft: [0, -1],
+		ArrowRight: [0, 1],
+		ArrowUp: [-1, 0],
+		ArrowDown: [1, 0]
+	}[event.key];
+	if (!delta) return;
+	event.preventDefault();
+	let row = resourceIndex + delta[0];
+	let column = slotIndex + delta[1];
+	while (row >= 0 && row < controls.length) {
+		const rowControls = controls[row] || [];
+		if (delta[0] !== 0) column = Math.min(column, rowControls.length - 1);
+		if (column < 0 || column >= rowControls.length) return;
+		const control = rowControls[column];
+		if (control && !control.disabled && !control.hasAttribute("data-hidden")) {
+			control.focus();
+			return;
+		}
+		row += delta[0];
+		column += delta[1];
+	}
+}
+//#endregion
 //#region src/hooks/use-event-resize.ts
 function useEventResize(input) {
 	const resizeState = (0, vue.ref)(null);
@@ -4113,6 +4195,2141 @@ var Schedule = (0, vue.defineComponent)({
 	}
 });
 //#endregion
+//#region src/hooks/use-horizontal-event-resize.ts
+function useHorizontalEventResize(input) {
+	const state = (0, vue.ref)(null);
+	let justResized = false;
+	let savedUserSelect = "";
+	const metrics = () => {
+		const start = parseTimeString(input.startTime());
+		const end = parseTimeString(input.endTime());
+		const startMinutes = start.hours * 60 + start.minutes;
+		const literalRange = end.hours * 60 + end.minutes - startMinutes;
+		const interval = clampIntervalMinutes(input.intervalMinutes());
+		const total = Math.ceil(literalRange / interval) * interval;
+		return {
+			startMinutes,
+			literalRange,
+			interval,
+			total,
+			minWidth: interval / total * 100
+		};
+	};
+	const snap = (percent) => {
+		const { literalRange, interval, total } = metrics();
+		return Math.max(0, Math.min(literalRange, Math.round(percent / 100 * total / interval) * interval)) / total * 100;
+	};
+	const toDateTime = (percent, date) => {
+		const { startMinutes, total } = metrics();
+		const minutes = startMinutes + Math.round(snap(percent) / 100 * total);
+		return `${date} ${String(Math.floor(minutes / 60)).padStart(2, "0")}:${String(minutes % 60).padStart(2, "0")}:00`;
+	};
+	const move = (event) => {
+		if (!state.value) return;
+		const rect = state.value.container.getBoundingClientRect();
+		const dayWidth = rect.width / state.value.dayCount;
+		const point = snap((event.clientX - rect.left - state.value.dayIndex * dayWidth) / dayWidth * 100);
+		const { minWidth } = metrics();
+		const current = state.value;
+		if (current.edge === "end") current.currentWidth = Math.max(minWidth, point - current.originalLeft);
+		else {
+			const right = current.originalLeft + current.originalWidth;
+			current.currentLeft = Math.min(point, right - minWidth);
+			current.currentWidth = right - current.currentLeft;
+		}
+		state.value = { ...current };
+	};
+	const cleanup = () => {
+		document.removeEventListener("pointermove", move);
+		document.removeEventListener("pointerup", finish);
+		document.body.style.userSelect = savedUserSelect;
+	};
+	const finish = () => {
+		const current = state.value;
+		if (current && (current.currentLeft !== current.originalLeft || current.currentWidth !== current.originalWidth)) input.onEventResize()?.({
+			eventId: current.event.id,
+			newStart: current.edge === "start" ? toDateTime(current.currentLeft, current.eventDate) : current.originalStart,
+			newEnd: current.edge === "end" ? toDateTime(current.currentLeft + current.currentWidth, current.eventDate) : current.originalEnd,
+			event: current.event
+		});
+		state.value = null;
+		cleanup();
+		justResized = true;
+		requestAnimationFrame(() => justResized = false);
+	};
+	const handleResizeStart = (params) => {
+		if (!input.enabled() || input.mode() === "static") return;
+		params.pointerEvent.preventDefault();
+		params.pointerEvent.stopPropagation();
+		state.value = {
+			...params,
+			currentLeft: params.originalLeft,
+			currentWidth: params.originalWidth,
+			originalStart: (0, dayjs.default)(params.event.start).format("YYYY-MM-DD HH:mm:ss"),
+			originalEnd: (0, dayjs.default)(params.event.end).format("YYYY-MM-DD HH:mm:ss"),
+			dayIndex: params.dayIndex ?? 0,
+			dayCount: params.dayCount ?? 1
+		};
+		savedUserSelect = document.body.style.userSelect;
+		document.body.style.userSelect = "none";
+		document.addEventListener("pointermove", move);
+		document.addEventListener("pointerup", finish);
+	};
+	(0, vue.onBeforeUnmount)(cleanup);
+	return {
+		state,
+		handleResizeStart,
+		getResizePosition: (id) => state.value?.event.id === id ? {
+			left: state.value.currentLeft,
+			width: state.value.currentWidth
+		} : null,
+		isResizableEvent: (event) => input.enabled() && input.mode() !== "static" && event.display !== "background" && (input.canResizeEvent()?.(event) ?? true),
+		wasResizing: () => justResized
+	};
+}
+//#endregion
+//#region src/components/ResourcesDayView/get-overlap-clusters/get-overlap-clusters.ts
+function getOverlapClusters(events) {
+	const sorted = [...events].sort((a, b) => a.position.top - b.position.top);
+	const clusters = [];
+	let current = [];
+	let end = -1;
+	sorted.forEach((event) => {
+		if (current.length && event.position.top >= end) {
+			clusters.push(current);
+			current = [];
+			end = -1;
+		}
+		current.push(event);
+		end = Math.max(end, event.position.top + event.position.height);
+	});
+	if (current.length) clusters.push(current);
+	return clusters;
+}
+//#endregion
+//#region src/components/ResourcesDayView/get-resources-day-view-events/get-resources-day-view-events.ts
+function getResourcesDayViewEvents({ events, resources, date, startTime, endTime, intervalMinutes }) {
+	const result = {
+		regularEvents: {},
+		allDayEvents: {},
+		backgroundTimedEvents: {},
+		backgroundAllDayEvents: {}
+	};
+	resources.forEach((resource) => {
+		result.regularEvents[resource.id] = [];
+		result.allDayEvents[resource.id] = [];
+		result.backgroundTimedEvents[resource.id] = [];
+		result.backgroundAllDayEvents[resource.id] = [];
+	});
+	if (!events) return result;
+	const dayStart = (0, dayjs.default)(date).startOf("day");
+	const dayEnd = (0, dayjs.default)(date).endOf("day");
+	const regular = new Map(resources.map((resource) => [resource.id, []]));
+	const background = new Map(resources.map((resource) => [resource.id, []]));
+	const seen = /* @__PURE__ */ new Set();
+	events.forEach((event) => {
+		if (event.resourceId === void 0 || !regular.has(event.resourceId)) return;
+		const eventStart = (0, dayjs.default)(event.start);
+		const eventEnd = (0, dayjs.default)(event.end);
+		const startsOnDay = eventStart.isSame(dayStart, "day");
+		if (!startsOnDay && !(eventStart.isBefore(dayEnd) && eventEnd.isAfter(dayStart))) return;
+		if (startsOnDay && !isEventInTimeRange({
+			event,
+			startTime,
+			endTime
+		})) return;
+		if (seen.has(event.id)) throw new Error(`[@mantine/schedule] ResourcesDayView: Duplicated event ids found: ${event.id}`);
+		seen.add(event.id);
+		const validated = validateEvent(event);
+		if (event.display === "background") {
+			background.get(event.resourceId).push(validated);
+			return;
+		}
+		const clipped = startsOnDay ? validated : {
+			...validated,
+			start: (eventStart.isBefore(dayStart) ? dayStart : eventStart).format("YYYY-MM-DD HH:mm:ss"),
+			end: (eventEnd.isAfter(dayEnd) ? dayEnd : eventEnd).format("YYYY-MM-DD HH:mm:ss")
+		};
+		if (isEventInTimeRange({
+			event: clipped,
+			startTime,
+			endTime
+		})) regular.get(event.resourceId).push(clipped);
+	});
+	resources.forEach((resource) => {
+		getDayPositionedEvents({
+			events: regular.get(resource.id),
+			startTime,
+			endTime,
+			date,
+			intervalMinutes
+		}).forEach((event) => {
+			(event.position.allDay ? result.allDayEvents : result.regularEvents)[resource.id].push(event);
+		});
+		background.get(resource.id).forEach((event) => {
+			const clippedStart = (0, dayjs.default)(event.start).isBefore(dayStart) ? dayStart : (0, dayjs.default)(event.start);
+			const clippedEnd = (0, dayjs.default)(event.end).isAfter(dayEnd) ? dayEnd : (0, dayjs.default)(event.end);
+			const clipped = {
+				...event,
+				start: clippedStart.format("YYYY-MM-DD HH:mm:ss"),
+				end: clippedEnd.format("YYYY-MM-DD HH:mm:ss")
+			};
+			const allDay = isAllDayEvent({
+				event: clipped,
+				date
+			});
+			const position = allDay ? {
+				top: 0,
+				height: 100
+			} : getDayPosition({
+				event: clipped,
+				startTime,
+				endTime,
+				intervalMinutes
+			});
+			if (!allDay && position.height <= 0) return;
+			(allDay ? result.backgroundAllDayEvents : result.backgroundTimedEvents)[resource.id].push({
+				...event,
+				position: {
+					...position,
+					allDay,
+					width: 100,
+					offset: 0,
+					column: 0,
+					overlaps: 1
+				}
+			});
+		});
+	});
+	return result;
+}
+var ResourcesDayView_module_default = {
+	resourcesDayView: "_resourcesDayView_7b9z2_1",
+	resourcesDayViewRoot: "_resourcesDayViewRoot_7b9z2_22",
+	resourcesDayViewScrollArea: "_resourcesDayViewScrollArea_7b9z2_30",
+	resourcesDayViewInner: "_resourcesDayViewInner_7b9z2_39",
+	resourcesDayViewTimeLabelsRow: "_resourcesDayViewTimeLabelsRow_7b9z2_44",
+	resourcesDayViewCorner: "_resourcesDayViewCorner_7b9z2_57",
+	resourcesDayViewTimeLabel: "_resourcesDayViewTimeLabel_7b9z2_44",
+	resourcesDayViewRow: "_resourcesDayViewRow_7b9z2_96",
+	resourcesDayViewResourceLabel: "_resourcesDayViewResourceLabel_7b9z2_100",
+	resourcesDayViewGroupColumn: "_resourcesDayViewGroupColumn_7b9z2_124",
+	resourcesDayViewGroupColumnEmpty: "_resourcesDayViewGroupColumnEmpty_7b9z2_125",
+	resourcesDayViewRowSlots: "_resourcesDayViewRowSlots_7b9z2_153",
+	resourcesDayViewRowSlot: "_resourcesDayViewRowSlot_7b9z2_153",
+	resourcesDayViewCurrentTimeIndicator: "_resourcesDayViewCurrentTimeIndicator_7b9z2_231",
+	resourcesDayViewCurrentTimeIndicatorLine: "_resourcesDayViewCurrentTimeIndicatorLine_7b9z2_243",
+	resourcesDayViewCurrentTimeIndicatorThumb: "_resourcesDayViewCurrentTimeIndicatorThumb_7b9z2_249",
+	resourcesDayViewCurrentTimeIndicatorTimeBubble: "_resourcesDayViewCurrentTimeIndicatorTimeBubble_7b9z2_259",
+	resourcesDayViewBackgroundEvent: "_resourcesDayViewBackgroundEvent_7b9z2_278",
+	resourcesDayViewAllDayEvent: "_resourcesDayViewAllDayEvent_7b9z2_290",
+	resourcesDayViewEventWrapper: "_resourcesDayViewEventWrapper_7b9z2_296",
+	resourcesDayViewResizeHandle: "_resourcesDayViewResizeHandle_7b9z2_300"
+};
+//#endregion
+//#region src/components/ResourcesDayView/ResourcesDayView.ts
+function cssSize$2(value) {
+	return typeof value === "number" ? `${value}px` : value;
+}
+var ResourcesDayView = (0, vue.defineComponent)({
+	name: "ResourcesDayView",
+	inheritAttrs: false,
+	slots: Object,
+	props: {
+		date: {
+			type: [String, Date],
+			required: true
+		},
+		onDateChange: Function,
+		resources: {
+			type: Array,
+			required: true
+		},
+		startTime: {
+			type: String,
+			default: "00:00:00"
+		},
+		endTime: {
+			type: String,
+			default: "23:59:59"
+		},
+		intervalMinutes: {
+			type: Number,
+			default: 60
+		},
+		slotLabelFormat: {
+			type: [String, Function],
+			default: "HH:mm"
+		},
+		radius: [String, Number],
+		startScrollTime: String,
+		scrollAreaProps: Object,
+		locale: String,
+		withCurrentTimeIndicator: {
+			type: Boolean,
+			default: void 0
+		},
+		withCurrentTimeBubble: {
+			type: Boolean,
+			default: true
+		},
+		getCurrentTime: Function,
+		withHeader: {
+			type: Boolean,
+			default: true
+		},
+		onViewChange: Function,
+		previousControlProps: Object,
+		nextControlProps: Object,
+		todayControlProps: Object,
+		viewSelectProps: Object,
+		headerFormat: {
+			type: [String, Function],
+			default: "MMMM D, YYYY"
+		},
+		events: Array,
+		slotWidth: {
+			type: [String, Number],
+			default: 80
+		},
+		rowHeight: {
+			type: [String, Number],
+			default: 64
+		},
+		labels: Object,
+		highlightBusinessHours: Boolean,
+		businessHours: {
+			type: Array,
+			default: () => ["09:00:00", "17:00:00"]
+		},
+		renderEventBody: Function,
+		renderEvent: Function,
+		renderResourceLabel: Function,
+		groups: Array,
+		renderGroupLabel: Function,
+		groupLabelWidth: {
+			type: [String, Number],
+			default: 80
+		},
+		withEventsDragAndDrop: Boolean,
+		onEventDrop: Function,
+		canDragEvent: Function,
+		onEventDragStart: Function,
+		onEventDragEnd: Function,
+		onTimeSlotClick: Function,
+		onEventClick: Function,
+		withDragSlotSelect: Boolean,
+		onSlotDragEnd: Function,
+		mode: {
+			type: String,
+			default: "default"
+		},
+		onExternalEventDrop: Function,
+		withEventResize: Boolean,
+		onEventResize: Function,
+		canResizeEvent: Function,
+		recurrenceExpansionLimit: {
+			type: Number,
+			default: 2e3
+		},
+		maxEventsPerTimeSlot: {
+			type: Number,
+			default: 2
+		},
+		moreEventsProps: Object
+	},
+	setup(props, { attrs, slots }) {
+		const theme = (0, _mantine_vue_core.useSafeMantineTheme)();
+		const controls = [];
+		const rootElement = (0, vue.ref)(null);
+		const rowContainers = /* @__PURE__ */ new Map();
+		const dropTarget = (0, vue.ref)(null);
+		const scrolled = (0, vue.ref)(false);
+		const scrolledX = (0, vue.ref)(false);
+		const intervals = (0, vue.computed)(() => getDayTimeIntervals({
+			startTime: props.startTime,
+			endTime: props.endTime,
+			intervalMinutes: props.intervalMinutes
+		}));
+		const ordered = (0, vue.computed)(() => getOrderedResources(props.resources, props.groups));
+		const resourceIdMap = (0, vue.computed)(() => getGroupToResourceIdMap(props.resources));
+		const expandedEvents = (0, vue.computed)(() => expandRecurringEvents({
+			events: props.events,
+			rangeStart: (0, dayjs.default)(props.date).startOf("day").toDate(),
+			rangeEnd: (0, dayjs.default)(props.date).endOf("day").toDate(),
+			expansionLimit: props.recurrenceExpansionLimit
+		}));
+		(0, vue.onMounted)(async () => {
+			if (!props.startScrollTime) return;
+			await (0, vue.nextTick)();
+			const targetIndex = intervals.value.findIndex((interval) => interval.startTime >= props.startScrollTime);
+			if (targetIndex < 0) return;
+			const target = controls[0]?.[targetIndex];
+			const viewport = rootElement.value?.querySelector(".mantine-ScrollArea-viewport");
+			if (target && viewport) {
+				viewport.scrollLeft = target.offsetLeft;
+				requestAnimationFrame(() => viewport.scrollLeft = target.offsetLeft);
+			}
+		});
+		const positioned = (0, vue.computed)(() => getResourcesDayViewEvents({
+			date: props.date,
+			events: expandedEvents.value,
+			resources: props.resources,
+			startTime: props.startTime,
+			endTime: props.endTime,
+			intervalMinutes: props.intervalMinutes
+		}));
+		const slotSelect = useSlotDragSelect({
+			enabled: () => props.withDragSlotSelect && props.mode !== "static",
+			onDragEnd: () => (start, end, group) => {
+				const first = intervals.value[start];
+				const last = intervals.value[end];
+				if (first && last) {
+					const date = (0, dayjs.default)(props.date).format("YYYY-MM-DD");
+					props.onSlotDragEnd?.({
+						rangeStart: `${date} ${first.startTime}`,
+						rangeEnd: `${date} ${last.endTime}`,
+						resourceId: resourceIdMap.value.get(group)
+					});
+				}
+			}
+		});
+		const resize = useHorizontalEventResize({
+			enabled: () => props.withEventResize,
+			mode: () => props.mode,
+			startTime: () => props.startTime,
+			endTime: () => props.endTime,
+			intervalMinutes: () => props.intervalMinutes,
+			onEventResize: () => props.onEventResize,
+			canResizeEvent: () => props.canResizeEvent
+		});
+		const emitDrop = (nativeEvent, resourceId, slotIndex) => {
+			nativeEvent.preventDefault();
+			dropTarget.value = null;
+			const interval = intervals.value[slotIndex];
+			if (!interval) return;
+			const target = `${(0, dayjs.default)(props.date).format("YYYY-MM-DD")} ${interval.startTime}`;
+			const event = getDropEvent(expandedEvents.value, nativeEvent.dataTransfer);
+			if (event) props.onEventDrop?.({
+				...moveEventTo(event, target),
+				resourceId
+			});
+			else if (nativeEvent.dataTransfer) props.onExternalEventDrop?.({
+				dataTransfer: nativeEvent.dataTransfer,
+				dropDateTime: target,
+				resourceId
+			});
+		};
+		const getSlotIndexAtPoint = (nativeEvent, resourceIndex) => {
+			const container = rowContainers.get(resourceIndex);
+			if (!container || intervals.value.length === 0) return -1;
+			const rect = container.getBoundingClientRect();
+			if (rect.width <= 0) return -1;
+			return Math.max(0, Math.min(intervals.value.length - 1, Math.floor((nativeEvent.clientX - rect.left) / rect.width * intervals.value.length)));
+		};
+		const renderGroupCell = (info) => {
+			if (info === void 0) return null;
+			if (info === null) return (0, vue.h)(_mantine_vue_core.Box, { class: ResourcesDayView_module_default.resourcesDayViewGroupColumnEmpty });
+			const starts = info.position === "first" || info.position === "only";
+			return (0, vue.h)(_mantine_vue_core.Box, {
+				class: ResourcesDayView_module_default.resourcesDayViewGroupColumn,
+				"data-group-position": info.position
+			}, () => starts ? (0, vue.h)("span", { style: info.count > 1 ? { transform: `translateY(calc((${info.count - 1} * (var(--resources-day-view-row-height) + 1px)) / 2))` } : void 0 }, slots.groupLabel?.({ group: info.group }) ?? props.renderGroupLabel?.(info.group) ?? info.group.label ?? void 0) : null);
+		};
+		return () => {
+			const date = (0, dayjs.default)(props.date).format("YYYY-MM-DD");
+			const now = (0, dayjs.default)(props.getCurrentTime?.() ?? /* @__PURE__ */ new Date());
+			const isToday = (0, dayjs.default)(props.date).isSame(now, "day");
+			const showIndicator = (props.withCurrentTimeIndicator ?? isToday) && isInTimeRange({
+				date: now.toDate(),
+				startTime: props.startTime,
+				endTime: props.endTime
+			});
+			const indicatorOffset = getCurrentTimePosition({
+				startTime: props.startTime,
+				endTime: props.endTime,
+				intervalMinutes: props.intervalMinutes,
+				now
+			});
+			const currentTime = formatDate({
+				date: now,
+				locale: props.locale || "en",
+				format: props.slotLabelFormat
+			});
+			const hasGroups = ordered.value.groupRanges.length > 0;
+			const timeLabels = intervals.value.map((interval) => {
+				const label = formatDate({
+					date: `${date} ${interval.startTime}`,
+					locale: props.locale || "en",
+					format: props.slotLabelFormat
+				});
+				const mod = getBusinessHoursMod({
+					time: interval.startTime,
+					businessHours: props.businessHours,
+					highlightBusinessHours: props.highlightBusinessHours
+				});
+				return (0, vue.h)(_mantine_vue_core.Box, {
+					key: interval.startTime,
+					class: ResourcesDayView_module_default.resourcesDayViewTimeLabel,
+					"data-business-hours": mod["business-hours"] || void 0,
+					"data-non-business-hours": mod["non-business-hours"] || void 0
+				}, () => slots.timeLabel?.({
+					label,
+					startTime: interval.startTime,
+					endTime: interval.endTime
+				}) ?? label);
+			});
+			const rows = ordered.value.orderedResources.map((resource, resourceIndex) => {
+				const resourceEvents = positioned.value;
+				const background = [...resourceEvents.backgroundTimedEvents[resource.id] || [], ...resourceEvents.backgroundAllDayEvents[resource.id] || []].map((event) => {
+					const colors = theme.value.variantColorResolver({
+						color: event.color || theme.value.primaryColor,
+						theme: theme.value,
+						variant: "light",
+						autoContrast: true
+					});
+					return slots.backgroundEvent?.({ event }) ?? (0, vue.h)(_mantine_vue_core.Box, {
+						key: `bg-${event.id}`,
+						class: ResourcesDayView_module_default.resourcesDayViewBackgroundEvent,
+						style: {
+							left: `${event.position.top}%`,
+							width: `${event.position.height}%`,
+							top: 0,
+							height: "100%",
+							"--bg-event-bg": colors.background,
+							"--bg-event-color": colors.color
+						}
+					}, () => props.renderEventBody?.(event) ?? slots.eventBody?.({ event }) ?? event.title);
+				});
+				const allRegular = resourceEvents.regularEvents[resource.id] || [];
+				const regular = allRegular.filter((event) => event.position.column < Math.max(1, props.maxEventsPerTimeSlot)).map((event) => {
+					const colors = theme.value.variantColorResolver({
+						color: event.color || theme.value.primaryColor,
+						theme: theme.value,
+						variant: event.variant || "light",
+						autoContrast: true
+					});
+					const position = resize.getResizePosition(event.id);
+					const left = position?.left ?? event.position.top;
+					const width = position?.width ?? event.position.height;
+					const isResizable = resize.isResizableEvent(event);
+					const isResizing = position !== null;
+					const wrapperStyle = {
+						left: `calc(${left}% + 1px)`,
+						width: `calc(${width}% - 2px)`,
+						top: `${event.position.offset}%`,
+						height: `${event.position.width}%`
+					};
+					return (0, vue.h)(_mantine_vue_core.Box, {
+						key: event.id,
+						class: ResourcesDayView_module_default.resourcesDayViewEventWrapper,
+						"data-resizing": isResizing || void 0,
+						style: {
+							...wrapperStyle,
+							"--event-color": colors.color
+						}
+					}, () => [(0, vue.h)(ScheduleEvent, {
+						event,
+						autoSize: true,
+						nowrap: true,
+						radius: props.radius,
+						mode: props.mode,
+						renderEvent: props.renderEvent,
+						renderEventBody: props.renderEventBody,
+						draggable: props.withEventsDragAndDrop && props.mode !== "static" && (props.canDragEvent?.(event) ?? true),
+						onEventDragStart: props.onEventDragStart,
+						onEventDragEnd: props.onEventDragEnd,
+						onClick: props.mode === "static" ? void 0 : (nativeEvent) => {
+							if (!resize.wasResizing()) props.onEventClick?.(event, nativeEvent);
+						},
+						style: {
+							width: "100%",
+							height: "100%"
+						}
+					}, forwardEventSlots(slots)), isResizable ? ["start", "end"].map((edge) => (0, vue.h)("div", {
+						class: ResourcesDayView_module_default.resourcesDayViewResizeHandle,
+						"data-edge": edge,
+						"data-active": resize.state.value?.edge === edge || void 0,
+						"aria-label": `${edge === "start" ? "Resize event start" : "Resize event end"} ${event.title}`,
+						onDragstart: (nativeEvent) => nativeEvent.preventDefault(),
+						onPointerdown: (pointerEvent) => {
+							const container = rowContainers.get(resourceIndex);
+							if (container) resize.handleResizeStart({
+								event,
+								edge,
+								container,
+								originalLeft: event.position.top,
+								originalWidth: event.position.height,
+								eventDate: date,
+								pointerEvent
+							});
+						}
+					})) : null]);
+				});
+				const allDay = (resourceEvents.allDayEvents[resource.id] || []).map((event, index) => (0, vue.h)(_mantine_vue_core.Box, {
+					key: `all-${event.id}`,
+					class: ResourcesDayView_module_default.resourcesDayViewAllDayEvent,
+					style: { top: `calc(${index} * (var(--resources-day-view-all-day-height) + 2px) + 2px)` }
+				}, () => slots.allDayEvent?.({ event }) ?? (0, vue.h)(ScheduleEvent, {
+					event,
+					autoSize: true,
+					nowrap: true,
+					radius: props.radius,
+					mode: props.mode,
+					renderEvent: props.renderEvent,
+					renderEventBody: props.renderEventBody,
+					onClick: props.mode === "static" ? void 0 : (nativeEvent) => props.onEventClick?.(event, nativeEvent),
+					style: {
+						width: "100%",
+						height: "100%"
+					}
+				}, forwardEventSlots(slots))));
+				const more = getOverlapClusters(allRegular).filter((cluster) => cluster.some((event) => event.position.column >= props.maxEventsPerTimeSlot)).map((cluster) => {
+					const hiddenCount = cluster.filter((event) => event.position.column >= props.maxEventsPerTimeSlot).length;
+					const left = Math.min(...cluster.map((event) => event.position.top));
+					const right = Math.max(...cluster.map((event) => event.position.top + event.position.height));
+					return slots.moreEvents?.({
+						events: cluster,
+						hiddenCount
+					}) ?? (0, vue.h)(MoreEvents, {
+						...props.moreEventsProps,
+						key: `more-${cluster[0].id}`,
+						events: cluster,
+						moreEventsCount: hiddenCount,
+						mode: props.mode,
+						labels: props.labels,
+						renderEventBody: props.renderEventBody,
+						renderEvent: props.renderEvent,
+						onEventClick: props.onEventClick,
+						style: {
+							position: "absolute",
+							left: `calc(${left}% + 1px)`,
+							width: `calc(${right - left}% - 2px)`,
+							bottom: 0,
+							height: "22px",
+							zIndex: 4
+						}
+					}, forwardEventSlots(slots));
+				});
+				const slotGroup = String(resource.id);
+				const buttons = intervals.value.map((interval, slotIndex) => {
+					const mod = getBusinessHoursMod({
+						time: interval.startTime,
+						businessHours: props.businessHours,
+						highlightBusinessHours: props.highlightBusinessHours
+					});
+					return (0, vue.h)(_mantine_vue_core.UnstyledButton, {
+						key: interval.startTime,
+						ref: (element) => {
+							const button = element?.$el ?? element;
+							controls[resourceIndex] ||= [];
+							controls[resourceIndex][slotIndex] = button instanceof HTMLButtonElement ? button : void 0;
+						},
+						class: ResourcesDayView_module_default.resourcesDayViewRowSlot,
+						"data-business-hours": mod["business-hours"] || void 0,
+						"data-non-business-hours": mod["non-business-hours"] || void 0,
+						"data-drop-target": dropTarget.value?.resourceId === resource.id && dropTarget.value.slotIndex === slotIndex ? true : void 0,
+						"data-drag-selected": slotSelect.isSlotSelected(slotIndex, slotGroup) || void 0,
+						"data-static": props.mode === "static" || void 0,
+						"data-drag-slot-index": props.withDragSlotSelect ? slotIndex : void 0,
+						"data-drag-slot-group": props.withDragSlotSelect ? slotGroup : void 0,
+						"aria-label": `${getLabel("resourceSlot", props.labels)} ${String(resource.label)} ${date} ${interval.startTime} - ${interval.endTime}`,
+						tabindex: props.mode === "static" ? -1 : resourceIndex === 0 && slotIndex === 0 ? 0 : -1,
+						onKeydown: (event) => handleResourcesGridKeyDown({
+							controls,
+							resourceIndex,
+							slotIndex,
+							event
+						}),
+						onPointerdown: props.mode === "static" ? void 0 : (event) => slotSelect.handleSlotPointerDown(event, slotIndex, slotGroup),
+						onClick: props.mode === "static" ? void 0 : (nativeEvent) => props.onTimeSlotClick?.({
+							slotStart: `${date} ${interval.startTime}`,
+							slotEnd: `${date} ${interval.endTime}`,
+							nativeEvent,
+							resourceId: resource.id
+						})
+					}, () => slots.timeSlot?.({
+						resource,
+						startTime: interval.startTime,
+						endTime: interval.endTime
+					}));
+				});
+				const groupInfo = hasGroups ? ordered.value.resourceGroupMap[resourceIndex] : void 0;
+				const allDayCount = resourceEvents.allDayEvents[resource.id]?.length || 0;
+				return (0, vue.h)(_mantine_vue_core.Box, {
+					key: resource.id,
+					class: ResourcesDayView_module_default.resourcesDayViewRow
+				}, () => [
+					renderGroupCell(groupInfo),
+					(0, vue.h)(_mantine_vue_core.Box, {
+						class: ResourcesDayView_module_default.resourcesDayViewResourceLabel,
+						"data-scrolled-x": scrolledX.value || void 0,
+						"data-has-groups": groupInfo !== void 0 || void 0
+					}, () => slots.resourceLabel?.({ resource }) ?? props.renderResourceLabel?.(resource) ?? resource.label),
+					(0, vue.h)(_mantine_vue_core.Box, {
+						class: ResourcesDayView_module_default.resourcesDayViewRowSlots,
+						ref: (element) => {
+							const node = element?.$el ?? element;
+							if (node instanceof HTMLElement) rowContainers.set(resourceIndex, node);
+						},
+						style: allDayCount ? { minHeight: `max(var(--resources-day-view-row-height), calc(${allDayCount} * (var(--resources-day-view-all-day-height) + 2px) + 4px))` } : void 0,
+						onDragover: props.withEventsDragAndDrop || props.onExternalEventDrop ? (nativeEvent) => {
+							if (props.mode === "static") return;
+							nativeEvent.preventDefault();
+							const slotIndex = getSlotIndexAtPoint(nativeEvent, resourceIndex);
+							if (slotIndex >= 0 && (dropTarget.value?.resourceId !== resource.id || dropTarget.value.slotIndex !== slotIndex)) dropTarget.value = {
+								resourceId: resource.id,
+								slotIndex
+							};
+						} : void 0,
+						onDragleave: props.withEventsDragAndDrop || props.onExternalEventDrop ? (nativeEvent) => {
+							const related = nativeEvent.relatedTarget;
+							const current = nativeEvent.currentTarget;
+							if (!(related instanceof Node) || !(current instanceof HTMLElement) || !current.contains(related)) dropTarget.value = null;
+						} : void 0,
+						onDrop: props.withEventsDragAndDrop || props.onExternalEventDrop ? (nativeEvent) => {
+							const slotIndex = getSlotIndexAtPoint(nativeEvent, resourceIndex);
+							if (slotIndex >= 0) emitDrop(nativeEvent, resource.id, slotIndex);
+						} : void 0
+					}, () => [
+						...background,
+						...allDay,
+						...regular,
+						...more,
+						...buttons
+					])
+				]);
+			});
+			const headerLabel = formatDate({
+				date: props.date,
+				locale: props.locale || "en",
+				format: props.headerFormat
+			});
+			const header = props.withHeader ? slots.header?.({
+				date,
+				label: headerLabel
+			}) ?? (0, vue.h)(ScheduleHeaderBase, {
+				view: "day",
+				navigationHandlers: {
+					previous: () => (0, dayjs.default)(props.date).subtract(1, "day").format("YYYY-MM-DD"),
+					next: () => (0, dayjs.default)(props.date).add(1, "day").format("YYYY-MM-DD"),
+					today: () => now.format("YYYY-MM-DD")
+				},
+				control: { title: headerLabel },
+				labels: props.labels,
+				onDateChange: props.onDateChange,
+				onViewChange: props.onViewChange,
+				previousControlProps: props.previousControlProps,
+				nextControlProps: props.nextControlProps,
+				todayControlProps: props.todayControlProps,
+				viewSelectProps: {
+					views: [
+						"day",
+						"week",
+						"month"
+					],
+					...props.viewSelectProps
+				}
+			}) : null;
+			const indicator = showIndicator ? slots.currentTimeIndicator?.({
+				time: currentTime,
+				offset: indicatorOffset
+			}) ?? (0, vue.h)(_mantine_vue_core.Box, {
+				class: ResourcesDayView_module_default.resourcesDayViewCurrentTimeIndicator,
+				style: {
+					"--indicator-left-offset": hasGroups ? `calc(var(--resources-day-view-resource-label-width) + var(--resources-day-view-group-label-width) + (100% - var(--resources-day-view-resource-label-width) - var(--resources-day-view-group-label-width)) * ${indicatorOffset} / 100)` : `calc(var(--resources-day-view-resource-label-width) + (100% - var(--resources-day-view-resource-label-width)) * ${indicatorOffset} / 100)`,
+					"--_time-bubble-width": String(currentTime).toLowerCase().includes("m") ? "64px" : "46px"
+				}
+			}, () => [props.withCurrentTimeBubble ? (0, vue.h)("div", { class: ResourcesDayView_module_default.resourcesDayViewCurrentTimeIndicatorTimeBubble }, currentTime) : (0, vue.h)("div", { class: ResourcesDayView_module_default.resourcesDayViewCurrentTimeIndicatorThumb }), (0, vue.h)("div", { class: ResourcesDayView_module_default.resourcesDayViewCurrentTimeIndicatorLine })]) : null;
+			return (0, vue.h)(_mantine_vue_core.Box, {
+				...attrs,
+				ref: (element) => {
+					const node = element?.$el ?? element;
+					rootElement.value = node instanceof HTMLElement ? node : null;
+				},
+				class: [ResourcesDayView_module_default.resourcesDayView, attrs.class],
+				style: [{
+					"--resources-day-view-radius": resolveScheduleRadius(props.radius),
+					"--resources-day-view-slot-width": cssSize$2(props.slotWidth),
+					"--resources-day-view-row-height": cssSize$2(props.rowHeight),
+					"--resources-day-view-group-label-width": cssSize$2(props.groupLabelWidth)
+				}, attrs.style],
+				"data-resizing": resize.state.value ? true : void 0,
+				"data-event-interaction": resize.state.value ? true : void 0
+			}, () => [header, (0, vue.h)(_mantine_vue_core.Box, { class: ResourcesDayView_module_default.resourcesDayViewRoot }, () => (0, vue.h)(_mantine_vue_core.ScrollArea, {
+				scrollbarSize: 4,
+				...props.scrollAreaProps,
+				class: ResourcesDayView_module_default.resourcesDayViewScrollArea,
+				onScrollPositionChange: (position) => {
+					scrolled.value = position.y !== 0;
+					scrolledX.value = position.x !== 0;
+				}
+			}, () => (0, vue.h)("div", { class: ResourcesDayView_module_default.resourcesDayViewInner }, [
+				(0, vue.h)(_mantine_vue_core.Box, {
+					class: ResourcesDayView_module_default.resourcesDayViewTimeLabelsRow,
+					"data-scrolled": scrolled.value || void 0
+				}, () => [(0, vue.h)("div", {
+					class: ResourcesDayView_module_default.resourcesDayViewCorner,
+					style: hasGroups ? {
+						flexBasis: "calc(var(--resources-day-view-resource-label-width) + var(--resources-day-view-group-label-width))",
+						minWidth: "calc(var(--resources-day-view-resource-label-width) + var(--resources-day-view-group-label-width))"
+					} : void 0
+				}, slots.corner?.({ resources: ordered.value.orderedResources }) ?? getLabel("resources", props.labels)), ...timeLabels]),
+				...rows,
+				indicator
+			])))]);
+		};
+	}
+});
+//#endregion
+//#region src/components/ResourcesWeekView/get-resources-week-view-events/get-resources-week-view-events.ts
+function assignAllDayRows(bars) {
+	const rowEnds = [];
+	[...bars].sort((a, b) => a.startDayIndex - b.startDayIndex || a.endDayIndex - b.endDayIndex).forEach((bar) => {
+		let row = 0;
+		while (row < rowEnds.length && rowEnds[row] >= bar.startDayIndex) row += 1;
+		rowEnds[row] = bar.endDayIndex;
+		bar.row = row;
+	});
+}
+function getResourcesWeekViewEvents({ events, resources, weekdays, startTime, endTime, intervalMinutes, expansionLimit }) {
+	const expanded = expandRecurringEvents({
+		events,
+		rangeStart: (0, dayjs.default)(weekdays[0]).startOf("day").toDate(),
+		rangeEnd: (0, dayjs.default)(weekdays.at(-1)).endOf("day").toDate(),
+		expansionLimit
+	});
+	const seen = /* @__PURE__ */ new Set();
+	expanded?.forEach((event) => {
+		if (seen.has(event.id)) throw new Error(`[@mantine/schedule] ResourcesWeekView: Duplicated event ids found: ${event.id}`);
+		seen.add(event.id);
+	});
+	const byDay = {};
+	const assigned = /* @__PURE__ */ new Set();
+	const spanning = (event) => event.display !== "background" && isMultidayEvent(event);
+	weekdays.forEach((day) => {
+		const dayEvents = expanded?.filter((event) => {
+			if (assigned.has(event.id) || spanning(event)) return false;
+			const start = (0, dayjs.default)(event.start);
+			const dayStart = (0, dayjs.default)(day).startOf("day");
+			if (start.isSame(dayStart, "day")) {
+				assigned.add(event.id);
+				return true;
+			}
+			return event.display === "background" && start.isBefore((0, dayjs.default)(day).endOf("day")) && (0, dayjs.default)(event.end).isAfter(dayStart);
+		});
+		byDay[day] = getResourcesDayViewEvents({
+			events: dayEvents,
+			resources,
+			date: day,
+			startTime,
+			endTime,
+			intervalMinutes
+		});
+	});
+	const allDayBars = {};
+	resources.forEach((resource) => allDayBars[resource.id] = []);
+	weekdays.forEach((day, dayIndex) => {
+		resources.forEach((resource) => {
+			byDay[day].allDayEvents[resource.id]?.forEach((event) => allDayBars[resource.id].push({
+				event,
+				startDayIndex: dayIndex,
+				endDayIndex: dayIndex,
+				row: 0
+			}));
+		});
+	});
+	expanded?.forEach((event) => {
+		if (!spanning(event) || event.resourceId === void 0 || !(event.resourceId in allDayBars)) return;
+		const days = calculateEventDays({
+			event,
+			weekDays: weekdays,
+			actualEndDate: getEventEndDate(event)
+		});
+		if (!days.length) return;
+		allDayBars[event.resourceId].push({
+			event,
+			startDayIndex: weekdays.indexOf(days[0]),
+			endDayIndex: weekdays.indexOf(days.at(-1)),
+			row: 0
+		});
+	});
+	resources.forEach((resource) => assignAllDayRows(allDayBars[resource.id]));
+	return {
+		byDay,
+		allDayBars
+	};
+}
+var ResourcesWeekView_module_default = {
+	resourcesWeekView: "_resourcesWeekView_jzd1a_1",
+	resourcesWeekViewRoot: "_resourcesWeekViewRoot_jzd1a_19",
+	resourcesWeekViewScrollArea: "_resourcesWeekViewScrollArea_jzd1a_26",
+	resourcesWeekViewInner: "_resourcesWeekViewInner_jzd1a_34",
+	resourcesWeekViewHeaderRows: "_resourcesWeekViewHeaderRows_jzd1a_39",
+	resourcesWeekViewCorner: "_resourcesWeekViewCorner_jzd1a_48",
+	resourcesWeekViewHeaderContent: "_resourcesWeekViewHeaderContent_jzd1a_63",
+	resourcesWeekViewDayLabelsRow: "_resourcesWeekViewDayLabelsRow_jzd1a_67",
+	resourcesWeekViewDayLabel: "_resourcesWeekViewDayLabel_jzd1a_67",
+	resourcesWeekViewTimeLabelsRow: "_resourcesWeekViewTimeLabelsRow_jzd1a_94",
+	resourcesWeekViewTimeLabel: "_resourcesWeekViewTimeLabel_jzd1a_94",
+	resourcesWeekViewRow: "_resourcesWeekViewRow_jzd1a_121",
+	resourcesWeekViewResourceLabel: "_resourcesWeekViewResourceLabel_jzd1a_125",
+	resourcesWeekViewGroupColumn: "_resourcesWeekViewGroupColumn_jzd1a_149",
+	resourcesWeekViewGroupColumnEmpty: "_resourcesWeekViewGroupColumnEmpty_jzd1a_150",
+	resourcesWeekViewRowSlots: "_resourcesWeekViewRowSlots_jzd1a_178",
+	resourcesWeekViewRowSlot: "_resourcesWeekViewRowSlot_jzd1a_178",
+	resourcesWeekViewBackgroundEvent: "_resourcesWeekViewBackgroundEvent_jzd1a_250",
+	resourcesWeekViewAllDayEvent: "_resourcesWeekViewAllDayEvent_jzd1a_262",
+	resourcesWeekViewEventWrapper: "_resourcesWeekViewEventWrapper_jzd1a_267",
+	resourcesWeekViewResizeHandle: "_resourcesWeekViewResizeHandle_jzd1a_271",
+	resourcesWeekViewCurrentTimeIndicator: "_resourcesWeekViewCurrentTimeIndicator_jzd1a_312",
+	resourcesWeekViewCurrentTimeIndicatorLine: "_resourcesWeekViewCurrentTimeIndicatorLine_jzd1a_324",
+	resourcesWeekViewCurrentTimeIndicatorThumb: "_resourcesWeekViewCurrentTimeIndicatorThumb_jzd1a_330",
+	resourcesWeekViewCurrentTimeIndicatorTimeBubble: "_resourcesWeekViewCurrentTimeIndicatorTimeBubble_jzd1a_340"
+};
+//#endregion
+//#region src/components/ResourcesWeekView/ResourcesWeekView.ts
+function cssSize$1(value) {
+	return typeof value === "number" ? `${value}px` : value;
+}
+var ResourcesWeekView = (0, vue.defineComponent)({
+	name: "ResourcesWeekView",
+	inheritAttrs: false,
+	slots: Object,
+	props: {
+		date: {
+			type: [String, Date],
+			required: true
+		},
+		onDateChange: Function,
+		resources: {
+			type: Array,
+			required: true
+		},
+		startTime: {
+			type: String,
+			default: "00:00:00"
+		},
+		endTime: {
+			type: String,
+			default: "23:59:59"
+		},
+		intervalMinutes: {
+			type: Number,
+			default: 60
+		},
+		slotLabelFormat: {
+			type: [String, Function],
+			default: "HH:mm"
+		},
+		radius: [String, Number],
+		startScrollDateTime: String,
+		scrollAreaProps: Object,
+		locale: String,
+		withCurrentTimeIndicator: {
+			type: Boolean,
+			default: void 0
+		},
+		withCurrentTimeBubble: {
+			type: Boolean,
+			default: true
+		},
+		getCurrentTime: Function,
+		withHeader: {
+			type: Boolean,
+			default: true
+		},
+		onViewChange: Function,
+		previousControlProps: Object,
+		nextControlProps: Object,
+		todayControlProps: Object,
+		viewSelectProps: Object,
+		weekLabelFormat: {
+			type: [String, Function],
+			default: "MMM DD"
+		},
+		renderWeekLabel: Function,
+		events: Array,
+		slotWidth: {
+			type: [String, Number],
+			default: 60
+		},
+		rowHeight: {
+			type: [String, Number],
+			default: 64
+		},
+		labels: Object,
+		highlightBusinessHours: Boolean,
+		businessHours: {
+			type: Array,
+			default: () => ["09:00:00", "17:00:00"]
+		},
+		renderEventBody: Function,
+		renderEvent: Function,
+		renderResourceLabel: Function,
+		groups: Array,
+		renderGroupLabel: Function,
+		groupLabelWidth: {
+			type: [String, Number],
+			default: 80
+		},
+		withEventsDragAndDrop: Boolean,
+		onEventDrop: Function,
+		canDragEvent: Function,
+		onEventDragStart: Function,
+		onEventDragEnd: Function,
+		onTimeSlotClick: Function,
+		onEventClick: Function,
+		withDragSlotSelect: Boolean,
+		onSlotDragEnd: Function,
+		mode: {
+			type: String,
+			default: "default"
+		},
+		onExternalEventDrop: Function,
+		withEventResize: Boolean,
+		onEventResize: Function,
+		canResizeEvent: Function,
+		recurrenceExpansionLimit: {
+			type: Number,
+			default: 2e3
+		},
+		maxEventsPerTimeSlot: {
+			type: Number,
+			default: 2
+		},
+		moreEventsProps: Object,
+		firstDayOfWeek: {
+			type: Number,
+			default: 1
+		},
+		weekendDays: {
+			type: Array,
+			default: () => [0, 6]
+		},
+		withWeekendDays: {
+			type: Boolean,
+			default: true
+		},
+		weekdayFormat: {
+			type: [String, Function],
+			default: "ddd D"
+		},
+		highlightToday: {
+			type: Boolean,
+			default: true
+		}
+	},
+	setup(props, { attrs, slots }) {
+		const theme = (0, _mantine_vue_core.useSafeMantineTheme)();
+		const controls = [];
+		const rootElement = (0, vue.ref)(null);
+		const rowContainers = /* @__PURE__ */ new Map();
+		const dropTarget = (0, vue.ref)(null);
+		const scrolledX = (0, vue.ref)(false);
+		const intervals = (0, vue.computed)(() => getDayTimeIntervals({
+			startTime: props.startTime,
+			endTime: props.endTime,
+			intervalMinutes: props.intervalMinutes
+		}));
+		const weekdays = (0, vue.computed)(() => getWeekDays({
+			week: props.date,
+			firstDayOfWeek: props.firstDayOfWeek,
+			weekendDays: props.weekendDays,
+			withWeekendDays: props.withWeekendDays
+		}).map((day) => (0, dayjs.default)(day).format("YYYY-MM-DD")));
+		const ordered = (0, vue.computed)(() => getOrderedResources(props.resources, props.groups));
+		const resourceIdMap = (0, vue.computed)(() => getGroupToResourceIdMap(props.resources));
+		const weekEvents = (0, vue.computed)(() => getResourcesWeekViewEvents({
+			events: props.events,
+			resources: props.resources,
+			weekdays: weekdays.value,
+			startTime: props.startTime,
+			endTime: props.endTime,
+			intervalMinutes: props.intervalMinutes,
+			expansionLimit: props.recurrenceExpansionLimit
+		}));
+		(0, vue.onMounted)(async () => {
+			if (!props.startScrollDateTime) return;
+			await (0, vue.nextTick)();
+			const target = (0, dayjs.default)(props.startScrollDateTime);
+			const dayIndex = weekdays.value.findIndex((day) => (0, dayjs.default)(day).isSame(target, "day"));
+			if (dayIndex < 0) return;
+			const targetTime = target.format("HH:mm:ss");
+			const intervalIndex = intervals.value.findIndex((interval) => interval.startTime >= targetTime);
+			if (intervalIndex < 0) return;
+			const flatIndex = dayIndex * intervals.value.length + intervalIndex;
+			const targetSlot = controls[0]?.[flatIndex];
+			const viewport = rootElement.value?.querySelector(".mantine-ScrollArea-viewport");
+			if (targetSlot && viewport) {
+				viewport.scrollLeft = targetSlot.offsetLeft;
+				requestAnimationFrame(() => viewport.scrollLeft = targetSlot.offsetLeft);
+			}
+		});
+		const slotSelect = useSlotDragSelect({
+			enabled: () => props.withDragSlotSelect && props.mode !== "static",
+			onDragEnd: () => (start, end, group) => {
+				const count = intervals.value.length;
+				const startDay = Math.floor(start / count);
+				const endDay = Math.floor(end / count);
+				const first = intervals.value[start % count];
+				const last = intervals.value[end % count];
+				if (first && last && weekdays.value[startDay] && weekdays.value[endDay]) props.onSlotDragEnd?.({
+					rangeStart: `${(0, dayjs.default)(weekdays.value[startDay]).format("YYYY-MM-DD")} ${first.startTime}`,
+					rangeEnd: `${(0, dayjs.default)(weekdays.value[endDay]).format("YYYY-MM-DD")} ${last.endTime}`,
+					resourceId: resourceIdMap.value.get(group)
+				});
+			}
+		});
+		const resize = useHorizontalEventResize({
+			enabled: () => props.withEventResize,
+			mode: () => props.mode,
+			startTime: () => props.startTime,
+			endTime: () => props.endTime,
+			intervalMinutes: () => props.intervalMinutes,
+			onEventResize: () => props.onEventResize,
+			canResizeEvent: () => props.canResizeEvent
+		});
+		const emitDrop = (nativeEvent, resourceId, flatIndex) => {
+			nativeEvent.preventDefault();
+			dropTarget.value = null;
+			const count = intervals.value.length;
+			const day = weekdays.value[Math.floor(flatIndex / count)];
+			const interval = intervals.value[flatIndex % count];
+			if (!day || !interval) return;
+			const target = `${(0, dayjs.default)(day).format("YYYY-MM-DD")} ${interval.startTime}`;
+			const event = getDropEvent(props.events, nativeEvent.dataTransfer);
+			if (event) props.onEventDrop?.({
+				...moveEventTo(event, target),
+				resourceId
+			});
+			else if (nativeEvent.dataTransfer) props.onExternalEventDrop?.({
+				dataTransfer: nativeEvent.dataTransfer,
+				dropDateTime: target,
+				resourceId
+			});
+		};
+		const getFlatIndexAtPoint = (nativeEvent, resourceIndex) => {
+			const container = rowContainers.get(resourceIndex);
+			const count = intervals.value.length * weekdays.value.length;
+			if (!container || count === 0) return -1;
+			const rect = container.getBoundingClientRect();
+			if (rect.width <= 0) return -1;
+			return Math.max(0, Math.min(count - 1, Math.floor((nativeEvent.clientX - rect.left) / rect.width * count)));
+		};
+		const groupCell = (info) => {
+			if (info === void 0) return null;
+			if (info === null) return (0, vue.h)(_mantine_vue_core.Box, { class: ResourcesWeekView_module_default.resourcesWeekViewGroupColumnEmpty });
+			const starts = info.position === "first" || info.position === "only";
+			return (0, vue.h)(_mantine_vue_core.Box, {
+				class: ResourcesWeekView_module_default.resourcesWeekViewGroupColumn,
+				"data-group-position": info.position
+			}, () => starts ? (0, vue.h)("span", { style: info.count > 1 ? { transform: `translateY(calc((${info.count - 1} * (var(--resources-week-view-row-height) + 1px)) / 2))` } : void 0 }, slots.groupLabel?.({ group: info.group }) ?? props.renderGroupLabel?.(info.group) ?? info.group.label ?? void 0) : null);
+		};
+		return () => {
+			const dayCount = weekdays.value.length;
+			const slotsPerDay = intervals.value.length;
+			const hasGroups = ordered.value.groupRanges.length > 0;
+			const now = (0, dayjs.default)(props.getCurrentTime?.() ?? /* @__PURE__ */ new Date());
+			const todayIndex = weekdays.value.findIndex((day) => (0, dayjs.default)(day).isSame(now, "day"));
+			const showIndicator = (props.withCurrentTimeIndicator ?? todayIndex !== -1) && todayIndex !== -1 && isInTimeRange({
+				date: now.toDate(),
+				startTime: props.startTime,
+				endTime: props.endTime
+			});
+			const indicatorOffset = (todayIndex + getCurrentTimePosition({
+				startTime: props.startTime,
+				endTime: props.endTime,
+				intervalMinutes: props.intervalMinutes,
+				now
+			}) / 100) / dayCount * 100;
+			const currentTime = formatDate({
+				date: now,
+				locale: props.locale || "en",
+				format: props.slotLabelFormat
+			});
+			const dayLabels = weekdays.value.map((day) => {
+				const label = formatDate({
+					date: day,
+					locale: props.locale || "en",
+					format: props.weekdayFormat
+				});
+				return (0, vue.h)(_mantine_vue_core.Box, {
+					key: day,
+					class: ResourcesWeekView_module_default.resourcesWeekViewDayLabel,
+					style: { flex: `0 0 calc(var(--resources-week-view-slot-width) * ${slotsPerDay})` },
+					"data-weekend": props.weekendDays.includes((0, dayjs.default)(day).day()) || void 0,
+					"data-today": props.highlightToday && (0, dayjs.default)(day).isSame(now, "day") || void 0
+				}, () => slots.dayLabel?.({
+					date: day,
+					label
+				}) ?? label);
+			});
+			const timeLabels = weekdays.value.flatMap((day) => intervals.value.map((interval) => {
+				const label = formatDate({
+					date: `${day} ${interval.startTime}`,
+					locale: props.locale || "en",
+					format: props.slotLabelFormat
+				});
+				const mod = getBusinessHoursMod({
+					time: interval.startTime,
+					businessHours: props.businessHours,
+					highlightBusinessHours: props.highlightBusinessHours,
+					dayOfWeek: (0, dayjs.default)(day).day()
+				});
+				return (0, vue.h)(_mantine_vue_core.Box, {
+					key: `${day}-${interval.startTime}`,
+					class: ResourcesWeekView_module_default.resourcesWeekViewTimeLabel,
+					"data-business-hours": mod["business-hours"] || void 0,
+					"data-non-business-hours": mod["non-business-hours"] || void 0
+				}, () => slots.timeLabel?.({
+					date: day,
+					label,
+					startTime: interval.startTime,
+					endTime: interval.endTime
+				}) ?? label);
+			}));
+			const rows = ordered.value.orderedResources.map((resource, resourceIndex) => {
+				const background = [];
+				const regular = [];
+				const more = [];
+				weekdays.value.forEach((day, dayIndex) => {
+					const data = weekEvents.value.byDay[day];
+					const dayOffset = dayIndex / dayCount * 100;
+					const dayWidth = 100 / dayCount;
+					[...data.backgroundTimedEvents[resource.id] || [], ...data.backgroundAllDayEvents[resource.id] || []].forEach((event) => {
+						const colors = theme.value.variantColorResolver({
+							color: event.color || theme.value.primaryColor,
+							theme: theme.value,
+							variant: "light",
+							autoContrast: true
+						});
+						background.push(slots.backgroundEvent?.({
+							event,
+							date: day
+						}) ?? (0, vue.h)(_mantine_vue_core.Box, {
+							key: `bg-${day}-${event.id}`,
+							class: ResourcesWeekView_module_default.resourcesWeekViewBackgroundEvent,
+							style: {
+								left: `${dayOffset + event.position.top / 100 * dayWidth}%`,
+								width: `${event.position.height / 100 * dayWidth}%`,
+								top: 0,
+								height: "100%",
+								"--bg-event-bg": colors.background,
+								"--bg-event-color": colors.color
+							}
+						}, () => props.renderEventBody?.(event) ?? slots.eventBody?.({ event }) ?? event.title));
+					});
+					const allRegular = data.regularEvents[resource.id] || [];
+					allRegular.filter((event) => event.position.column < Math.max(1, props.maxEventsPerTimeSlot)).forEach((event) => {
+						const colors = theme.value.variantColorResolver({
+							color: event.color || theme.value.primaryColor,
+							theme: theme.value,
+							variant: event.variant || "light",
+							autoContrast: true
+						});
+						const position = resize.getResizePosition(event.id);
+						const relativeLeft = position?.left ?? event.position.top;
+						const relativeWidth = position?.width ?? event.position.height;
+						const isResizable = resize.isResizableEvent(event);
+						regular.push((0, vue.h)(_mantine_vue_core.Box, {
+							key: `${day}-${event.id}`,
+							class: ResourcesWeekView_module_default.resourcesWeekViewEventWrapper,
+							"data-resizing": position !== null || void 0,
+							style: {
+								"--event-color": colors.color,
+								left: `calc(${dayOffset + relativeLeft / 100 * dayWidth}% + 1px)`,
+								width: `calc(${relativeWidth / 100 * dayWidth}% - 2px)`,
+								top: `${event.position.offset}%`,
+								height: `${event.position.width}%`
+							}
+						}, () => [(0, vue.h)(ScheduleEvent, {
+							event,
+							autoSize: true,
+							nowrap: true,
+							radius: props.radius,
+							mode: props.mode,
+							renderEvent: props.renderEvent,
+							renderEventBody: props.renderEventBody,
+							draggable: props.withEventsDragAndDrop && props.mode !== "static" && (props.canDragEvent?.(event) ?? true),
+							onEventDragStart: props.onEventDragStart,
+							onEventDragEnd: props.onEventDragEnd,
+							onClick: props.mode === "static" ? void 0 : (nativeEvent) => {
+								if (!resize.wasResizing()) props.onEventClick?.(event, nativeEvent);
+							},
+							style: {
+								width: "100%",
+								height: "100%"
+							}
+						}, forwardEventSlots(slots)), isResizable ? ["start", "end"].map((edge) => (0, vue.h)("div", {
+							class: ResourcesWeekView_module_default.resourcesWeekViewResizeHandle,
+							"data-edge": edge,
+							"data-active": resize.state.value?.edge === edge || void 0,
+							"aria-label": `${edge === "start" ? "Resize event start" : "Resize event end"} ${event.title}`,
+							onDragstart: (nativeEvent) => nativeEvent.preventDefault(),
+							onPointerdown: (pointerEvent) => {
+								const container = rowContainers.get(resourceIndex);
+								if (container) resize.handleResizeStart({
+									event,
+									edge,
+									container,
+									originalLeft: event.position.top,
+									originalWidth: event.position.height,
+									eventDate: (0, dayjs.default)(day).format("YYYY-MM-DD"),
+									dayIndex,
+									dayCount,
+									pointerEvent
+								});
+							}
+						})) : null]));
+					});
+					getOverlapClusters(allRegular).filter((cluster) => cluster.some((event) => event.position.column >= props.maxEventsPerTimeSlot)).forEach((cluster) => {
+						const hiddenCount = cluster.filter((event) => event.position.column >= props.maxEventsPerTimeSlot).length;
+						const left = Math.min(...cluster.map((event) => event.position.top));
+						const right = Math.max(...cluster.map((event) => event.position.top + event.position.height));
+						more.push(slots.moreEvents?.({
+							events: cluster,
+							hiddenCount,
+							date: day
+						}) ?? (0, vue.h)(MoreEvents, {
+							...props.moreEventsProps,
+							key: `more-${day}-${cluster[0].id}`,
+							events: cluster,
+							moreEventsCount: hiddenCount,
+							mode: props.mode,
+							labels: props.labels,
+							renderEventBody: props.renderEventBody,
+							renderEvent: props.renderEvent,
+							onEventClick: props.onEventClick,
+							style: {
+								position: "absolute",
+								left: `calc(${dayOffset + left / 100 * dayWidth}% + 1px)`,
+								width: `calc(${(right - left) / 100 * dayWidth}% - 2px)`,
+								bottom: 0,
+								height: "22px",
+								zIndex: 4
+							}
+						}, forwardEventSlots(slots)));
+					});
+				});
+				const allDayBars = weekEvents.value.allDayBars[resource.id] || [];
+				const allDay = allDayBars.map((bar) => (0, vue.h)(_mantine_vue_core.Box, {
+					key: `all-${bar.event.id}`,
+					class: ResourcesWeekView_module_default.resourcesWeekViewAllDayEvent,
+					style: {
+						left: `calc(${bar.startDayIndex / dayCount * 100}% + 1px)`,
+						width: `calc(${(bar.endDayIndex - bar.startDayIndex + 1) / dayCount * 100}% - 2px)`,
+						top: `calc(${bar.row} * (var(--resources-week-view-all-day-height) + 2px) + 2px)`
+					}
+				}, () => slots.allDayEvent?.({
+					event: bar.event,
+					startDayIndex: bar.startDayIndex,
+					endDayIndex: bar.endDayIndex
+				}) ?? (0, vue.h)(ScheduleEvent, {
+					event: bar.event,
+					autoSize: true,
+					nowrap: true,
+					radius: props.radius,
+					mode: props.mode,
+					renderEvent: props.renderEvent,
+					renderEventBody: props.renderEventBody,
+					onClick: props.mode === "static" ? void 0 : (nativeEvent) => props.onEventClick?.(bar.event, nativeEvent),
+					style: {
+						width: "100%",
+						height: "100%"
+					}
+				}, forwardEventSlots(slots))));
+				const slotGroup = String(resource.id);
+				const buttons = weekdays.value.flatMap((day, dayIndex) => intervals.value.map((interval, slotIndex) => {
+					const flatIndex = dayIndex * slotsPerDay + slotIndex;
+					const mod = getBusinessHoursMod({
+						time: interval.startTime,
+						businessHours: props.businessHours,
+						highlightBusinessHours: props.highlightBusinessHours,
+						dayOfWeek: (0, dayjs.default)(day).day()
+					});
+					return (0, vue.h)(_mantine_vue_core.UnstyledButton, {
+						key: `${day}-${interval.startTime}`,
+						ref: (element) => {
+							const button = element?.$el ?? element;
+							controls[resourceIndex] ||= [];
+							controls[resourceIndex][flatIndex] = button instanceof HTMLButtonElement ? button : void 0;
+						},
+						class: ResourcesWeekView_module_default.resourcesWeekViewRowSlot,
+						"data-business-hours": mod["business-hours"] || void 0,
+						"data-non-business-hours": mod["non-business-hours"] || void 0,
+						"data-drop-target": dropTarget.value?.resourceId === resource.id && dropTarget.value.flatIndex === flatIndex ? true : void 0,
+						"data-drag-selected": slotSelect.isSlotSelected(flatIndex, slotGroup) || void 0,
+						"data-static": props.mode === "static" || void 0,
+						"data-drag-slot-index": props.withDragSlotSelect ? flatIndex : void 0,
+						"data-drag-slot-group": props.withDragSlotSelect ? slotGroup : void 0,
+						"aria-label": `${getLabel("resourceSlot", props.labels)} ${String(resource.label)} ${day} ${interval.startTime} - ${interval.endTime}`,
+						tabindex: props.mode === "static" ? -1 : resourceIndex === 0 && flatIndex === 0 ? 0 : -1,
+						onKeydown: (event) => handleResourcesGridKeyDown({
+							controls,
+							resourceIndex,
+							slotIndex: flatIndex,
+							event
+						}),
+						onPointerdown: props.mode === "static" ? void 0 : (event) => slotSelect.handleSlotPointerDown(event, flatIndex, slotGroup),
+						onClick: props.mode === "static" ? void 0 : (nativeEvent) => props.onTimeSlotClick?.({
+							slotStart: `${day} ${interval.startTime}`,
+							slotEnd: `${day} ${interval.endTime}`,
+							nativeEvent,
+							resourceId: resource.id
+						})
+					}, () => slots.timeSlot?.({
+						resource,
+						date: day,
+						startTime: interval.startTime,
+						endTime: interval.endTime
+					}));
+				}));
+				const info = hasGroups ? ordered.value.resourceGroupMap[resourceIndex] : void 0;
+				const allDayRows = allDayBars.length ? Math.max(...allDayBars.map((bar) => bar.row)) + 1 : 0;
+				return (0, vue.h)(_mantine_vue_core.Box, {
+					key: resource.id,
+					class: ResourcesWeekView_module_default.resourcesWeekViewRow
+				}, () => [
+					groupCell(info),
+					(0, vue.h)(_mantine_vue_core.Box, {
+						class: ResourcesWeekView_module_default.resourcesWeekViewResourceLabel,
+						"data-scrolled-x": scrolledX.value || void 0,
+						"data-has-groups": info !== void 0 || void 0
+					}, () => slots.resourceLabel?.({ resource }) ?? props.renderResourceLabel?.(resource) ?? resource.label),
+					(0, vue.h)(_mantine_vue_core.Box, {
+						class: ResourcesWeekView_module_default.resourcesWeekViewRowSlots,
+						ref: (element) => {
+							const node = element?.$el ?? element;
+							if (node instanceof HTMLElement) rowContainers.set(resourceIndex, node);
+						},
+						style: allDayRows ? { minHeight: `max(var(--resources-week-view-row-height), calc(${allDayRows} * (var(--resources-week-view-all-day-height) + 2px) + 4px))` } : void 0,
+						onDragover: props.withEventsDragAndDrop || props.onExternalEventDrop ? (nativeEvent) => {
+							if (props.mode === "static") return;
+							nativeEvent.preventDefault();
+							const flatIndex = getFlatIndexAtPoint(nativeEvent, resourceIndex);
+							if (flatIndex >= 0 && (dropTarget.value?.resourceId !== resource.id || dropTarget.value.flatIndex !== flatIndex)) dropTarget.value = {
+								resourceId: resource.id,
+								flatIndex
+							};
+						} : void 0,
+						onDragleave: props.withEventsDragAndDrop || props.onExternalEventDrop ? (nativeEvent) => {
+							const related = nativeEvent.relatedTarget;
+							const current = nativeEvent.currentTarget;
+							if (!(related instanceof Node) || !(current instanceof HTMLElement) || !current.contains(related)) dropTarget.value = null;
+						} : void 0,
+						onDrop: props.withEventsDragAndDrop || props.onExternalEventDrop ? (nativeEvent) => {
+							const flatIndex = getFlatIndexAtPoint(nativeEvent, resourceIndex);
+							if (flatIndex >= 0) emitDrop(nativeEvent, resource.id, flatIndex);
+						} : void 0
+					}, () => [
+						...background,
+						...allDay,
+						...regular,
+						...more,
+						...buttons
+					])
+				]);
+			});
+			const weekStart = (0, dayjs.default)(weekdays.value[0]).format("YYYY-MM-DD");
+			const weekEnd = (0, dayjs.default)(weekdays.value.at(-1)).format("YYYY-MM-DD");
+			const headerLabel = props.renderWeekLabel?.({
+				weekStart,
+				weekEnd
+			}) ?? getWeekLabel({
+				weekdays: weekdays.value,
+				locale: props.locale || "en",
+				weekLabelFormat: props.weekLabelFormat
+			});
+			const header = props.withHeader ? slots.header?.({
+				weekStart,
+				weekEnd,
+				label: headerLabel
+			}) ?? (0, vue.h)(ScheduleHeaderBase, {
+				view: "week",
+				navigationHandlers: {
+					previous: () => (0, dayjs.default)(props.date).subtract(1, "week").format("YYYY-MM-DD"),
+					next: () => (0, dayjs.default)(props.date).add(1, "week").format("YYYY-MM-DD"),
+					today: () => now.format("YYYY-MM-DD")
+				},
+				control: { title: headerLabel },
+				labels: props.labels,
+				onDateChange: props.onDateChange,
+				onViewChange: props.onViewChange,
+				previousControlProps: props.previousControlProps,
+				nextControlProps: props.nextControlProps,
+				todayControlProps: props.todayControlProps,
+				viewSelectProps: {
+					views: [
+						"day",
+						"week",
+						"month"
+					],
+					...props.viewSelectProps
+				}
+			}) : null;
+			const indicator = showIndicator ? slots.currentTimeIndicator?.({
+				time: currentTime,
+				offset: indicatorOffset,
+				date: weekdays.value[todayIndex]
+			}) ?? (0, vue.h)(_mantine_vue_core.Box, {
+				class: ResourcesWeekView_module_default.resourcesWeekViewCurrentTimeIndicator,
+				style: {
+					"--indicator-left-offset": hasGroups ? `calc(var(--resources-week-view-resource-label-width) + var(--resources-week-view-group-label-width) + (100% - var(--resources-week-view-resource-label-width) - var(--resources-week-view-group-label-width)) * ${indicatorOffset} / 100)` : `calc(var(--resources-week-view-resource-label-width) + (100% - var(--resources-week-view-resource-label-width)) * ${indicatorOffset} / 100)`,
+					"--_time-bubble-width": String(currentTime).toLowerCase().includes("m") ? "64px" : "46px"
+				}
+			}, () => [props.withCurrentTimeBubble ? (0, vue.h)("div", { class: ResourcesWeekView_module_default.resourcesWeekViewCurrentTimeIndicatorTimeBubble }, currentTime) : (0, vue.h)("div", { class: ResourcesWeekView_module_default.resourcesWeekViewCurrentTimeIndicatorThumb }), (0, vue.h)("div", { class: ResourcesWeekView_module_default.resourcesWeekViewCurrentTimeIndicatorLine })]) : null;
+			return (0, vue.h)(_mantine_vue_core.Box, {
+				...attrs,
+				ref: (element) => {
+					const node = element?.$el ?? element;
+					rootElement.value = node instanceof HTMLElement ? node : null;
+				},
+				class: [ResourcesWeekView_module_default.resourcesWeekView, attrs.class],
+				style: [{
+					"--resources-week-view-radius": resolveScheduleRadius(props.radius),
+					"--resources-week-view-slot-width": cssSize$1(props.slotWidth),
+					"--resources-week-view-row-height": cssSize$1(props.rowHeight),
+					"--resources-week-view-group-label-width": cssSize$1(props.groupLabelWidth)
+				}, attrs.style],
+				"data-resizing": resize.state.value ? true : void 0,
+				"data-event-interaction": resize.state.value ? true : void 0
+			}, () => [header, (0, vue.h)(_mantine_vue_core.Box, { class: ResourcesWeekView_module_default.resourcesWeekViewRoot }, () => (0, vue.h)(_mantine_vue_core.ScrollArea, {
+				scrollbarSize: 4,
+				...props.scrollAreaProps,
+				class: ResourcesWeekView_module_default.resourcesWeekViewScrollArea,
+				onScrollPositionChange: (position) => scrolledX.value = position.x !== 0
+			}, () => (0, vue.h)("div", { class: ResourcesWeekView_module_default.resourcesWeekViewInner }, [
+				(0, vue.h)(_mantine_vue_core.Box, { class: ResourcesWeekView_module_default.resourcesWeekViewHeaderRows }, () => [(0, vue.h)("div", {
+					class: ResourcesWeekView_module_default.resourcesWeekViewCorner,
+					style: hasGroups ? {
+						flexBasis: "calc(var(--resources-week-view-resource-label-width) + var(--resources-week-view-group-label-width))",
+						minWidth: "calc(var(--resources-week-view-resource-label-width) + var(--resources-week-view-group-label-width))"
+					} : void 0
+				}, slots.corner?.({ resources: ordered.value.orderedResources }) ?? getLabel("resources", props.labels)), (0, vue.h)("div", { class: ResourcesWeekView_module_default.resourcesWeekViewHeaderContent }, [(0, vue.h)("div", { class: ResourcesWeekView_module_default.resourcesWeekViewDayLabelsRow }, dayLabels), (0, vue.h)("div", { class: ResourcesWeekView_module_default.resourcesWeekViewTimeLabelsRow }, timeLabels)])]),
+				...rows,
+				indicator
+			])))]);
+		};
+	}
+});
+var ResourcesMonthView_module_default = {
+	resourcesMonthView: "_resourcesMonthView_wgbmp_1",
+	resourcesMonthViewRoot: "_resourcesMonthViewRoot_wgbmp_17",
+	resourcesMonthViewScrollArea: "_resourcesMonthViewScrollArea_wgbmp_24",
+	resourcesMonthViewInner: "_resourcesMonthViewInner_wgbmp_33",
+	resourcesMonthViewDayLabelsRow: "_resourcesMonthViewDayLabelsRow_wgbmp_37",
+	resourcesMonthViewCorner: "_resourcesMonthViewCorner_wgbmp_46",
+	resourcesMonthViewDayLabel: "_resourcesMonthViewDayLabel_wgbmp_37",
+	resourcesMonthViewDayLabelWeekday: "_resourcesMonthViewDayLabelWeekday_wgbmp_85",
+	resourcesMonthViewDayLabelNumber: "_resourcesMonthViewDayLabelNumber_wgbmp_92",
+	resourcesMonthViewRow: "_resourcesMonthViewRow_wgbmp_97",
+	resourcesMonthViewResourceLabel: "_resourcesMonthViewResourceLabel_wgbmp_101",
+	resourcesMonthViewGroupColumn: "_resourcesMonthViewGroupColumn_wgbmp_120",
+	resourcesMonthViewGroupColumnEmpty: "_resourcesMonthViewGroupColumnEmpty_wgbmp_121",
+	resourcesMonthViewRowSlots: "_resourcesMonthViewRowSlots_wgbmp_149",
+	resourcesMonthViewCell: "_resourcesMonthViewCell_wgbmp_154"
+};
+//#endregion
+//#region src/components/ResourcesMonthView/ResourcesMonthView.ts
+var cssSize = (value) => typeof value === "number" ? `${value}px` : value;
+var isMulti = (event) => (0, dayjs.default)(event.end).startOf("day").isAfter((0, dayjs.default)(event.start).startOf("day"));
+var compareEvents = (a, b) => {
+	const aSpan = (0, dayjs.default)(a.end).startOf("day").diff((0, dayjs.default)(a.start).startOf("day"), "day");
+	const bSpan = (0, dayjs.default)(b.end).startOf("day").diff((0, dayjs.default)(b.start).startOf("day"), "day");
+	return aSpan === bSpan ? (0, dayjs.default)(a.start).valueOf() - (0, dayjs.default)(b.start).valueOf() : bSpan - aSpan;
+};
+var ResourcesMonthView = (0, vue.defineComponent)({
+	name: "ResourcesMonthView",
+	inheritAttrs: false,
+	slots: Object,
+	props: {
+		date: {
+			type: [String, Date],
+			required: true
+		},
+		onDateChange: Function,
+		resources: {
+			type: Array,
+			required: true
+		},
+		locale: String,
+		weekdayFormat: {
+			type: [String, Function],
+			default: "ddd"
+		},
+		weekendDays: {
+			type: Array,
+			default: () => [0, 6]
+		},
+		withWeekendDays: {
+			type: Boolean,
+			default: true
+		},
+		startScrollDate: String,
+		onDayClick: Function,
+		highlightToday: {
+			type: Boolean,
+			default: true
+		},
+		radius: [String, Number],
+		withHeader: {
+			type: Boolean,
+			default: true
+		},
+		monthYearSelectProps: Object,
+		onViewChange: Function,
+		previousControlProps: Object,
+		nextControlProps: Object,
+		todayControlProps: Object,
+		viewSelectProps: Object,
+		events: Array,
+		dayWidth: {
+			type: [String, Number],
+			default: 80
+		},
+		rowHeight: {
+			type: [String, Number],
+			default: 64
+		},
+		renderEventBody: Function,
+		renderEvent: Function,
+		renderResourceLabel: Function,
+		groups: Array,
+		renderGroupLabel: Function,
+		groupLabelWidth: {
+			type: [String, Number],
+			default: 80
+		},
+		withEventsDragAndDrop: Boolean,
+		onEventDrop: Function,
+		canDragEvent: Function,
+		onEventDragStart: Function,
+		onEventDragEnd: Function,
+		onEventClick: Function,
+		withDragSlotSelect: Boolean,
+		onSlotDragEnd: Function,
+		labels: Object,
+		mode: {
+			type: String,
+			default: "default"
+		},
+		scrollAreaProps: Object,
+		onExternalEventDrop: Function,
+		maxEventsPerTimeSlot: {
+			type: Number,
+			default: 2
+		},
+		moreEventsProps: Object,
+		recurrenceExpansionLimit: {
+			type: Number,
+			default: 2e3
+		}
+	},
+	setup(props, { attrs, slots }) {
+		const controls = [];
+		const rowContainers = /* @__PURE__ */ new Map();
+		const rootElement = (0, vue.ref)(null);
+		const dropTarget = (0, vue.ref)(null);
+		const days = (0, vue.computed)(() => {
+			const month = (0, dayjs.default)(props.date).startOf("month");
+			return Array.from({ length: month.daysInMonth() }, (_, index) => month.date(index + 1)).filter((day) => props.withWeekendDays || !props.weekendDays.includes(day.day())).map((day) => day.format("YYYY-MM-DD"));
+		});
+		const ordered = (0, vue.computed)(() => getOrderedResources(props.resources, props.groups));
+		const idMap = (0, vue.computed)(() => getGroupToResourceIdMap(props.resources));
+		const expanded = (0, vue.computed)(() => expandRecurringEvents({
+			events: props.events,
+			rangeStart: (0, dayjs.default)(props.date).startOf("month").toDate(),
+			rangeEnd: (0, dayjs.default)(props.date).endOf("month").toDate(),
+			expansionLimit: props.recurrenceExpansionLimit
+		}));
+		const slotSelect = useSlotDragSelect({
+			enabled: () => props.withDragSlotSelect && props.mode !== "static",
+			onDragEnd: () => props.onSlotDragEnd ? (start, end, group) => {
+				const first = days.value[start];
+				const last = days.value[end];
+				if (first && last) props.onSlotDragEnd?.({
+					rangeStart: `${first} 00:00:00`,
+					rangeEnd: (0, dayjs.default)(last).endOf("day").format("YYYY-MM-DD HH:mm:ss"),
+					resourceId: idMap.value.get(group) ?? group
+				});
+			} : void 0
+		});
+		(0, vue.onMounted)(async () => {
+			if (!props.startScrollDate) return;
+			await (0, vue.nextTick)();
+			const index = days.value.indexOf((0, dayjs.default)(props.startScrollDate).format("YYYY-MM-DD"));
+			const target = controls[0]?.[index];
+			const viewport = rootElement.value?.querySelector(".mantine-ScrollArea-viewport");
+			if (target && viewport) {
+				viewport.scrollLeft = target.offsetLeft;
+				requestAnimationFrame(() => viewport.scrollLeft = target.offsetLeft);
+			}
+		});
+		const indexAtPoint = (event, resourceIndex) => {
+			const container = rowContainers.get(resourceIndex);
+			if (!container || !days.value.length) return -1;
+			const rect = container.getBoundingClientRect();
+			if (rect.width <= 0) return -1;
+			return Math.max(0, Math.min(days.value.length - 1, Math.floor((event.clientX - rect.left) / rect.width * days.value.length)));
+		};
+		const emitDrop = (event, resourceId, dayIndex) => {
+			event.preventDefault();
+			dropTarget.value = null;
+			const day = days.value[dayIndex];
+			if (!day) return;
+			const dragged = getDropEvent(expanded.value, event.dataTransfer);
+			if (dragged) {
+				const next = calculateMonthDropDate({
+					draggedEvent: dragged,
+					targetDay: day
+				});
+				props.onEventDrop?.({
+					eventId: dragged.id,
+					newStart: (0, dayjs.default)(next.start).format("YYYY-MM-DD HH:mm:ss"),
+					newEnd: (0, dayjs.default)(next.end).format("YYYY-MM-DD HH:mm:ss"),
+					event: dragged,
+					resourceId
+				});
+			} else if (event.dataTransfer) props.onExternalEventDrop?.({
+				dataTransfer: event.dataTransfer,
+				dropDateTime: `${day} 00:00:00`,
+				resourceId
+			});
+		};
+		return () => {
+			const maxRows = Math.min(10, Math.max(1, props.maxEventsPerTimeSlot));
+			const hasGroups = ordered.value.groupRanges.length > 0;
+			const monthStart = (0, dayjs.default)(days.value[0]).startOf("day");
+			const monthEnd = (0, dayjs.default)(days.value.at(-1)).add(1, "day").startOf("day");
+			const rows = ordered.value.orderedResources.map((resource, resourceIndex) => {
+				const eventsByDay = days.value.map((day) => (expanded.value || []).filter((event) => event.resourceId === resource.id && (0, dayjs.default)(event.start).isBefore((0, dayjs.default)(day).endOf("day")) && (0, dayjs.default)(event.end).isAfter((0, dayjs.default)(day).startOf("day"))).sort(compareEvents));
+				const layouts = [];
+				const lastRow = /* @__PURE__ */ new Map();
+				const rowByEvent = /* @__PURE__ */ new Map();
+				eventsByDay.forEach((eventList, dayIndex) => {
+					const used = /* @__PURE__ */ new Set();
+					const visible = [];
+					let hiddenCount = 0;
+					eventList.forEach((event) => {
+						let row = lastRow.get(event.id);
+						if (row === void 0 || row >= maxRows || used.has(row)) row = Array.from({ length: maxRows }, (_, i) => i).find((i) => !used.has(i));
+						if (row === void 0) {
+							hiddenCount++;
+							return;
+						}
+						used.add(row);
+						visible.push({
+							event,
+							row
+						});
+						lastRow.set(event.id, row);
+						if (!rowByEvent.has(event.id)) rowByEvent.set(event.id, /* @__PURE__ */ new Map());
+						rowByEvent.get(event.id).set(dayIndex, row);
+					});
+					layouts.push({
+						visible,
+						hiddenCount
+					});
+				});
+				const segments = [];
+				Array.from(new Map(eventsByDay.flat().filter(isMulti).map((event) => [event.id, event])).values()).forEach((event) => {
+					const rowsForEvent = rowByEvent.get(event.id);
+					let run = null;
+					const flush = () => {
+						if (!run) return;
+						const before = (0, dayjs.default)(event.start).isBefore(monthStart);
+						const after = (0, dayjs.default)(event.end).isAfter(monthEnd);
+						segments.push({
+							event,
+							...run,
+							hanging: before && after ? "both" : before ? "start" : after ? "end" : "none",
+							hidden: Array.from({ length: run.end - run.start + 1 }, (_, i) => layouts[run.start + i].hiddenCount > 0).some(Boolean)
+						});
+						run = null;
+					};
+					days.value.forEach((_day, index) => {
+						const row = rowsForEvent?.get(index);
+						if (row === void 0) flush();
+						else if (run && run.row === row && run.end === index - 1) run.end = index;
+						else {
+							flush();
+							run = {
+								start: index,
+								end: index,
+								row
+							};
+						}
+					});
+					flush();
+				});
+				const eventNodes = [];
+				layouts.forEach((layout, dayIndex) => layout.visible.forEach(({ event, row }) => {
+					if (isMulti(event)) return;
+					const compressed = layout.hiddenCount > 0 && props.mode !== "static";
+					eventNodes.push((0, vue.h)(ScheduleEvent, {
+						key: `${event.id}-${dayIndex}`,
+						event,
+						autoSize: true,
+						nowrap: true,
+						radius: props.radius,
+						mode: props.mode,
+						renderEvent: props.renderEvent,
+						renderEventBody: props.renderEventBody,
+						draggable: props.withEventsDragAndDrop && props.mode !== "static" && (props.canDragEvent?.(event) ?? true),
+						onEventDragStart: props.onEventDragStart,
+						onEventDragEnd: props.onEventDragEnd,
+						onClick: props.mode === "static" ? void 0 : (nativeEvent) => props.onEventClick?.(event, nativeEvent),
+						style: {
+							position: "absolute",
+							left: `calc(${dayIndex / days.value.length * 100}% + 1px)`,
+							width: `calc(${100 / days.value.length}% - 2px)`,
+							top: compressed ? `calc((100% - 18px) * ${row} / ${maxRows} + 1px)` : `calc(${row / maxRows * 100}% + 1px)`,
+							height: compressed ? `calc((100% - 18px) / ${maxRows} - 2px)` : `calc(${100 / maxRows}% - 2px)`,
+							zIndex: 3
+						}
+					}, forwardEventSlots(slots)));
+				}));
+				segments.forEach((segment) => eventNodes.push((0, vue.h)(ScheduleEvent, {
+					key: `${segment.event.id}-${segment.start}`,
+					event: segment.event,
+					hanging: segment.hanging,
+					autoSize: true,
+					nowrap: true,
+					radius: props.radius,
+					mode: props.mode,
+					renderEvent: props.renderEvent,
+					renderEventBody: props.renderEventBody,
+					draggable: props.withEventsDragAndDrop && props.mode !== "static" && (props.canDragEvent?.(segment.event) ?? true),
+					onEventDragStart: props.onEventDragStart,
+					onEventDragEnd: props.onEventDragEnd,
+					onClick: props.mode === "static" ? void 0 : (nativeEvent) => props.onEventClick?.(segment.event, nativeEvent),
+					style: {
+						position: "absolute",
+						left: `calc(${segment.start / days.value.length * 100}% + 1px)`,
+						width: `calc(${(segment.end - segment.start + 1) / days.value.length * 100}% - 2px)`,
+						top: segment.hidden ? `calc((100% - 18px) * ${segment.row} / ${maxRows} + 1px)` : `calc(${segment.row / maxRows * 100}% + 1px)`,
+						height: segment.hidden ? `calc((100% - 18px) / ${maxRows} - 2px)` : `calc(${100 / maxRows}% - 2px)`,
+						zIndex: 3
+					}
+				}, forwardEventSlots(slots))));
+				const moreNodes = layouts.map((layout, dayIndex) => layout.hiddenCount && props.mode !== "static" ? slots.moreEvents?.({
+					events: eventsByDay[dayIndex],
+					hiddenCount: layout.hiddenCount,
+					resource,
+					date: days.value[dayIndex]
+				}) ?? (0, vue.h)(MoreEvents, {
+					...props.moreEventsProps,
+					key: `more-${dayIndex}`,
+					events: eventsByDay[dayIndex],
+					moreEventsCount: layout.hiddenCount,
+					mode: props.mode,
+					labels: props.labels,
+					renderEvent: props.renderEvent,
+					renderEventBody: props.renderEventBody,
+					onEventClick: props.onEventClick,
+					style: {
+						position: "absolute",
+						bottom: "1px",
+						left: `calc(${dayIndex / days.value.length * 100}% + 1px)`,
+						width: `calc(${100 / days.value.length}% - 2px)`,
+						height: "18px",
+						zIndex: 4
+					}
+				}, forwardEventSlots(slots)) : null);
+				const group = hasGroups ? ordered.value.resourceGroupMap[resourceIndex] : void 0;
+				const groupCell = group === void 0 ? null : group === null ? (0, vue.h)(_mantine_vue_core.Box, { class: ResourcesMonthView_module_default.resourcesMonthViewGroupColumnEmpty }) : (0, vue.h)(_mantine_vue_core.Box, {
+					class: ResourcesMonthView_module_default.resourcesMonthViewGroupColumn,
+					"data-group-position": group.position
+				}, () => group.position === "first" || group.position === "only" ? (0, vue.h)("span", { style: group.count > 1 ? { transform: `translateY(calc((${group.count - 1} * (var(--resources-month-view-row-height) + 1px)) / 2))` } : void 0 }, slots.groupLabel?.({ group: group.group }) ?? props.renderGroupLabel?.(group.group) ?? group.group.label ?? void 0) : null);
+				const cells = days.value.map((day, dayIndex) => {
+					const weekend = props.weekendDays.includes((0, dayjs.default)(day).day());
+					const groupId = String(resource.id);
+					return (0, vue.h)(_mantine_vue_core.UnstyledButton, {
+						key: day,
+						ref: (element) => {
+							const button = element?.$el ?? element;
+							controls[resourceIndex] ||= [];
+							controls[resourceIndex][dayIndex] = button instanceof HTMLButtonElement ? button : void 0;
+						},
+						class: ResourcesMonthView_module_default.resourcesMonthViewCell,
+						"data-weekend": weekend || void 0,
+						"data-drop-target": dropTarget.value?.resourceId === resource.id && dropTarget.value.dayIndex === dayIndex || void 0,
+						"data-drag-selected": slotSelect.isSlotSelected(dayIndex, groupId) || void 0,
+						"data-static": props.mode === "static" || void 0,
+						"data-drag-slot-index": props.withDragSlotSelect ? dayIndex : void 0,
+						"data-drag-slot-group": props.withDragSlotSelect ? groupId : void 0,
+						tabindex: props.mode === "static" ? -1 : resourceIndex === 0 && dayIndex === 0 ? 0 : -1,
+						"aria-label": `${String(resource.label)} ${(0, dayjs.default)(day).format("MMMM D, YYYY")}`,
+						onKeydown: (event) => handleResourcesGridKeyDown({
+							controls,
+							resourceIndex,
+							slotIndex: dayIndex,
+							event
+						}),
+						onPointerdown: props.mode === "static" ? void 0 : (event) => slotSelect.handleSlotPointerDown(event, dayIndex, groupId),
+						onClick: props.mode === "static" ? void 0 : (nativeEvent) => props.onDayClick?.({
+							date: day,
+							nativeEvent,
+							resourceId: resource.id
+						})
+					}, () => slots.dayCell?.({
+						resource,
+						date: day
+					}));
+				});
+				return (0, vue.h)("div", {
+					class: ResourcesMonthView_module_default.resourcesMonthViewRow,
+					key: resource.id
+				}, [
+					groupCell,
+					(0, vue.h)("div", {
+						class: ResourcesMonthView_module_default.resourcesMonthViewResourceLabel,
+						"data-has-groups": hasGroups || void 0
+					}, slots.resourceLabel?.({ resource }) ?? props.renderResourceLabel?.(resource) ?? resource.label ?? void 0),
+					(0, vue.h)("div", {
+						class: ResourcesMonthView_module_default.resourcesMonthViewRowSlots,
+						ref: (element) => {
+							if (element instanceof HTMLElement) rowContainers.set(resourceIndex, element);
+						},
+						onDragover: props.mode !== "static" && (props.withEventsDragAndDrop || props.onExternalEventDrop) ? (event) => {
+							event.preventDefault();
+							const dayIndex = indexAtPoint(event, resourceIndex);
+							if (dayIndex >= 0 && (dropTarget.value?.resourceId !== resource.id || dropTarget.value.dayIndex !== dayIndex)) dropTarget.value = {
+								resourceId: resource.id,
+								dayIndex
+							};
+						} : void 0,
+						onDragleave: (event) => {
+							const current = event.currentTarget;
+							if (!(event.relatedTarget instanceof Node) || !(current instanceof HTMLElement) || !current.contains(event.relatedTarget)) dropTarget.value = null;
+						},
+						onDrop: props.mode !== "static" && (props.withEventsDragAndDrop || props.onExternalEventDrop) ? (event) => {
+							const dayIndex = indexAtPoint(event, resourceIndex);
+							if (dayIndex >= 0) emitDrop(event, resource.id, dayIndex);
+						} : void 0
+					}, [
+						...eventNodes,
+						...moreNodes,
+						...cells
+					])
+				]);
+			});
+			const month = (0, dayjs.default)(props.date).startOf("month");
+			const monthString = month.format("YYYY-MM-DD");
+			const header = props.withHeader ? slots.header?.({ month: monthString }) ?? (0, vue.h)(ScheduleHeaderBase, {
+				view: "month",
+				navigationHandlers: {
+					previous: () => month.subtract(1, "month").format("YYYY-MM-DD"),
+					next: () => month.add(1, "month").format("YYYY-MM-DD"),
+					today: () => (0, dayjs.default)().format("YYYY-MM-DD")
+				},
+				control: { monthYearSelect: {
+					locale: props.locale,
+					monthValue: month.month(),
+					yearValue: month.year(),
+					onMonthChange: (value) => props.onDateChange?.(month.month(value).format("YYYY-MM-DD")),
+					onYearChange: (value) => props.onDateChange?.(month.year(value).format("YYYY-MM-DD")),
+					...props.monthYearSelectProps
+				} },
+				labels: props.labels,
+				onDateChange: props.onDateChange,
+				onViewChange: props.onViewChange,
+				previousControlProps: props.previousControlProps,
+				nextControlProps: props.nextControlProps,
+				todayControlProps: props.todayControlProps,
+				viewSelectProps: {
+					views: [
+						"day",
+						"week",
+						"month"
+					],
+					...props.viewSelectProps
+				}
+			}) : null;
+			const labels = days.value.map((day) => {
+				const weekday = formatDate({
+					date: day,
+					locale: props.locale || "en",
+					format: props.weekdayFormat
+				});
+				return slots.dayLabel?.({
+					date: day,
+					weekday,
+					day: (0, dayjs.default)(day).date()
+				}) ?? (0, vue.h)("div", {
+					key: day,
+					class: ResourcesMonthView_module_default.resourcesMonthViewDayLabel,
+					"data-weekend": props.weekendDays.includes((0, dayjs.default)(day).day()) || void 0,
+					"data-today": props.highlightToday && (0, dayjs.default)(day).isSame((0, dayjs.default)(), "day") || void 0
+				}, [(0, vue.h)("span", { class: ResourcesMonthView_module_default.resourcesMonthViewDayLabelWeekday }, weekday), (0, vue.h)("span", { class: ResourcesMonthView_module_default.resourcesMonthViewDayLabelNumber }, (0, dayjs.default)(day).date())]);
+			});
+			return (0, vue.h)(_mantine_vue_core.Box, {
+				...attrs,
+				ref: (element) => {
+					const node = element?.$el ?? element;
+					rootElement.value = node instanceof HTMLElement ? node : null;
+				},
+				class: [ResourcesMonthView_module_default.resourcesMonthView, attrs.class],
+				style: [{
+					"--resources-month-view-radius": resolveScheduleRadius(props.radius),
+					"--resources-month-view-day-width": cssSize(props.dayWidth),
+					"--resources-month-view-row-height": cssSize(props.rowHeight),
+					"--resources-month-view-group-label-width": cssSize(props.groupLabelWidth)
+				}, attrs.style],
+				"data-event-interaction": dropTarget.value ? true : void 0
+			}, () => [header, (0, vue.h)(_mantine_vue_core.Box, { class: ResourcesMonthView_module_default.resourcesMonthViewRoot }, () => (0, vue.h)(_mantine_vue_core.ScrollArea, {
+				scrollbarSize: 4,
+				scrollbars: "x",
+				...props.scrollAreaProps,
+				class: ResourcesMonthView_module_default.resourcesMonthViewScrollArea
+			}, () => (0, vue.h)("div", { class: ResourcesMonthView_module_default.resourcesMonthViewInner }, [(0, vue.h)("div", { class: ResourcesMonthView_module_default.resourcesMonthViewDayLabelsRow }, [(0, vue.h)("div", {
+				class: ResourcesMonthView_module_default.resourcesMonthViewCorner,
+				style: hasGroups ? {
+					flexBasis: "calc(var(--resources-month-view-resource-label-width) + var(--resources-month-view-group-label-width))",
+					minWidth: "calc(var(--resources-month-view-resource-label-width) + var(--resources-month-view-group-label-width))"
+				} : void 0
+			}, slots.corner?.({ resources: ordered.value.orderedResources }) ?? getLabel("resources", props.labels)), ...labels]), ...rows])))]);
+		};
+	}
+});
+var ResourcesSchedule_module_default = { root: "_root_13xbl_1" };
+//#endregion
+//#region src/components/ResourcesSchedule/ResourcesSchedule.ts
+var ResourcesSchedule = (0, vue.defineComponent)({
+	name: "ResourcesSchedule",
+	inheritAttrs: false,
+	slots: Object,
+	props: {
+		resources: {
+			type: Array,
+			required: true
+		},
+		date: [String, Date],
+		defaultDate: [String, Date],
+		onDateChange: Function,
+		view: String,
+		defaultView: {
+			type: String,
+			default: "day"
+		},
+		onViewChange: Function,
+		events: Array,
+		locale: String,
+		radius: [String, Number],
+		labels: Object,
+		renderEventBody: Function,
+		renderResourceLabel: Function,
+		withEventsDragAndDrop: Boolean,
+		onEventDrop: Function,
+		canDragEvent: Function,
+		onEventDragStart: Function,
+		onEventDragEnd: Function,
+		onTimeSlotClick: Function,
+		onDayClick: Function,
+		onEventClick: Function,
+		withDragSlotSelect: Boolean,
+		onSlotDragEnd: Function,
+		mode: {
+			type: String,
+			default: "default"
+		},
+		onExternalEventDrop: Function,
+		withEventResize: Boolean,
+		onEventResize: Function,
+		canResizeEvent: Function,
+		recurrenceExpansionLimit: {
+			type: Number,
+			default: 2e3
+		},
+		dayViewProps: Object,
+		weekViewProps: Object,
+		monthViewProps: Object
+	},
+	setup(props, { attrs, slots }) {
+		const currentDate = (0, vue.ref)(toDateString(props.date ?? props.defaultDate ?? (0, dayjs.default)()));
+		const currentView = (0, vue.ref)(props.view ?? props.defaultView);
+		(0, vue.watch)(() => props.date, (value) => {
+			if (value !== void 0) currentDate.value = toDateString(value);
+		});
+		(0, vue.watch)(() => props.view, (value) => {
+			if (value !== void 0) currentView.value = value;
+		});
+		const changeDate = (date) => {
+			if (props.date === void 0) currentDate.value = date;
+			props.onDateChange?.(date);
+		};
+		const changeView = (view) => {
+			if (view !== "day" && view !== "week" && view !== "month") return;
+			if (props.view === void 0) currentView.value = view;
+			props.onViewChange?.(view);
+		};
+		return () => {
+			const isStatic = props.mode === "static";
+			const shared = {
+				resources: props.resources,
+				date: currentDate.value,
+				onDateChange: changeDate,
+				onViewChange: changeView,
+				events: props.events,
+				locale: props.locale,
+				radius: props.radius,
+				labels: props.labels,
+				renderEventBody: props.renderEventBody,
+				renderResourceLabel: props.renderResourceLabel,
+				withEventsDragAndDrop: isStatic ? false : props.withEventsDragAndDrop,
+				onEventDrop: props.onEventDrop,
+				canDragEvent: props.canDragEvent,
+				onEventDragStart: props.onEventDragStart,
+				onEventDragEnd: props.onEventDragEnd,
+				onEventClick: props.onEventClick,
+				withDragSlotSelect: props.withDragSlotSelect,
+				onSlotDragEnd: props.onSlotDragEnd,
+				onExternalEventDrop: props.onExternalEventDrop,
+				recurrenceExpansionLimit: props.recurrenceExpansionLimit,
+				mode: props.mode
+			};
+			const forwarded = {};
+			for (const key of Object.keys(slots)) {
+				const slot = slots[key];
+				if (typeof slot === "function") forwarded[key] = slot;
+			}
+			const forwardedSlots = Object.keys(forwarded).length ? forwarded : void 0;
+			const content = (() => {
+				switch (currentView.value) {
+					case "day": return (0, vue.h)(ResourcesDayView, {
+						...shared,
+						onTimeSlotClick: props.onTimeSlotClick,
+						withEventResize: isStatic ? false : props.withEventResize,
+						onEventResize: props.onEventResize,
+						canResizeEvent: props.canResizeEvent,
+						...props.dayViewProps
+					}, forwardedSlots);
+					case "week": return (0, vue.h)(ResourcesWeekView, {
+						...shared,
+						onTimeSlotClick: props.onTimeSlotClick,
+						withEventResize: isStatic ? false : props.withEventResize,
+						onEventResize: props.onEventResize,
+						canResizeEvent: props.canResizeEvent,
+						...props.weekViewProps
+					}, forwardedSlots);
+					case "month": return (0, vue.h)(ResourcesMonthView, {
+						...shared,
+						onDayClick: props.onDayClick,
+						...props.monthViewProps
+					}, forwardedSlots);
+					default: return null;
+				}
+			})();
+			return (0, vue.h)(_mantine_vue_core.Box, {
+				...attrs,
+				class: [ResourcesSchedule_module_default.root, attrs.class],
+				style: attrs.style
+			}, () => [content]);
+		};
+	}
+});
+//#endregion
 //#region src/components/DragContext/DragContext.ts
 var DragContext = Symbol("mantine-schedule-drag-context");
 function provideDragContext(value) {
@@ -4136,6 +6353,10 @@ exports.MobileMonthView = MobileMonthView;
 exports.MonthView = MonthView;
 exports.MonthYearSelect = MonthYearSelect;
 exports.MoreEvents = MoreEvents;
+exports.ResourcesDayView = ResourcesDayView;
+exports.ResourcesMonthView = ResourcesMonthView;
+exports.ResourcesSchedule = ResourcesSchedule;
+exports.ResourcesWeekView = ResourcesWeekView;
 exports.Schedule = Schedule;
 exports.ScheduleEvent = ScheduleEvent;
 exports.ScheduleHeader = ScheduleHeader;
@@ -4159,6 +6380,7 @@ exports.getDayPositionedEvents = getDayPositionedEvents;
 exports.getDayTimeIntervals = getDayTimeIntervals;
 exports.getDayViewEvents = getDayViewEvents;
 exports.getEndOfWeek = getEndOfWeek;
+exports.getGroupToResourceIdMap = getGroupToResourceIdMap;
 exports.getLabel = getLabel;
 exports.getMonthDays = getMonthDays;
 exports.getMonthPositionedEvents = getMonthPositionedEvents;
@@ -4166,7 +6388,11 @@ exports.getMonthRange = getMonthRange;
 exports.getMonthViewEvents = getMonthViewEvents;
 exports.getMonthsByQuarter = getMonthsByQuarter;
 exports.getMonthsList = getMonthsList;
+exports.getOrderedResources = getOrderedResources;
+exports.getOverlapClusters = getOverlapClusters;
 exports.getRenderableMonthEventSegments = getRenderableMonthEventSegments;
+exports.getResourcesDayViewEvents = getResourcesDayViewEvents;
+exports.getResourcesWeekViewEvents = getResourcesWeekViewEvents;
 exports.getStartOfWeek = getStartOfWeek;
 exports.getVisibleEvents = getVisibleEvents;
 exports.getWeekDays = getWeekDays;
@@ -4176,6 +6402,7 @@ exports.getWeekPositionedEvents = getWeekPositionedEvents;
 exports.getWeekViewEvents = getWeekViewEvents;
 exports.getWeekdaysNames = getWeekdaysNames;
 exports.getYearsList = getYearsList;
+exports.handleResourcesGridKeyDown = handleResourcesGridKeyDown;
 exports.isAfterMinDate = isAfterMinDate;
 exports.isAllDayEvent = isAllDayEvent;
 exports.isBeforeMaxDate = isBeforeMaxDate;