@mantine/schedule 9.3.2 → 9.4.1

package/cjs/components/ResourcesMonthView/ResourcesMonthView.cjs

@@ -0,0 +1,602 @@
+"use client";
+const require_runtime = require("../../_virtual/_rolldown/runtime.cjs");
+const require_labels = require("../../labels.cjs");
+const require_format_date = require("../../utils/format-date/format-date.cjs");
+const require_to_date_string = require("../../utils/to-date-string/to-date-string.cjs");
+const require_calculate_month_drop_date = require("../../utils/calculate-month-drop-date/calculate-month-drop-date.cjs");
+const require_expand_recurring_events = require("../../utils/expand-recurring-events/expand-recurring-events.cjs");
+const require_get_ordered_resources = require("../../utils/get-ordered-resources/get-ordered-resources.cjs");
+const require_get_group_to_resource_id_map = require("../../utils/get-group-to-resource-id-map/get-group-to-resource-id-map.cjs");
+const require_get_index_from_drag_point = require("../../utils/get-index-from-drag-point/get-index-from-drag-point.cjs");
+const require_use_drag_drop_handlers = require("../../hooks/use-drag-drop-handlers.cjs");
+const require_use_slot_drag_select = require("../../hooks/use-slot-drag-select.cjs");
+const require_DragContext = require("../DragContext/DragContext.cjs");
+const require_ScheduleEvent = require("../ScheduleEvent/ScheduleEvent.cjs");
+const require_MoreEvents = require("../MoreEvents/MoreEvents.cjs");
+const require_ScheduleHeaderBase = require("../ScheduleHeader/ScheduleHeaderBase.cjs");
+const require_ResourcesMonthView_module = require("./ResourcesMonthView.module.cjs");
+let dayjs = require("dayjs");
+dayjs = require_runtime.__toESM(dayjs);
+let _mantine_core = require("@mantine/core");
+let _mantine_hooks = require("@mantine/hooks");
+let react = require("react");
+let _mantine_dates = require("@mantine/dates");
+let react_jsx_runtime = require("react/jsx-runtime");
+//#region packages/@mantine/schedule/src/components/ResourcesMonthView/ResourcesMonthView.tsx
+const varsResolver = (0, _mantine_core.createVarsResolver)((_theme, { radius, dayWidth, rowHeight, groupLabelWidth }) => ({ resourcesMonthView: {
+	"--resources-month-view-radius": radius ? (0, _mantine_core.getRadius)(radius) : void 0,
+	"--resources-month-view-day-width": (0, _mantine_core.rem)(dayWidth),
+	"--resources-month-view-row-height": (0, _mantine_core.rem)(rowHeight),
+	"--resources-month-view-group-label-width": (0, _mantine_core.rem)(groupLabelWidth)
+} }));
+const defaultProps = {
+	__staticSelector: "ResourcesMonthView",
+	highlightToday: true,
+	withHeader: true,
+	weekdayFormat: "ddd",
+	withWeekendDays: true,
+	withEventsDragAndDrop: false,
+	withDragSlotSelect: false,
+	mode: "default"
+};
+function compareCellEvents(a, b) {
+	const aStart = (0, dayjs.default)(a.start);
+	const bStart = (0, dayjs.default)(b.start);
+	const aSpan = (0, dayjs.default)(a.end).startOf("day").diff(aStart.startOf("day"), "day");
+	const bSpan = (0, dayjs.default)(b.end).startOf("day").diff(bStart.startOf("day"), "day");
+	if (aSpan !== bSpan) return bSpan - aSpan;
+	return aStart.valueOf() - bStart.valueOf();
+}
+function getFirstAvailableRow(usedRows, maxRows) {
+	for (let row = 0; row < maxRows; row += 1) if (!usedRows.has(row)) return row;
+	return null;
+}
+function isMultiDayEvent(event) {
+	return (0, dayjs.default)(event.end).startOf("day").isAfter((0, dayjs.default)(event.start).startOf("day"));
+}
+const ResourcesMonthView = (0, _mantine_core.factory)((_props) => {
+	const props = (0, _mantine_core.useProps)("ResourcesMonthView", defaultProps, _props);
+	const { classNames, className, style, styles, unstyled, attributes, vars, mod, date, onDateChange, resources, locale, weekdayFormat, weekendDays, withWeekendDays, startScrollDate, __staticSelector, onDayClick, highlightToday, radius, withHeader, monthYearSelectProps, onViewChange, todayControlProps, nextControlProps, previousControlProps, viewSelectProps, events, dayWidth, rowHeight, renderResourceLabel, groups, renderGroupLabel, groupLabelWidth, renderEventBody, renderEvent, withEventsDragAndDrop, onEventDrop, canDragEvent, onEventDragStart, onEventDragEnd, onEventClick, withDragSlotSelect, onSlotDragEnd, labels, mode, scrollAreaProps, onExternalEventDrop, maxEventsPerTimeSlot: _maxEventsPerTimeSlot, moreEventsProps, recurrenceExpansionLimit, ...others } = props;
+	const maxEventsPerTimeSlot = Math.min(10, Math.max(1, _maxEventsPerTimeSlot ?? 2));
+	const getStyles = (0, _mantine_core.useStyles)({
+		name: __staticSelector,
+		classes: require_ResourcesMonthView_module.default,
+		props,
+		className,
+		style,
+		classNames,
+		styles,
+		unstyled,
+		attributes,
+		vars,
+		varsResolver,
+		rootSelector: "resourcesMonthView"
+	});
+	const { resolvedClassNames, resolvedStyles } = (0, _mantine_core.useResolvedStylesApi)({
+		classNames,
+		styles,
+		props
+	});
+	const stylesApiProps = {
+		classNames: resolvedClassNames,
+		styles: resolvedStyles,
+		attributes,
+		__staticSelector,
+		radius
+	};
+	const ctx = (0, _mantine_dates.useDatesContext)();
+	const resolvedWeekendDays = ctx.getWeekendDays(weekendDays);
+	const { orderedResources, groupRanges, resourceGroupMap } = (0, react.useMemo)(() => require_get_ordered_resources.getOrderedResources(resources, groups), [resources, groups]);
+	const hasGroups = groupRanges.length > 0;
+	const monthDays = (0, react.useMemo)(() => {
+		const start = (0, dayjs.default)(date).startOf("month");
+		const daysCount = start.endOf("month").date();
+		const weekendDayList = ctx.getWeekendDays(weekendDays);
+		const days = [];
+		for (let d = 1; d <= daysCount; d++) {
+			const day = start.date(d);
+			if (!withWeekendDays && weekendDayList.includes(day.day())) continue;
+			days.push(day.format("YYYY-MM-DD"));
+		}
+		return days;
+	}, [
+		date,
+		withWeekendDays,
+		weekendDays,
+		ctx
+	]);
+	const viewportRef = (0, react.useRef)(null);
+	const mergedViewportRef = (0, _mantine_hooks.useMergedRef)(viewportRef, scrollAreaProps?.viewportRef);
+	const dayLabelRefs = (0, react.useRef)([]);
+	const resourceLabelRef = (0, react.useRef)(null);
+	const scrollToDay = (0, react.useCallback)((targetDate) => {
+		if (!viewportRef.current) return;
+		const targetIndex = monthDays.indexOf(targetDate);
+		if (targetIndex < 0) return;
+		const targetLabel = dayLabelRefs.current[targetIndex];
+		if (!targetLabel) return;
+		const labelRect = targetLabel.getBoundingClientRect();
+		const viewportRect = viewportRef.current.getBoundingClientRect();
+		const labelWidth = resourceLabelRef.current?.getBoundingClientRect().width ?? 0;
+		viewportRef.current.scrollTo({
+			left: labelRect.left - viewportRect.left - labelWidth,
+			top: 0
+		});
+	}, [monthDays]);
+	(0, _mantine_hooks.useIsomorphicEffect)(() => {
+		if (startScrollDate) scrollToDay(startScrollDate);
+	}, []);
+	const expandedEvents = (0, react.useMemo)(() => require_expand_recurring_events.expandRecurringEvents({
+		events,
+		rangeStart: (0, dayjs.default)(date).startOf("month").toDate(),
+		rangeEnd: (0, dayjs.default)(date).endOf("month").toDate(),
+		expansionLimit: recurrenceExpansionLimit
+	}), [
+		events,
+		date,
+		recurrenceExpansionLimit
+	]);
+	const { eventsByResourceAndDay, eventLayoutByResource } = (0, react.useMemo)(() => {
+		const eventsByResourceAndDay = {};
+		for (const resource of resources) {
+			eventsByResourceAndDay[resource.id] = {};
+			for (const day of monthDays) eventsByResourceAndDay[resource.id][day] = [];
+		}
+		if (expandedEvents) for (const event of expandedEvents) {
+			if (event.resourceId === void 0 || !(event.resourceId in eventsByResourceAndDay)) continue;
+			const eventStart = (0, dayjs.default)(event.start);
+			const eventEnd = (0, dayjs.default)(event.end);
+			for (const day of monthDays) {
+				const dayStart = (0, dayjs.default)(day).startOf("day");
+				const dayEnd = (0, dayjs.default)(day).endOf("day");
+				if (eventStart.isBefore(dayEnd) && eventEnd.isAfter(dayStart)) eventsByResourceAndDay[event.resourceId][day].push(event);
+			}
+		}
+		const eventLayoutByResource = {};
+		const monthRangeStart = (0, dayjs.default)(monthDays[0]).startOf("day");
+		const monthEndExclusive = (0, dayjs.default)(monthDays[monthDays.length - 1]).add(1, "day").startOf("day");
+		for (const resource of resources) {
+			const byDay = {};
+			const lastRow = /* @__PURE__ */ new Map();
+			const rowByEventDay = /* @__PURE__ */ new Map();
+			const overlapByEvent = /* @__PURE__ */ new Map();
+			monthDays.forEach((day, dayIndex) => {
+				const dayEvents = eventsByResourceAndDay[resource.id][day];
+				dayEvents.sort(compareCellEvents);
+				for (const event of dayEvents) {
+					const overlap = overlapByEvent.get(event.id);
+					if (overlap) overlap.days.push(dayIndex);
+					else overlapByEvent.set(event.id, {
+						event,
+						days: [dayIndex]
+					});
+				}
+				const usedRows = /* @__PURE__ */ new Set();
+				const visible = [];
+				let hiddenCount = 0;
+				for (const event of dayEvents) {
+					let row = lastRow.get(event.id);
+					if (row === void 0 || row >= maxEventsPerTimeSlot || usedRows.has(row)) row = getFirstAvailableRow(usedRows, maxEventsPerTimeSlot);
+					if (row === null) {
+						hiddenCount += 1;
+						continue;
+					}
+					usedRows.add(row);
+					visible.push({
+						event,
+						row
+					});
+					if (!rowByEventDay.has(event.id)) rowByEventDay.set(event.id, /* @__PURE__ */ new Map());
+					rowByEventDay.get(event.id).set(dayIndex, row);
+					lastRow.set(event.id, row);
+				}
+				byDay[day] = {
+					visible,
+					hiddenCount
+				};
+			});
+			const segments = [];
+			for (const { event, days } of overlapByEvent.values()) {
+				if (!isMultiDayEvent(event)) continue;
+				const firstOverlap = days[0];
+				const lastOverlap = days[days.length - 1];
+				const rows = rowByEventDay.get(event.id);
+				const extendsBefore = (0, dayjs.default)(event.start).isBefore(monthRangeStart);
+				const extendsAfter = (0, dayjs.default)(event.end).isAfter(monthEndExclusive);
+				let run = null;
+				const flushRun = () => {
+					if (!run) return;
+					const clipStart = run.startDayIndex > firstOverlap;
+					const clipEnd = run.endDayIndex < lastOverlap;
+					const hangStart = !clipStart && extendsBefore;
+					const hangEnd = !clipEnd && extendsAfter;
+					let hiddenInSpan = false;
+					for (let dayIndex = run.startDayIndex; dayIndex <= run.endDayIndex; dayIndex += 1) if ((byDay[monthDays[dayIndex]]?.hiddenCount ?? 0) > 0) {
+						hiddenInSpan = true;
+						break;
+					}
+					segments.push({
+						event,
+						startDayIndex: run.startDayIndex,
+						endDayIndex: run.endDayIndex,
+						row: run.row,
+						clipStart,
+						clipEnd,
+						hanging: hangStart && hangEnd ? "both" : hangStart ? "start" : hangEnd ? "end" : "none",
+						hiddenInSpan
+					});
+					run = null;
+				};
+				for (let dayIndex = firstOverlap; dayIndex <= lastOverlap; dayIndex += 1) {
+					const row = rows?.get(dayIndex);
+					if (row === void 0) {
+						flushRun();
+						continue;
+					}
+					if (run && run.row === row && run.endDayIndex === dayIndex - 1) run.endDayIndex = dayIndex;
+					else {
+						flushRun();
+						run = {
+							startDayIndex: dayIndex,
+							endDayIndex: dayIndex,
+							row
+						};
+					}
+				}
+				flushRun();
+			}
+			eventLayoutByResource[resource.id] = {
+				byDay,
+				segments
+			};
+		}
+		return {
+			eventsByResourceAndDay,
+			eventLayoutByResource
+		};
+	}, [
+		resources,
+		monthDays,
+		expandedEvents,
+		maxEventsPerTimeSlot
+	]);
+	const handleExternalDrop = (0, react.useCallback)((e, target) => {
+		if (!onExternalEventDrop) return;
+		onExternalEventDrop({
+			dataTransfer: e.dataTransfer,
+			dropDateTime: `${(0, dayjs.default)(target.day).format("YYYY-MM-DD")} 00:00:00`,
+			resourceId: target.resourceId
+		});
+	}, [onExternalEventDrop]);
+	const dragDrop = require_use_drag_drop_handlers.useDragDropHandlers({
+		enabled: withEventsDragAndDrop,
+		mode,
+		onEventDrop: (data) => {
+			onEventDrop?.({
+				...data,
+				resourceId: lastDropResourceId.current
+			});
+		},
+		canDragEvent,
+		onEventDragStart,
+		onEventDragEnd,
+		calculateDropTarget: (target, draggedEvent) => {
+			lastDropResourceId.current = target.resourceId;
+			return require_calculate_month_drop_date.calculateMonthDropDate({
+				draggedEvent,
+				targetDay: target.day
+			});
+		},
+		onExternalDrop: onExternalEventDrop ? handleExternalDrop : void 0
+	});
+	const lastDropResourceId = (0, react.useRef)(void 0);
+	const withDragHandlers = (withEventsDragAndDrop || !!onExternalEventDrop) && mode !== "static";
+	const groupToResourceId = (0, react.useMemo)(() => require_get_group_to_resource_id_map.getGroupToResourceIdMap(resources), [resources]);
+	const slotDragSelect = require_use_slot_drag_select.useSlotDragSelect({
+		enabled: withDragSlotSelect && mode !== "static",
+		onDragEnd: (startIndex, endIndex, group) => {
+			if (!onSlotDragEnd) return;
+			const startDay = monthDays[startIndex];
+			const endDay = monthDays[endIndex];
+			if (startDay && endDay) onSlotDragEnd({
+				rangeStart: (0, dayjs.default)(startDay).startOf("day").format("YYYY-MM-DD HH:mm:ss"),
+				rangeEnd: (0, dayjs.default)(endDay).endOf("day").format("YYYY-MM-DD HH:mm:ss"),
+				resourceId: groupToResourceId.get(group) ?? group
+			});
+		}
+	});
+	const dayLabels = monthDays.map((day, dayIndex) => {
+		const d = (0, dayjs.default)(day);
+		const weekend = resolvedWeekendDays.includes(d.day());
+		const today = d.isSame((0, dayjs.default)(), "day") && highlightToday;
+		return /* @__PURE__ */ (0, react.createElement)(_mantine_core.Box, {
+			...getStyles("resourcesMonthViewDayLabel"),
+			key: day,
+			mod: {
+				weekend,
+				today
+			},
+			ref: (node) => {
+				dayLabelRefs.current[dayIndex] = node;
+			}
+		}, /* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+			...getStyles("resourcesMonthViewDayLabelWeekday"),
+			children: require_format_date.formatDate({
+				date: d,
+				locale: ctx.getLocale(locale),
+				format: weekdayFormat
+			})
+		}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+			...getStyles("resourcesMonthViewDayLabelNumber"),
+			children: d.date()
+		}));
+	});
+	const cellsRef = (0, react.useRef)([]);
+	const getDayIndexFromDragPoint = (0, react.useCallback)((event, resourceIndex) => {
+		return require_get_index_from_drag_point.getIndexFromDragPoint(cellsRef.current[resourceIndex] ?? [], event.clientX);
+	}, []);
+	const handleCellKeyDown = (event, resourceIndex, dayIndex) => {
+		const key = event.key;
+		let nextResourceIndex = resourceIndex;
+		let nextDayIndex = dayIndex;
+		if (key === "ArrowRight") nextDayIndex = Math.min(dayIndex + 1, monthDays.length - 1);
+		else if (key === "ArrowLeft") nextDayIndex = Math.max(dayIndex - 1, 0);
+		else if (key === "ArrowDown") nextResourceIndex = Math.min(resourceIndex + 1, resources.length - 1);
+		else if (key === "ArrowUp") nextResourceIndex = Math.max(resourceIndex - 1, 0);
+		else return;
+		event.preventDefault();
+		cellsRef.current[nextResourceIndex]?.[nextDayIndex]?.focus();
+	};
+	const rowHeightPercent = 100 / maxEventsPerTimeSlot;
+	const rows = orderedResources.map((resource, resourceIndex) => {
+		if (!cellsRef.current[resourceIndex]) cellsRef.current[resourceIndex] = [];
+		const slotGroup = String(resource.id);
+		const dropTarget = dragDrop.dropTarget;
+		const totalDays = monthDays.length;
+		const eventNodes = [];
+		const moreNodes = [];
+		const cells = monthDays.map((day, dayIndex) => {
+			const d = (0, dayjs.default)(day);
+			const weekend = ctx.getWeekendDays(weekendDays).includes(d.day());
+			const isDropTarget = dropTarget !== null && typeof dropTarget === "object" && "day" in dropTarget && dropTarget.day === day && dropTarget.resourceId === resource.id;
+			const isDragSelected = slotDragSelect.isSlotSelected(dayIndex, slotGroup);
+			const dayEvents = eventsByResourceAndDay[resource.id]?.[day] || [];
+			const layout = eventLayoutByResource[resource.id]?.byDay[day];
+			const visibleEvents = layout?.visible ?? [];
+			const hiddenEventsCount = layout?.hiddenCount ?? 0;
+			const isFirstCell = resourceIndex === 0 && dayIndex === 0;
+			const dayLeftPercent = dayIndex / totalDays * 100;
+			const dayWidthPercent = 100 / totalDays;
+			const hasHiddenEvents = hiddenEventsCount > 0 && mode !== "static";
+			visibleEvents.forEach(({ event, row }) => {
+				if (isMultiDayEvent(event)) return;
+				const isDraggable = dragDrop.isDraggableEvent(event);
+				const topValue = hasHiddenEvents ? `calc((100% - 18px) * ${row} / ${maxEventsPerTimeSlot} + 1px)` : `calc(${row * rowHeightPercent}% + 1px)`;
+				const heightValue = hasHiddenEvents ? `calc((100% - 18px) / ${maxEventsPerTimeSlot} - 2px)` : `calc(${rowHeightPercent}% - 2px)`;
+				eventNodes.push(/* @__PURE__ */ (0, react_jsx_runtime.jsx)(require_ScheduleEvent.ScheduleEvent, {
+					event,
+					nowrap: true,
+					autoSize: true,
+					size: "sm",
+					draggable: isDraggable,
+					renderEventBody,
+					renderEvent,
+					radius,
+					mode,
+					onClick: onEventClick ? (e) => onEventClick(event, e) : void 0,
+					style: {
+						position: "absolute",
+						top: topValue,
+						left: `calc(${dayLeftPercent}% + 1px)`,
+						width: `calc(${dayWidthPercent}% - 2px)`,
+						height: heightValue,
+						zIndex: 3
+					}
+				}, `${event.id}-${day}`));
+			});
+			if (hiddenEventsCount > 0 && mode !== "static") moreNodes.push(/* @__PURE__ */ (0, react_jsx_runtime.jsx)(require_MoreEvents.MoreEvents, {
+				events: dayEvents,
+				moreEventsCount: hiddenEventsCount,
+				mode,
+				labels,
+				renderEventBody,
+				renderEvent,
+				onEventClick,
+				style: {
+					position: "absolute",
+					bottom: 1,
+					left: `calc(${dayLeftPercent}% + 1px)`,
+					width: `calc(${dayWidthPercent}% - 2px)`,
+					height: 18,
+					zIndex: 4
+				},
+				...stylesApiProps,
+				...moreEventsProps
+			}, `more-${resource.id}-${day}`));
+			return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_mantine_core.UnstyledButton, {
+				ref: (node) => {
+					if (node) {
+						if (!cellsRef.current[resourceIndex]) cellsRef.current[resourceIndex] = [];
+						cellsRef.current[resourceIndex][dayIndex] = node;
+					}
+				},
+				...getStyles("resourcesMonthViewCell"),
+				"aria-label": `${resource.label} ${d.format("MMMM D, YYYY")}`,
+				"data-drag-slot-index": withDragSlotSelect && mode !== "static" ? dayIndex : void 0,
+				"data-drag-slot-group": withDragSlotSelect && mode !== "static" ? slotGroup : void 0,
+				mod: {
+					weekend,
+					"drop-target": isDropTarget,
+					"drag-selected": isDragSelected,
+					static: mode === "static"
+				},
+				tabIndex: mode === "static" ? -1 : isFirstCell ? 0 : -1,
+				onClick: mode === "static" ? void 0 : (e) => onDayClick?.({
+					date: day,
+					nativeEvent: e,
+					resourceId: resource.id
+				}),
+				onKeyDown: mode === "static" ? void 0 : (e) => handleCellKeyDown(e, resourceIndex, dayIndex),
+				onPointerDown: withDragSlotSelect && mode !== "static" ? (e) => slotDragSelect.handleSlotPointerDown(e, dayIndex, slotGroup) : void 0,
+				onDragOver: withDragHandlers ? (e) => e.preventDefault() : void 0
+			}, day);
+		});
+		(eventLayoutByResource[resource.id]?.segments ?? []).forEach((segment) => {
+			const isDraggable = dragDrop.isDraggableEvent(segment.event);
+			const segmentLeftPercent = segment.startDayIndex / totalDays * 100;
+			const segmentWidthPercent = (segment.endDayIndex - segment.startDayIndex + 1) / totalDays * 100;
+			const compressed = segment.hiddenInSpan && mode !== "static";
+			const topValue = compressed ? `calc((100% - 18px) * ${segment.row} / ${maxEventsPerTimeSlot} + 1px)` : `calc(${segment.row * rowHeightPercent}% + 1px)`;
+			const heightValue = compressed ? `calc((100% - 18px) / ${maxEventsPerTimeSlot} - 2px)` : `calc(${rowHeightPercent}% - 2px)`;
+			eventNodes.push(/* @__PURE__ */ (0, react_jsx_runtime.jsx)(require_ScheduleEvent.ScheduleEvent, {
+				event: segment.event,
+				nowrap: true,
+				autoSize: true,
+				size: "sm",
+				hanging: segment.hanging,
+				draggable: isDraggable,
+				renderEventBody,
+				renderEvent,
+				radius,
+				mode,
+				mod: {
+					"clip-start": segment.clipStart,
+					"clip-end": segment.clipEnd
+				},
+				onClick: onEventClick ? (e) => onEventClick(segment.event, e) : void 0,
+				style: {
+					position: "absolute",
+					top: topValue,
+					left: `calc(${segmentLeftPercent}% + 1px)`,
+					width: `calc(${segmentWidthPercent}% - 2px)`,
+					height: heightValue,
+					zIndex: 3
+				}
+			}, `${segment.event.id}-segment-${segment.startDayIndex}`));
+		});
+		const groupInfo = hasGroups ? resourceGroupMap[resourceIndex] : void 0;
+		const isGroupStart = groupInfo?.position === "first" || groupInfo?.position === "only";
+		const groupCell = groupInfo !== void 0 ? groupInfo !== null ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_mantine_core.Box, {
+			...getStyles("resourcesMonthViewGroupColumn"),
+			mod: { "group-position": groupInfo.position },
+			children: isGroupStart && /* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+				style: groupInfo.count > 1 ? { transform: `translateY(calc((${groupInfo.count - 1} * (var(--resources-month-view-row-height) + 1px)) / 2))` } : void 0,
+				children: renderGroupLabel ? renderGroupLabel(groupInfo.group) : groupInfo.group.label
+			})
+		}) : /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_mantine_core.Box, { ...getStyles("resourcesMonthViewGroupColumnEmpty") }) : null;
+		return /* @__PURE__ */ (0, react.createElement)("div", {
+			...getStyles("resourcesMonthViewRow"),
+			key: resource.id
+		}, groupCell, /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+			...getStyles("resourcesMonthViewResourceLabel"),
+			"data-has-groups": hasGroups || void 0,
+			children: renderResourceLabel ? renderResourceLabel(resource) : resource.label
+		}), /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+			...getStyles("resourcesMonthViewRowSlots"),
+			onDragOver: withDragHandlers ? (e) => {
+				const dayIndex = getDayIndexFromDragPoint(e, resourceIndex);
+				if (dayIndex !== null && monthDays[dayIndex]) dragDrop.handleDragOver(e, {
+					day: monthDays[dayIndex],
+					resourceId: resource.id
+				});
+			} : void 0,
+			onDragLeave: withDragHandlers ? dragDrop.handleDragLeave : void 0,
+			onDrop: withDragHandlers ? (e) => {
+				const dayIndex = getDayIndexFromDragPoint(e, resourceIndex);
+				if (dayIndex !== null && monthDays[dayIndex]) dragDrop.handleDrop(e, {
+					day: monthDays[dayIndex],
+					resourceId: resource.id
+				});
+			} : void 0,
+			children: [
+				eventNodes,
+				moreNodes,
+				cells
+			]
+		}));
+	});
+	const content = /* @__PURE__ */ (0, react_jsx_runtime.jsxs)(_mantine_core.Box, {
+		mod: [{
+			static: mode === "static",
+			"slot-dragging": slotDragSelect.isDragging,
+			"event-interaction": dragDrop.dragContextValue.isDragging
+		}, mod],
+		...getStyles("resourcesMonthView"),
+		...others,
+		children: [withHeader && /* @__PURE__ */ (0, react_jsx_runtime.jsx)(require_ScheduleHeaderBase.ScheduleHeaderBase, {
+			view: "month",
+			navigationHandlers: {
+				previous: () => require_to_date_string.toDateString((0, dayjs.default)(date).subtract(1, "month").startOf("month")),
+				next: () => require_to_date_string.toDateString((0, dayjs.default)(date).add(1, "month").startOf("month")),
+				today: () => {
+					requestAnimationFrame(() => {
+						scrollToDay((0, dayjs.default)().format("YYYY-MM-DD"));
+					});
+					return require_to_date_string.toDateString((0, dayjs.default)());
+				}
+			},
+			control: { monthYearSelect: {
+				locale,
+				yearValue: (0, dayjs.default)(date).get("year"),
+				monthValue: (0, dayjs.default)(date).get("month"),
+				onYearChange: (year) => onDateChange?.(require_to_date_string.toDateString((0, dayjs.default)(date).set("year", year).startOf("month"))),
+				onMonthChange: (month) => onDateChange?.(require_to_date_string.toDateString((0, dayjs.default)(date).set("month", month).startOf("month"))),
+				...monthYearSelectProps
+			} },
+			labels,
+			onDateChange,
+			onViewChange,
+			previousControlProps,
+			nextControlProps,
+			todayControlProps,
+			viewSelectProps: {
+				views: [
+					"day",
+					"week",
+					"month"
+				],
+				...viewSelectProps
+			},
+			stylesApiProps
+		}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_mantine_core.Box, {
+			...getStyles("resourcesMonthViewRoot"),
+			children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_mantine_core.ScrollArea, {
+				scrollbars: "x",
+				scrollbarSize: 4,
+				...scrollAreaProps,
+				...getStyles("resourcesMonthViewScrollArea", {
+					className: scrollAreaProps?.className,
+					style: scrollAreaProps?.style
+				}),
+				viewportRef: mergedViewportRef,
+				children: /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+					...getStyles("resourcesMonthViewInner"),
+					children: [/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+						...getStyles("resourcesMonthViewDayLabelsRow"),
+						children: [/* @__PURE__ */ (0, react.createElement)("div", {
+							...getStyles("resourcesMonthViewCorner"),
+							key: "corner",
+							ref: resourceLabelRef,
+							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
+						}, require_labels.getLabel("resources", labels)), dayLabels]
+					}), rows]
+				})
+			})
+		})]
+	});
+	if (withEventsDragAndDrop) return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(require_DragContext.DragContext.Provider, {
+		value: dragDrop.dragContextValue,
+		children: content
+	});
+	return content;
+});
+ResourcesMonthView.displayName = "@mantine/schedule/ResourcesMonthView";
+ResourcesMonthView.classes = require_ResourcesMonthView_module.default;
+ResourcesMonthView.varsResolver = varsResolver;
+//#endregion
+exports.ResourcesMonthView = ResourcesMonthView;
+
+//# sourceMappingURL=ResourcesMonthView.cjs.map