@mantine/schedule 9.0.0-alpha.5 → 9.0.0-alpha.6

package/cjs/components/WeekView/WeekView.cjs

@@ -1,754 +1,623 @@
-'use client';
-'use strict';
-
-var jsxRuntime = require('react/jsx-runtime');
-var React = require('react');
-var dayjs = require('dayjs');
-var core = require('@mantine/core');
-var dates = require('@mantine/dates');
-var hooks = require('@mantine/hooks');
-var useAutoScrollOnDrag = require('../../hooks/use-auto-scroll-on-drag.cjs');
-var useDragDropHandlers = require('../../hooks/use-drag-drop-handlers.cjs');
-var useEventResize = require('../../hooks/use-event-resize.cjs');
-var useSlotDragSelect = require('../../hooks/use-slot-drag-select.cjs');
-var labels = require('../../labels.cjs');
-var formatDate = require('../../utils/format-date/format-date.cjs');
-var getWeekNumber = require('../../utils/get-week-number/get-week-number.cjs');
-var getDayTimeIntervals = require('../../utils/get-day-time-intervals/get-day-time-intervals.cjs');
-var getWeekDays = require('../../utils/get-week-days/get-week-days.cjs');
-var toDateString = require('../../utils/to-date-string/to-date-string.cjs');
-var nextWeek = require('../../utils/next-week/next-week.cjs');
-var previousWeek = require('../../utils/previous-week/previous-week.cjs');
-var isAllDayEvent = require('../../utils/is-all-day-event/is-all-day-event.cjs');
-var calculateDropTime = require('../../utils/calculate-drop-time/calculate-drop-time.cjs');
-var getBusinessHoursMod = require('../../utils/get-business-hours-mod/get-business-hours-mod.cjs');
-var expandRecurringEvents = require('../../utils/expand-recurring-events/expand-recurring-events.cjs');
-var CurrentTimeIndicator = require('../CurrentTimeIndicator/CurrentTimeIndicator.cjs');
-var DragContext = require('../DragContext/DragContext.cjs');
-var ScheduleEvent = require('../ScheduleEvent/ScheduleEvent.cjs');
-var ScheduleHeaderBase = require('../ScheduleHeader/ScheduleHeaderBase.cjs');
-var getWeekLabel = require('./get-week-label/get-week-label.cjs');
-var getWeekViewEvents = require('./get-week-view-events/get-week-view-events.cjs');
-var handleWeekViewKeyDown = require('./handle-week-view-key-down.cjs');
-var WeekViewDay = require('./WeekViewDay.cjs');
-var WeekView_module = require('./WeekView.module.css.cjs');
-
-function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
-
-var dayjs__default = /*#__PURE__*/_interopDefault(dayjs);
-
+"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_get_week_number = require("../../utils/get-week-number/get-week-number.cjs");
+const require_get_day_time_intervals = require("../../utils/get-day-time-intervals/get-day-time-intervals.cjs");
+const require_to_date_string = require("../../utils/to-date-string/to-date-string.cjs");
+const require_get_week_days = require("../../utils/get-week-days/get-week-days.cjs");
+const require_next_week = require("../../utils/next-week/next-week.cjs");
+const require_previous_week = require("../../utils/previous-week/previous-week.cjs");
+const require_is_all_day_event = require("../../utils/is-all-day-event/is-all-day-event.cjs");
+const require_calculate_drop_time = require("../../utils/calculate-drop-time/calculate-drop-time.cjs");
+const require_get_business_hours_mod = require("../../utils/get-business-hours-mod/get-business-hours-mod.cjs");
+const require_expand_recurring_events = require("../../utils/expand-recurring-events/expand-recurring-events.cjs");
+const require_use_auto_scroll_on_drag = require("../../hooks/use-auto-scroll-on-drag.cjs");
+const require_use_drag_drop_handlers = require("../../hooks/use-drag-drop-handlers.cjs");
+const require_use_event_resize = require("../../hooks/use-event-resize.cjs");
+const require_use_slot_drag_select = require("../../hooks/use-slot-drag-select.cjs");
+const require_CurrentTimeIndicator = require("../CurrentTimeIndicator/CurrentTimeIndicator.cjs");
+const require_DragContext = require("../DragContext/DragContext.cjs");
+const require_ScheduleEvent = require("../ScheduleEvent/ScheduleEvent.cjs");
+const require_ScheduleHeaderBase = require("../ScheduleHeader/ScheduleHeaderBase.cjs");
+const require_get_week_label = require("./get-week-label/get-week-label.cjs");
+const require_get_week_view_events = require("./get-week-view-events/get-week-view-events.cjs");
+const require_handle_week_view_key_down = require("./handle-week-view-key-down.cjs");
+const require_WeekViewDay = require("./WeekViewDay.cjs");
+const require_WeekView_module = require("./WeekView.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/WeekView/WeekView.tsx
 const defaultProps = {
-  __staticSelector: "WeekView",
-  withWeekendDays: true,
-  withCurrentTimeIndicator: true,
-  startTime: "00:00:00",
-  endTime: "23:59:59",
-  slotLabelFormat: "HH:mm",
-  intervalMinutes: 60,
-  weekdayFormat: "ddd",
-  withWeekNumber: true,
-  withCurrentTimeBubble: true,
-  withAllDaySlots: true,
-  withHeader: true,
-  weekLabelFormat: "MMM DD",
-  highlightBusinessHours: false,
-  businessHours: ["09:00:00", "17:00:00"],
-  withEventsDragAndDrop: false,
-  withDragSlotSelect: false,
-  withEventResize: false,
-  mode: "default"
+	__staticSelector: "WeekView",
+	withWeekendDays: true,
+	withCurrentTimeIndicator: true,
+	startTime: "00:00:00",
+	endTime: "23:59:59",
+	slotLabelFormat: "HH:mm",
+	intervalMinutes: 60,
+	weekdayFormat: "ddd",
+	withWeekNumber: true,
+	withCurrentTimeBubble: true,
+	withAllDaySlots: true,
+	withHeader: true,
+	weekLabelFormat: "MMM DD",
+	highlightBusinessHours: false,
+	businessHours: ["09:00:00", "17:00:00"],
+	withEventsDragAndDrop: false,
+	withDragSlotSelect: false,
+	withEventResize: false,
+	mode: "default"
 };
-const varsResolver = core.createVarsResolver(
-  (_theme, { radius, allDaySlotHeight, slotHeight }) => ({
-    weekView: {
-      "--week-view-radius": radius ? core.getRadius(radius) : void 0,
-      "--week-view-all-day-slots-height": core.rem(allDaySlotHeight),
-      "--week-view-slot-height": core.rem(slotHeight)
-    }
-  })
-);
-const WeekView = core.factory((_props) => {
-  const props = core.useProps("WeekView", defaultProps, _props);
-  const {
-    classNames,
-    className,
-    style,
-    styles,
-    unstyled,
-    attributes,
-    vars,
-    startTime,
-    endTime,
-    date,
-    onDateChange,
-    intervalMinutes,
-    slotLabelFormat,
-    withWeekendDays,
-    weekendDays,
-    firstDayOfWeek,
-    weekdayFormat,
-    radius,
-    highlightToday,
-    withCurrentTimeIndicator,
-    scrollAreaProps,
-    locale,
-    withWeekNumber,
-    withCurrentTimeBubble,
-    withAllDaySlots,
-    __staticSelector,
-    withHeader,
-    onViewChange,
-    previousControlProps,
-    nextControlProps,
-    todayControlProps,
-    viewSelectProps,
-    weekLabelFormat,
-    events,
-    allDaySlotHeight,
-    slotHeight,
-    labels: labels$1,
-    highlightBusinessHours,
-    businessHours,
-    renderEventBody,
-    renderEvent,
-    withEventsDragAndDrop,
-    onEventDrop,
-    canDragEvent,
-    onEventDragStart,
-    onEventDragEnd,
-    onTimeSlotClick,
-    onAllDaySlotClick,
-    onEventClick,
-    withDragSlotSelect,
-    onSlotDragEnd,
-    mode,
-    startScrollTime,
-    renderWeekLabel,
-    onExternalEventDrop,
-    withEventResize,
-    onEventResize,
-    canResizeEvent,
-    recurrenceExpansionLimit,
-    ...others
-  } = props;
-  const getStyles = core.useStyles({
-    name: __staticSelector,
-    classes: WeekView_module,
-    props,
-    className,
-    style,
-    classNames,
-    styles,
-    unstyled,
-    vars,
-    varsResolver,
-    attributes,
-    rootSelector: "weekView"
-  });
-  const { resolvedClassNames, resolvedStyles } = core.useResolvedStylesApi({
-    classNames,
-    styles,
-    props
-  });
-  const stylesApiProps = {
-    classNames: resolvedClassNames,
-    styles: resolvedStyles,
-    attributes,
-    __staticSelector,
-    radius
-  };
-  const theme = core.useMantineTheme();
-  const [scrolled, setScrolled] = React.useState(false);
-  const ctx = dates.useDatesContext();
-  const slots = getDayTimeIntervals.getDayTimeIntervals({ startTime, endTime, intervalMinutes });
-  const viewportRef = React.useRef(null);
-  useAutoScrollOnDrag.useAutoScrollOnDrag({
-    viewportRef,
-    enabled: (withEventsDragAndDrop || !!onExternalEventDrop) && mode !== "static"
-  });
-  const handleExternalDrop = React.useCallback(
-    (e, target) => {
-      if (!onExternalEventDrop) {
-        return;
-      }
-      const slotDate = dayjs__default.default(target.day).format("YYYY-MM-DD");
-      onExternalEventDrop(e.dataTransfer, `${slotDate} ${slots[target.slotIndex].startTime}`);
-    },
-    [onExternalEventDrop, slots]
-  );
-  const handleExternalAllDayDrop = React.useCallback(
-    (e, day) => {
-      if (!onExternalEventDrop) {
-        return;
-      }
-      onExternalEventDrop(e.dataTransfer, `${dayjs__default.default(day).format("YYYY-MM-DD")} 00:00:00`);
-    },
-    [onExternalEventDrop]
-  );
-  const dragDrop = useDragDropHandlers.useDragDropHandlers({
-    enabled: withEventsDragAndDrop,
-    mode,
-    onEventDrop,
-    canDragEvent,
-    onEventDragStart,
-    onEventDragEnd,
-    calculateDropTarget: (target, draggedEvent) => {
-      const slotTime = slots[target.slotIndex].startTime;
-      return calculateDropTime.calculateDropTime({
-        draggedEvent,
-        targetDate: target.day,
-        targetSlotTime: slotTime,
-        intervalMinutes
-      });
-    },
-    onExternalDrop: onExternalEventDrop ? handleExternalDrop : void 0
-  });
-  const allDayDragDrop = useDragDropHandlers.useDragDropHandlers({
-    enabled: withEventsDragAndDrop,
-    mode,
-    onEventDrop,
-    canDragEvent,
-    onEventDragStart,
-    onEventDragEnd,
-    calculateDropTarget: (targetDay, draggedEvent) => {
-      const eventDuration = dayjs__default.default(draggedEvent.end).diff(dayjs__default.default(draggedEvent.start), "millisecond");
-      const newStart = dayjs__default.default(targetDay).startOf("day");
-      return { start: newStart.toDate(), end: newStart.add(eventDuration, "millisecond").toDate() };
-    },
-    onExternalDrop: onExternalEventDrop ? handleExternalAllDayDrop : void 0
-  });
-  const slotDragSelect = useSlotDragSelect.useSlotDragSelect({
-    enabled: withDragSlotSelect && mode !== "static",
-    onDragEnd: (startIndex, endIndex, group) => {
-      if (!onSlotDragEnd) {
-        return;
-      }
-      const slotDate = dayjs__default.default(group).format("YYYY-MM-DD");
-      onSlotDragEnd(
-        `${slotDate} ${slots[startIndex].startTime}`,
-        `${slotDate} ${slots[endIndex].endTime}`
-      );
-    }
-  });
-  const eventResize = useEventResize.useEventResize({
-    enabled: withEventResize,
-    mode,
-    startTime,
-    endTime,
-    intervalMinutes,
-    onEventResize,
-    canResizeEvent
-  });
-  const withDragHandlers = (withEventsDragAndDrop || !!onExternalEventDrop) && mode !== "static";
-  const handleTimeSlotClick = (day, slotTime, e) => {
-    if (!onTimeSlotClick) {
-      return;
-    }
-    const slotDate = dayjs__default.default(day).format("YYYY-MM-DD");
-    const slotIndex = slots.findIndex((s) => s.startTime === slotTime);
-    if (slotIndex === -1) {
-      return;
-    }
-    const slot = slots[slotIndex];
-    onTimeSlotClick(`${slotDate} ${slot.startTime}`, `${slotDate} ${slot.endTime}`, e);
-  };
-  const weekdays = getWeekDays.getWeekDays({
-    week: date,
-    withWeekendDays,
-    weekendDays: ctx.getWeekendDays(weekendDays),
-    firstDayOfWeek: ctx.getFirstDayOfWeek(firstDayOfWeek)
-  });
-  const expandedEvents = expandRecurringEvents.expandRecurringEvents({
-    events,
-    rangeStart: dayjs__default.default(weekdays[0]).startOf("day").toDate(),
-    rangeEnd: dayjs__default.default(weekdays[weekdays.length - 1]).endOf("day").toDate(),
-    expansionLimit: recurrenceExpansionLimit
-  });
-  const weekEvents = getWeekViewEvents.getWeekViewEvents({
-    date,
-    events: expandedEvents,
-    startTime,
-    endTime,
-    firstDayOfWeek: ctx.getFirstDayOfWeek(firstDayOfWeek),
-    weekendDays: ctx.getWeekendDays(weekendDays),
-    withWeekendDays
-  });
-  const timeValues = slots.map((interval) => {
-    const intervalTime = dayjs__default.default(`${dayjs__default.default(date).format("YYYY-MM-DD")} ${interval.startTime}`);
-    const label = formatDate.formatDate({
-      date: intervalTime,
-      locale: ctx.getLocale(locale),
-      format: slotLabelFormat
-    });
-    return /* @__PURE__ */ React.createElement(
-      core.Box,
-      {
-        ...getStyles("weekViewSlotLabel"),
-        key: interval.startTime,
-        mod: {
-          "hour-start": interval.isHourStart,
-          ...getBusinessHoursMod.getBusinessHoursMod({
-            time: interval.startTime,
-            businessHours,
-            highlightBusinessHours
-          })
-        }
-      },
-      label
-    );
-  });
-  const slotsRef = React.useRef([]);
-  const allDaySlotsRef = React.useRef([]);
-  const weekdaysRef = React.useRef([]);
-  const daySlotsContainersRef = React.useRef([]);
-  const mergedViewportRef = hooks.useMergedRef(viewportRef, scrollAreaProps?.viewportRef);
-  const firstSlotIndex = { dayIndex: 0, slotIndex: 0 };
-  hooks.useIsomorphicEffect(() => {
-    if (!startScrollTime || !viewportRef.current) {
-      return;
-    }
-    const firstDaySlots = slotsRef.current[0];
-    if (!firstDaySlots || firstDaySlots.length === 0) {
-      return;
-    }
-    const targetIndex = slots.findIndex((s) => s.startTime >= startScrollTime);
-    if (targetIndex < 0) {
-      return;
-    }
-    const targetSlot = firstDaySlots[targetIndex];
-    if (!targetSlot) {
-      return;
-    }
-    const slotRect = targetSlot.getBoundingClientRect();
-    const viewportRect = viewportRef.current.getBoundingClientRect();
-    viewportRef.current.scrollTo({ left: 0, top: slotRect.top - viewportRect.top });
-  }, []);
-  const getSlotIndexFromDragPoint = React.useCallback((event, dayIndex) => {
-    const daySlots = slotsRef.current[dayIndex] ?? [];
-    const slotIndex = daySlots.findIndex((slotNode) => {
-      if (!slotNode) {
-        return false;
-      }
-      const rect = slotNode.getBoundingClientRect();
-      return event.clientY >= rect.top && event.clientY <= rect.bottom;
-    });
-    if (slotIndex >= 0) {
-      return slotIndex;
-    }
-    const firstSlot = daySlots[0];
-    const lastSlot = daySlots[daySlots.length - 1];
-    if (!firstSlot || !lastSlot) {
-      return null;
-    }
-    const firstRect = firstSlot.getBoundingClientRect();
-    const lastRect = lastSlot.getBoundingClientRect();
-    if (event.clientY < firstRect.top) {
-      return 0;
-    }
-    if (event.clientY > lastRect.bottom) {
-      return daySlots.length - 1;
-    }
-    return null;
-  }, []);
-  const handleSlotKeyDown = (event, dayIndex, slotIndex) => {
-    handleWeekViewKeyDown.handleWeekViewKeyDown({
-      controlsRef: slotsRef,
-      dayIndex,
-      slotIndex,
-      event
-    });
-  };
-  const handleAllDaySlotKeyDown = (event, dayIndex) => {
-    const direction = event.key;
-    if (direction === "ArrowRight" && dayIndex < weekdays.length - 1) {
-      event.preventDefault();
-      allDaySlotsRef.current[dayIndex + 1]?.focus();
-    } else if (direction === "ArrowLeft" && dayIndex > 0) {
-      event.preventDefault();
-      allDaySlotsRef.current[dayIndex - 1]?.focus();
-    } else if (direction === "ArrowDown") {
-      event.preventDefault();
-      slotsRef.current?.[dayIndex]?.[0]?.focus();
-    }
-  };
-  const handleWeekdayKeyDown = (event, dayIndex) => {
-    const direction = event.key;
-    if (direction === "ArrowRight" && dayIndex < weekdays.length - 1) {
-      event.preventDefault();
-      weekdaysRef.current[dayIndex + 1]?.focus();
-    } else if (direction === "ArrowLeft" && dayIndex > 0) {
-      event.preventDefault();
-      weekdaysRef.current[dayIndex - 1]?.focus();
-    }
-  };
-  const currentWeekdayIndex = withCurrentTimeIndicator ? weekdays.findIndex((day) => dayjs__default.default(day).isSame(dayjs__default.default(), "date")) : -1;
-  const weekdaysLabels = weekdays.map((day, dayIndex) => /* @__PURE__ */ React.createElement(
-    core.UnstyledButton,
-    {
-      ...getStyles("weekViewDayLabel"),
-      key: day,
-      ref: (node) => {
-        weekdaysRef.current[dayIndex] = node;
-      },
-      "aria-label": `${labels.getLabel("weekday", labels$1)} ${dayjs__default.default(day).format("YYYY-MM-DD")}`,
-      mod: {
-        today: dayjs__default.default(day).isSame(dayjs__default.default(), "day") && !!highlightToday,
-        weekend: ctx.getWeekendDays(weekendDays).includes(dayjs__default.default(day).day()),
-        static: mode === "static"
-      },
-      tabIndex: mode === "static" ? -1 : dayIndex === 0 ? 0 : -1,
-      onKeyDown: mode === "static" ? void 0 : (event) => handleWeekdayKeyDown(event, dayIndex),
-      onClick: mode === "static" ? void 0 : () => {
-        onViewChange?.("day");
-        onDateChange?.(toDateString.toDateString(day));
-      }
-    },
-    /* @__PURE__ */ React.createElement(core.Box, { ...getStyles("weekViewDayWeekday"), key: "weekday" }, formatDate.formatDate({ locale: ctx.getLocale(locale), date: day, format: weekdayFormat })),
-    /* @__PURE__ */ React.createElement("div", { ...getStyles("weekViewDayNumber"), key: "date" }, dayjs__default.default(day).date())
-  ));
-  const days = weekdays.map((day, dayIndex) => {
-    const allBgEvents = weekEvents.backgroundEvents[day] || [];
-    const backgroundEventNodes = allBgEvents.filter((event) => !event.position.allDay).map((event) => {
-      const colors = theme.variantColorResolver({
-        color: event.color || theme.primaryColor,
-        theme,
-        variant: "light",
-        autoContrast: true
-      });
-      const bgEventBody = typeof renderEventBody === "function" ? renderEventBody(event) : event.title;
-      const bgEventProps = {
-        key: `bg-${event.id}`,
-        ...getStyles("weekViewBackgroundEvent", {
-          style: {
-            top: `${event.position.top}%`,
-            height: `${event.position.height}%`,
-            width: "100%"
-          }
-        }),
-        __vars: {
-          "--bg-event-bg": colors.background,
-          "--bg-event-color": colors.color
-        },
-        children: bgEventBody
-      };
-      if (typeof renderEvent === "function") {
-        return renderEvent(event, bgEventProps);
-      }
-      return /* @__PURE__ */ jsxRuntime.jsx(core.Box, { ...bgEventProps });
-    });
-    const dayEvents = (weekEvents.regularEvents[day] || []).map((event) => {
-      const eventIsAllDay = isAllDayEvent.isAllDayEvent({ event, date: day });
-      const isDraggable = !eventIsAllDay && dragDrop.isDraggableEvent(event);
-      const isResizable = !eventIsAllDay && eventResize.isResizableEvent(event);
-      const resizePosition = eventResize.getResizePosition(event.id);
-      const eventTop = resizePosition ? resizePosition.top : event.position.top;
-      const eventHeight = resizePosition ? resizePosition.height : event.position.height;
-      return /* @__PURE__ */ jsxRuntime.jsx(
-        ScheduleEvent.ScheduleEvent,
-        {
-          event,
-          autoSize: true,
-          hanging: event.position.hanging,
-          draggable: isDraggable,
-          withResize: isResizable,
-          isResizing: resizePosition !== null,
-          onResizeStart: isResizable ? (edge, e) => {
-            const container = daySlotsContainersRef.current[dayIndex];
-            if (container) {
-              eventResize.handleResizeStart(
-                event,
-                edge,
-                container,
-                event.position.top,
-                event.position.height,
-                dayjs__default.default(day).format("YYYY-MM-DD"),
-                e
-              );
-            }
-          } : void 0,
-          renderEventBody,
-          renderEvent,
-          radius,
-          mode,
-          onClick: onEventClick ? (e) => onEventClick(event, e) : void 0,
-          style: {
-            position: "absolute",
-            top: `calc(${eventTop}% + 1px)`,
-            left: `${event.position.offset}%`,
-            width: `${event.position.width}%`,
-            height: `calc(${eventHeight}% - 1px)`
-          }
-        },
-        event.id
-      );
-    });
-    return /* @__PURE__ */ jsxRuntime.jsxs(
-      WeekViewDay.WeekViewDay,
-      {
-        day,
-        dayIndex,
-        slots,
-        getStyles,
-        weekendDays,
-        highlightBusinessHours,
-        businessHours,
-        labels: labels$1,
-        withEventsDragAndDrop: withDragHandlers,
-        mode,
-        slotsRef,
-        firstSlotIndex,
-        onSlotKeyDown: handleSlotKeyDown,
-        onSlotClick: handleTimeSlotClick,
-        onFirstSlotArrowUp: withAllDaySlots ? (dayIdx) => {
-          allDaySlotsRef.current[dayIdx]?.focus();
-        } : void 0,
-        onDaySlotsDragOver: (event, dayStr, dayIdx) => {
-          const slotIndex = getSlotIndexFromDragPoint(event, dayIdx);
-          if (slotIndex !== null) {
-            dragDrop.handleDragOver(event, { day: dayStr, slotIndex });
-          }
-        },
-        onDaySlotsDragLeave: dragDrop.handleDragLeave,
-        onDaySlotsDrop: (event, dayStr, dayIdx) => {
-          const slotIndex = getSlotIndexFromDragPoint(event, dayIdx);
-          if (slotIndex !== null) {
-            dragDrop.handleDrop(event, { day: dayStr, slotIndex });
-          }
-        },
-        dropTargetSlotIndex: dragDrop.dropTarget?.day === day ? dragDrop.dropTarget.slotIndex : void 0,
-        withDragSlotSelect,
-        onSlotPointerDown: slotDragSelect.handleSlotPointerDown,
-        isSlotDragSelected: slotDragSelect.isSlotSelected,
-        daySlotsContainerRef: (node) => {
-          daySlotsContainersRef.current[dayIndex] = node;
-        },
-        children: [
-          backgroundEventNodes,
-          dayEvents
-        ]
-      },
-      day
-    );
-  });
-  const allDaySlots = weekdays.map((day, dayIndex) => /* @__PURE__ */ jsxRuntime.jsx(
-    core.UnstyledButton,
-    {
-      "aria-label": `${labels.getLabel("allDay", labels$1)} ${dayjs__default.default(day).format("YYYY-MM-DD")}`,
-      ref: (node) => {
-        allDaySlotsRef.current[dayIndex] = node;
-      },
-      tabIndex: dayIndex === 0 ? 0 : -1,
-      onKeyDown: (event) => handleAllDaySlotKeyDown(event, dayIndex),
-      onClick: mode === "static" || !onAllDaySlotClick ? void 0 : (e) => onAllDaySlotClick(dayjs__default.default(day).format("YYYY-MM-DD"), e),
-      onDragOver: withDragHandlers ? (e) => allDayDragDrop.handleDragOver(e, day) : void 0,
-      onDragLeave: withDragHandlers ? allDayDragDrop.handleDragLeave : void 0,
-      onDrop: withDragHandlers ? (e) => allDayDragDrop.handleDrop(e, day) : void 0,
-      ...getStyles("weekViewDaySlot"),
-      mod: { "drop-target": allDayDragDrop.isDropTarget(day) }
-    },
-    day
-  ));
-  const allDayEventIds = React.useMemo(
-    () => new Set(weekEvents.allDayEvents.map((e) => e.id)),
-    [weekEvents.allDayEvents]
-  );
-  const allDayEvents = weekEvents.allDayEvents.map((event) => /* @__PURE__ */ jsxRuntime.jsx(
-    ScheduleEvent.ScheduleEvent,
-    {
-      event,
-      autoSize: true,
-      nowrap: true,
-      hanging: event.position.hanging,
-      draggable: allDayDragDrop.isDraggableEvent(event),
-      renderEvent,
-      mode,
-      onClick: onEventClick ? (e) => onEventClick(event, e) : void 0,
-      style: {
-        position: "absolute",
-        zIndex: 2,
-        top: `calc(${event.position.row * 50}% + 1px)`,
-        left: `calc(${event.position.offset}% + 1px)`,
-        width: `calc(${event.position.width}% - 1px)`,
-        height: "calc(50% - 2px)",
-        maxHeight: "calc(50% - 2px)"
-      }
-    },
-    event.id
-  ));
-  const allDayBackgroundEventNodes = weekdays.flatMap((day, dayIndex) => {
-    const allDayBgEvents = (weekEvents.backgroundEvents[day] || []).filter(
-      (event) => event.position.allDay
-    );
-    const dayWidth = 100 / weekdays.length;
-    const dayOffset = dayIndex * dayWidth;
-    return allDayBgEvents.map((event) => {
-      const colors = theme.variantColorResolver({
-        color: event.color || theme.primaryColor,
-        theme,
-        variant: "light",
-        autoContrast: true
-      });
-      const bgEventBody = typeof renderEventBody === "function" ? renderEventBody(event) : event.title;
-      const bgEventProps = {
-        key: `bg-allday-${event.id}-${day}`,
-        ...getStyles("weekViewBackgroundEvent", {
-          style: {
-            top: 0,
-            height: "100%",
-            left: `${dayOffset}%`,
-            width: `${dayWidth}%`
-          }
-        }),
-        __vars: {
-          "--bg-event-bg": colors.background,
-          "--bg-event-color": colors.color
-        },
-        children: bgEventBody
-      };
-      if (typeof renderEvent === "function") {
-        return renderEvent(event, bgEventProps);
-      }
-      return /* @__PURE__ */ jsxRuntime.jsx(core.Box, { ...bgEventProps });
-    });
-  });
-  const extraRows = Math.max(...weekEvents.allDayEvents.map((event) => event.position.row), 1) - 1;
-  const content = /* @__PURE__ */ jsxRuntime.jsxs(
-    core.Box,
-    {
-      ...getStyles("weekView"),
-      mod: { static: mode === "static", "slot-dragging": slotDragSelect.isDragging },
-      ...others,
-      children: [
-        withHeader && /* @__PURE__ */ jsxRuntime.jsx(
-          ScheduleHeaderBase.ScheduleHeaderBase,
-          {
-            view: "week",
-            navigationHandlers: {
-              previous: () => previousWeek.previousWeek(date, ctx.getFirstDayOfWeek(firstDayOfWeek)),
-              next: () => nextWeek.nextWeek(date, ctx.getFirstDayOfWeek(firstDayOfWeek)),
-              today: () => toDateString.toDateString(dayjs__default.default())
-            },
-            control: {
-              miw: 140,
-              title: getWeekLabel.getWeekLabel({
-                weekdays,
-                locale: ctx.getLocale(locale),
-                weekLabelFormat,
-                renderWeekLabel
-              })
-            },
-            labels: labels$1,
-            onDateChange,
-            onViewChange,
-            previousControlProps,
-            nextControlProps,
-            todayControlProps,
-            viewSelectProps,
-            stylesApiProps
-          }
-        ),
-        /* @__PURE__ */ jsxRuntime.jsx(
-          core.Box,
-          {
-            ...getStyles("weekViewRoot"),
-            __vars: {
-              "--indicator-offset-index": currentWeekdayIndex === -1 ? void 0 : `${currentWeekdayIndex + 1}`,
-              "--number-of-days": withWeekendDays ? "7" : `${7 - ctx.getWeekendDays(weekendDays).length}`
-            },
-            mod: { "with-weekends": withWeekendDays },
-            children: /* @__PURE__ */ jsxRuntime.jsxs(
-              core.ScrollArea.Autosize,
-              {
-                scrollbarSize: 4,
-                ...scrollAreaProps,
-                ...getStyles("weekViewScrollArea", {
-                  className: scrollAreaProps?.className,
-                  style: scrollAreaProps?.style
-                }),
-                onScrollPositionChange: (position) => {
-                  scrollAreaProps?.onScrollPositionChange?.(position);
-                  setScrolled(position.y !== 0);
-                },
-                viewportRef: mergedViewportRef,
-                children: [
-                  /* @__PURE__ */ jsxRuntime.jsxs(core.Box, { ...getStyles("weekViewHeader"), mod: { scrolled }, children: [
-                    /* @__PURE__ */ React.createElement("div", { ...getStyles("weekViewCorner"), key: "corner" }, withWeekNumber && /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
-                      /* @__PURE__ */ jsxRuntime.jsx("div", { ...getStyles("weekViewWeekLabel"), children: labels.getLabel("week", labels$1) }),
-                      /* @__PURE__ */ jsxRuntime.jsx("div", { ...getStyles("weekViewWeekNumber"), children: getWeekNumber.getWeekNumber(date) })
-                    ] })),
-                    weekdaysLabels
-                  ] }),
-                  withAllDaySlots && /* @__PURE__ */ jsxRuntime.jsxs("div", { ...getStyles("weekViewAllDaySlots"), children: [
-                    /* @__PURE__ */ jsxRuntime.jsx("div", { ...getStyles("weekViewAllDaySlotsLabel"), children: labels.getLabel("allDay", labels$1) }),
-                    /* @__PURE__ */ jsxRuntime.jsxs("div", { ...getStyles("weekViewAllDaySlotsList"), children: [
-                      allDayBackgroundEventNodes,
-                      /* @__PURE__ */ jsxRuntime.jsx(
-                        core.Box,
-                        {
-                          ...getStyles("weekViewAllDaySlotsEvents"),
-                          __vars: { "--extra-rows": `${extraRows}` },
-                          children: allDayEvents
-                        }
-                      ),
-                      allDaySlots
-                    ] })
-                  ] }),
-                  /* @__PURE__ */ jsxRuntime.jsxs("div", { ...getStyles("weekViewInner"), children: [
-                    /* @__PURE__ */ jsxRuntime.jsx("div", { ...getStyles("weekViewSlotLabels"), children: timeValues }),
-                    withCurrentTimeIndicator && currentWeekdayIndex !== -1 && /* @__PURE__ */ jsxRuntime.jsx(
-                      CurrentTimeIndicator.CurrentTimeIndicator,
-                      {
-                        startOffset: "calc(100% - (100% / var(--number-of-days)) * (var(--number-of-days) - var(--indicator-offset-index) + 1) + ((var(--number-of-days) - var(--indicator-offset-index) + 1) * var(--indicator-labels-offset)))",
-                        endOffset: "calc((100% / var(--number-of-days)) * (var(--number-of-days) - var(--indicator-offset-index)) - (var(--number-of-days) - var(--indicator-offset-index)) * var(--indicator-labels-offset))",
-                        timeBubbleStartOffset: "calc(var(--week-view-slots-label-width) - var(--time-bubble-width))",
-                        currentTimeFormat: slotLabelFormat,
-                        withTimeBubble: withCurrentTimeBubble,
-                        withThumb: withCurrentTimeBubble ? currentWeekdayIndex !== 0 : true,
-                        locale,
-                        startTime,
-                        endTime,
-                        ...stylesApiProps
-                      }
-                    ),
-                    days
-                  ] })
-                ]
-              }
-            )
-          }
-        )
-      ]
-    }
-  );
-  const mergedDragContextValue = React.useMemo(
-    () => ({
-      isDragging: dragDrop.dragContextValue.isDragging || allDayDragDrop.dragContextValue.isDragging,
-      draggedEventId: dragDrop.dragContextValue.draggedEventId ?? allDayDragDrop.dragContextValue.draggedEventId,
-      draggedEvent: dragDrop.dragContextValue.draggedEvent ?? allDayDragDrop.dragContextValue.draggedEvent,
-      dropTarget: dragDrop.dragContextValue.dropTarget ?? allDayDragDrop.dragContextValue.dropTarget,
-      onDragStart: (event) => {
-        if (allDayEventIds.has(event.id)) {
-          allDayDragDrop.handleDragStart(event);
-        } else {
-          dragDrop.handleDragStart(event);
-        }
-      },
-      onDragEnd: () => {
-        dragDrop.handleDragEnd();
-        allDayDragDrop.handleDragEnd();
-      },
-      setDropTarget: dragDrop.dragContextValue.setDropTarget
-    }),
-    [dragDrop.dragContextValue, allDayDragDrop.dragContextValue, allDayEventIds]
-  );
-  if (withEventsDragAndDrop) {
-    return /* @__PURE__ */ jsxRuntime.jsx(DragContext.DragContext.Provider, { value: mergedDragContextValue, children: content });
-  }
-  return content;
+const varsResolver = (0, _mantine_core.createVarsResolver)((_theme, { radius, allDaySlotHeight, slotHeight }) => ({ weekView: {
+	"--week-view-radius": radius ? (0, _mantine_core.getRadius)(radius) : void 0,
+	"--week-view-all-day-slots-height": (0, _mantine_core.rem)(allDaySlotHeight),
+	"--week-view-slot-height": (0, _mantine_core.rem)(slotHeight)
+} }));
+const WeekView = (0, _mantine_core.factory)((_props) => {
+	const props = (0, _mantine_core.useProps)("WeekView", defaultProps, _props);
+	const { classNames, className, style, styles, unstyled, attributes, vars, startTime, endTime, date, onDateChange, intervalMinutes, slotLabelFormat, withWeekendDays, weekendDays, firstDayOfWeek, weekdayFormat, radius, highlightToday, withCurrentTimeIndicator, scrollAreaProps, locale, withWeekNumber, withCurrentTimeBubble, withAllDaySlots, __staticSelector, withHeader, onViewChange, previousControlProps, nextControlProps, todayControlProps, viewSelectProps, weekLabelFormat, events, allDaySlotHeight, slotHeight, labels, highlightBusinessHours, businessHours, renderEventBody, renderEvent, withEventsDragAndDrop, onEventDrop, canDragEvent, onEventDragStart, onEventDragEnd, onTimeSlotClick, onAllDaySlotClick, onEventClick, withDragSlotSelect, onSlotDragEnd, mode, startScrollTime, renderWeekLabel, onExternalEventDrop, withEventResize, onEventResize, canResizeEvent, recurrenceExpansionLimit, ...others } = props;
+	const getStyles = (0, _mantine_core.useStyles)({
+		name: __staticSelector,
+		classes: require_WeekView_module.default,
+		props,
+		className,
+		style,
+		classNames,
+		styles,
+		unstyled,
+		vars,
+		varsResolver,
+		attributes,
+		rootSelector: "weekView"
+	});
+	const { resolvedClassNames, resolvedStyles } = (0, _mantine_core.useResolvedStylesApi)({
+		classNames,
+		styles,
+		props
+	});
+	const stylesApiProps = {
+		classNames: resolvedClassNames,
+		styles: resolvedStyles,
+		attributes,
+		__staticSelector,
+		radius
+	};
+	const theme = (0, _mantine_core.useMantineTheme)();
+	const [scrolled, setScrolled] = (0, react.useState)(false);
+	const ctx = (0, _mantine_dates.useDatesContext)();
+	const slots = require_get_day_time_intervals.getDayTimeIntervals({
+		startTime,
+		endTime,
+		intervalMinutes
+	});
+	const viewportRef = (0, react.useRef)(null);
+	require_use_auto_scroll_on_drag.useAutoScrollOnDrag({
+		viewportRef,
+		enabled: (withEventsDragAndDrop || !!onExternalEventDrop) && mode !== "static"
+	});
+	const handleExternalDrop = (0, react.useCallback)((e, target) => {
+		if (!onExternalEventDrop) return;
+		const slotDate = (0, dayjs.default)(target.day).format("YYYY-MM-DD");
+		onExternalEventDrop(e.dataTransfer, `${slotDate} ${slots[target.slotIndex].startTime}`);
+	}, [onExternalEventDrop, slots]);
+	const handleExternalAllDayDrop = (0, react.useCallback)((e, day) => {
+		if (!onExternalEventDrop) return;
+		onExternalEventDrop(e.dataTransfer, `${(0, dayjs.default)(day).format("YYYY-MM-DD")} 00:00:00`);
+	}, [onExternalEventDrop]);
+	const dragDrop = require_use_drag_drop_handlers.useDragDropHandlers({
+		enabled: withEventsDragAndDrop,
+		mode,
+		onEventDrop,
+		canDragEvent,
+		onEventDragStart,
+		onEventDragEnd,
+		calculateDropTarget: (target, draggedEvent) => {
+			const slotTime = slots[target.slotIndex].startTime;
+			return require_calculate_drop_time.calculateDropTime({
+				draggedEvent,
+				targetDate: target.day,
+				targetSlotTime: slotTime,
+				intervalMinutes
+			});
+		},
+		onExternalDrop: onExternalEventDrop ? handleExternalDrop : void 0
+	});
+	const allDayDragDrop = require_use_drag_drop_handlers.useDragDropHandlers({
+		enabled: withEventsDragAndDrop,
+		mode,
+		onEventDrop,
+		canDragEvent,
+		onEventDragStart,
+		onEventDragEnd,
+		calculateDropTarget: (targetDay, draggedEvent) => {
+			const eventDuration = (0, dayjs.default)(draggedEvent.end).diff((0, dayjs.default)(draggedEvent.start), "millisecond");
+			const newStart = (0, dayjs.default)(targetDay).startOf("day");
+			return {
+				start: newStart.toDate(),
+				end: newStart.add(eventDuration, "millisecond").toDate()
+			};
+		},
+		onExternalDrop: onExternalEventDrop ? handleExternalAllDayDrop : void 0
+	});
+	const slotDragSelect = require_use_slot_drag_select.useSlotDragSelect({
+		enabled: withDragSlotSelect && mode !== "static",
+		onDragEnd: (startIndex, endIndex, group) => {
+			if (!onSlotDragEnd) return;
+			const slotDate = (0, dayjs.default)(group).format("YYYY-MM-DD");
+			onSlotDragEnd(`${slotDate} ${slots[startIndex].startTime}`, `${slotDate} ${slots[endIndex].endTime}`);
+		}
+	});
+	const eventResize = require_use_event_resize.useEventResize({
+		enabled: withEventResize,
+		mode,
+		startTime,
+		endTime,
+		intervalMinutes,
+		onEventResize,
+		canResizeEvent
+	});
+	const withDragHandlers = (withEventsDragAndDrop || !!onExternalEventDrop) && mode !== "static";
+	const handleTimeSlotClick = (day, slotTime, e) => {
+		if (!onTimeSlotClick) return;
+		const slotDate = (0, dayjs.default)(day).format("YYYY-MM-DD");
+		const slotIndex = slots.findIndex((s) => s.startTime === slotTime);
+		if (slotIndex === -1) return;
+		const slot = slots[slotIndex];
+		onTimeSlotClick(`${slotDate} ${slot.startTime}`, `${slotDate} ${slot.endTime}`, e);
+	};
+	const weekdays = require_get_week_days.getWeekDays({
+		week: date,
+		withWeekendDays,
+		weekendDays: ctx.getWeekendDays(weekendDays),
+		firstDayOfWeek: ctx.getFirstDayOfWeek(firstDayOfWeek)
+	});
+	const weekEvents = require_get_week_view_events.getWeekViewEvents({
+		date,
+		events: require_expand_recurring_events.expandRecurringEvents({
+			events,
+			rangeStart: (0, dayjs.default)(weekdays[0]).startOf("day").toDate(),
+			rangeEnd: (0, dayjs.default)(weekdays[weekdays.length - 1]).endOf("day").toDate(),
+			expansionLimit: recurrenceExpansionLimit
+		}),
+		startTime,
+		endTime,
+		firstDayOfWeek: ctx.getFirstDayOfWeek(firstDayOfWeek),
+		weekendDays: ctx.getWeekendDays(weekendDays),
+		withWeekendDays
+	});
+	const timeValues = slots.map((interval) => {
+		const label = require_format_date.formatDate({
+			date: (0, dayjs.default)(`${(0, dayjs.default)(date).format("YYYY-MM-DD")} ${interval.startTime}`),
+			locale: ctx.getLocale(locale),
+			format: slotLabelFormat
+		});
+		return /* @__PURE__ */ (0, react.createElement)(_mantine_core.Box, {
+			...getStyles("weekViewSlotLabel"),
+			key: interval.startTime,
+			mod: {
+				"hour-start": interval.isHourStart,
+				...require_get_business_hours_mod.getBusinessHoursMod({
+					time: interval.startTime,
+					businessHours,
+					highlightBusinessHours
+				})
+			}
+		}, label);
+	});
+	const slotsRef = (0, react.useRef)([]);
+	const allDaySlotsRef = (0, react.useRef)([]);
+	const weekdaysRef = (0, react.useRef)([]);
+	const daySlotsContainersRef = (0, react.useRef)([]);
+	const mergedViewportRef = (0, _mantine_hooks.useMergedRef)(viewportRef, scrollAreaProps?.viewportRef);
+	const firstSlotIndex = {
+		dayIndex: 0,
+		slotIndex: 0
+	};
+	(0, _mantine_hooks.useIsomorphicEffect)(() => {
+		if (!startScrollTime || !viewportRef.current) return;
+		const firstDaySlots = slotsRef.current[0];
+		if (!firstDaySlots || firstDaySlots.length === 0) return;
+		const targetIndex = slots.findIndex((s) => s.startTime >= startScrollTime);
+		if (targetIndex < 0) return;
+		const targetSlot = firstDaySlots[targetIndex];
+		if (!targetSlot) return;
+		const slotRect = targetSlot.getBoundingClientRect();
+		const viewportRect = viewportRef.current.getBoundingClientRect();
+		viewportRef.current.scrollTo({
+			left: 0,
+			top: slotRect.top - viewportRect.top
+		});
+	}, []);
+	const getSlotIndexFromDragPoint = (0, react.useCallback)((event, dayIndex) => {
+		const daySlots = slotsRef.current[dayIndex] ?? [];
+		const slotIndex = daySlots.findIndex((slotNode) => {
+			if (!slotNode) return false;
+			const rect = slotNode.getBoundingClientRect();
+			return event.clientY >= rect.top && event.clientY <= rect.bottom;
+		});
+		if (slotIndex >= 0) return slotIndex;
+		const firstSlot = daySlots[0];
+		const lastSlot = daySlots[daySlots.length - 1];
+		if (!firstSlot || !lastSlot) return null;
+		const firstRect = firstSlot.getBoundingClientRect();
+		const lastRect = lastSlot.getBoundingClientRect();
+		if (event.clientY < firstRect.top) return 0;
+		if (event.clientY > lastRect.bottom) return daySlots.length - 1;
+		return null;
+	}, []);
+	const handleSlotKeyDown = (event, dayIndex, slotIndex) => {
+		require_handle_week_view_key_down.handleWeekViewKeyDown({
+			controlsRef: slotsRef,
+			dayIndex,
+			slotIndex,
+			event
+		});
+	};
+	const handleAllDaySlotKeyDown = (event, dayIndex) => {
+		const direction = event.key;
+		if (direction === "ArrowRight" && dayIndex < weekdays.length - 1) {
+			event.preventDefault();
+			allDaySlotsRef.current[dayIndex + 1]?.focus();
+		} else if (direction === "ArrowLeft" && dayIndex > 0) {
+			event.preventDefault();
+			allDaySlotsRef.current[dayIndex - 1]?.focus();
+		} else if (direction === "ArrowDown") {
+			event.preventDefault();
+			slotsRef.current?.[dayIndex]?.[0]?.focus();
+		}
+	};
+	const handleWeekdayKeyDown = (event, dayIndex) => {
+		const direction = event.key;
+		if (direction === "ArrowRight" && dayIndex < weekdays.length - 1) {
+			event.preventDefault();
+			weekdaysRef.current[dayIndex + 1]?.focus();
+		} else if (direction === "ArrowLeft" && dayIndex > 0) {
+			event.preventDefault();
+			weekdaysRef.current[dayIndex - 1]?.focus();
+		}
+	};
+	const currentWeekdayIndex = withCurrentTimeIndicator ? weekdays.findIndex((day) => (0, dayjs.default)(day).isSame((0, dayjs.default)(), "date")) : -1;
+	const weekdaysLabels = weekdays.map((day, dayIndex) => /* @__PURE__ */ (0, react.createElement)(_mantine_core.UnstyledButton, {
+		...getStyles("weekViewDayLabel"),
+		key: day,
+		ref: (node) => {
+			weekdaysRef.current[dayIndex] = node;
+		},
+		"aria-label": `${require_labels.getLabel("weekday", labels)} ${(0, dayjs.default)(day).format("YYYY-MM-DD")}`,
+		mod: {
+			today: (0, dayjs.default)(day).isSame((0, dayjs.default)(), "day") && !!highlightToday,
+			weekend: ctx.getWeekendDays(weekendDays).includes((0, dayjs.default)(day).day()),
+			static: mode === "static"
+		},
+		tabIndex: mode === "static" ? -1 : dayIndex === 0 ? 0 : -1,
+		onKeyDown: mode === "static" ? void 0 : (event) => handleWeekdayKeyDown(event, dayIndex),
+		onClick: mode === "static" ? void 0 : () => {
+			onViewChange?.("day");
+			onDateChange?.(require_to_date_string.toDateString(day));
+		}
+	}, /* @__PURE__ */ (0, react.createElement)(_mantine_core.Box, {
+		...getStyles("weekViewDayWeekday"),
+		key: "weekday"
+	}, require_format_date.formatDate({
+		locale: ctx.getLocale(locale),
+		date: day,
+		format: weekdayFormat
+	})), /* @__PURE__ */ (0, react.createElement)("div", {
+		...getStyles("weekViewDayNumber"),
+		key: "date"
+	}, (0, dayjs.default)(day).date())));
+	const days = weekdays.map((day, dayIndex) => {
+		const backgroundEventNodes = (weekEvents.backgroundEvents[day] || []).filter((event) => !event.position.allDay).map((event) => {
+			const colors = theme.variantColorResolver({
+				color: event.color || theme.primaryColor,
+				theme,
+				variant: "light",
+				autoContrast: true
+			});
+			const bgEventBody = typeof renderEventBody === "function" ? renderEventBody(event) : event.title;
+			const bgEventProps = {
+				key: `bg-${event.id}`,
+				...getStyles("weekViewBackgroundEvent", { style: {
+					top: `${event.position.top}%`,
+					height: `${event.position.height}%`,
+					width: "100%"
+				} }),
+				__vars: {
+					"--bg-event-bg": colors.background,
+					"--bg-event-color": colors.color
+				},
+				children: bgEventBody
+			};
+			if (typeof renderEvent === "function") return renderEvent(event, bgEventProps);
+			return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_mantine_core.Box, { ...bgEventProps });
+		});
+		const dayEvents = (weekEvents.regularEvents[day] || []).map((event) => {
+			const eventIsAllDay = require_is_all_day_event.isAllDayEvent({
+				event,
+				date: day
+			});
+			const isDraggable = !eventIsAllDay && dragDrop.isDraggableEvent(event);
+			const isResizable = !eventIsAllDay && eventResize.isResizableEvent(event);
+			const resizePosition = eventResize.getResizePosition(event.id);
+			const eventTop = resizePosition ? resizePosition.top : event.position.top;
+			const eventHeight = resizePosition ? resizePosition.height : event.position.height;
+			return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(require_ScheduleEvent.ScheduleEvent, {
+				event,
+				autoSize: true,
+				hanging: event.position.hanging,
+				draggable: isDraggable,
+				withResize: isResizable,
+				isResizing: resizePosition !== null,
+				onResizeStart: isResizable ? (edge, e) => {
+					const container = daySlotsContainersRef.current[dayIndex];
+					if (container) eventResize.handleResizeStart(event, edge, container, event.position.top, event.position.height, (0, dayjs.default)(day).format("YYYY-MM-DD"), e);
+				} : void 0,
+				renderEventBody,
+				renderEvent,
+				radius,
+				mode,
+				onClick: onEventClick ? (e) => onEventClick(event, e) : void 0,
+				style: {
+					position: "absolute",
+					top: `calc(${eventTop}% + 1px)`,
+					left: `${event.position.offset}%`,
+					width: `${event.position.width}%`,
+					height: `calc(${eventHeight}% - 1px)`
+				}
+			}, event.id);
+		});
+		return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)(require_WeekViewDay.WeekViewDay, {
+			day,
+			dayIndex,
+			slots,
+			getStyles,
+			weekendDays,
+			highlightBusinessHours,
+			businessHours,
+			labels,
+			withEventsDragAndDrop: withDragHandlers,
+			mode,
+			slotsRef,
+			firstSlotIndex,
+			onSlotKeyDown: handleSlotKeyDown,
+			onSlotClick: handleTimeSlotClick,
+			onFirstSlotArrowUp: withAllDaySlots ? (dayIdx) => {
+				allDaySlotsRef.current[dayIdx]?.focus();
+			} : void 0,
+			onDaySlotsDragOver: (event, dayStr, dayIdx) => {
+				const slotIndex = getSlotIndexFromDragPoint(event, dayIdx);
+				if (slotIndex !== null) dragDrop.handleDragOver(event, {
+					day: dayStr,
+					slotIndex
+				});
+			},
+			onDaySlotsDragLeave: dragDrop.handleDragLeave,
+			onDaySlotsDrop: (event, dayStr, dayIdx) => {
+				const slotIndex = getSlotIndexFromDragPoint(event, dayIdx);
+				if (slotIndex !== null) dragDrop.handleDrop(event, {
+					day: dayStr,
+					slotIndex
+				});
+			},
+			dropTargetSlotIndex: dragDrop.dropTarget?.day === day ? dragDrop.dropTarget.slotIndex : void 0,
+			withDragSlotSelect,
+			onSlotPointerDown: slotDragSelect.handleSlotPointerDown,
+			isSlotDragSelected: slotDragSelect.isSlotSelected,
+			daySlotsContainerRef: (node) => {
+				daySlotsContainersRef.current[dayIndex] = node;
+			},
+			children: [backgroundEventNodes, dayEvents]
+		}, day);
+	});
+	const allDaySlots = weekdays.map((day, dayIndex) => /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_mantine_core.UnstyledButton, {
+		"aria-label": `${require_labels.getLabel("allDay", labels)} ${(0, dayjs.default)(day).format("YYYY-MM-DD")}`,
+		ref: (node) => {
+			allDaySlotsRef.current[dayIndex] = node;
+		},
+		tabIndex: dayIndex === 0 ? 0 : -1,
+		onKeyDown: (event) => handleAllDaySlotKeyDown(event, dayIndex),
+		onClick: mode === "static" || !onAllDaySlotClick ? void 0 : (e) => onAllDaySlotClick((0, dayjs.default)(day).format("YYYY-MM-DD"), e),
+		onDragOver: withDragHandlers ? (e) => allDayDragDrop.handleDragOver(e, day) : void 0,
+		onDragLeave: withDragHandlers ? allDayDragDrop.handleDragLeave : void 0,
+		onDrop: withDragHandlers ? (e) => allDayDragDrop.handleDrop(e, day) : void 0,
+		...getStyles("weekViewDaySlot"),
+		mod: { "drop-target": allDayDragDrop.isDropTarget(day) }
+	}, day));
+	const allDayEventIds = (0, react.useMemo)(() => new Set(weekEvents.allDayEvents.map((e) => e.id)), [weekEvents.allDayEvents]);
+	const allDayEvents = weekEvents.allDayEvents.map((event) => /* @__PURE__ */ (0, react_jsx_runtime.jsx)(require_ScheduleEvent.ScheduleEvent, {
+		event,
+		autoSize: true,
+		nowrap: true,
+		hanging: event.position.hanging,
+		draggable: allDayDragDrop.isDraggableEvent(event),
+		renderEvent,
+		mode,
+		onClick: onEventClick ? (e) => onEventClick(event, e) : void 0,
+		style: {
+			position: "absolute",
+			zIndex: 2,
+			top: `calc(${event.position.row * 50}% + 1px)`,
+			left: `calc(${event.position.offset}% + 1px)`,
+			width: `calc(${event.position.width}% - 1px)`,
+			height: "calc(50% - 2px)",
+			maxHeight: "calc(50% - 2px)"
+		}
+	}, event.id));
+	const allDayBackgroundEventNodes = weekdays.flatMap((day, dayIndex) => {
+		const allDayBgEvents = (weekEvents.backgroundEvents[day] || []).filter((event) => event.position.allDay);
+		const dayWidth = 100 / weekdays.length;
+		const dayOffset = dayIndex * dayWidth;
+		return allDayBgEvents.map((event) => {
+			const colors = theme.variantColorResolver({
+				color: event.color || theme.primaryColor,
+				theme,
+				variant: "light",
+				autoContrast: true
+			});
+			const bgEventBody = typeof renderEventBody === "function" ? renderEventBody(event) : event.title;
+			const bgEventProps = {
+				key: `bg-allday-${event.id}-${day}`,
+				...getStyles("weekViewBackgroundEvent", { style: {
+					top: 0,
+					height: "100%",
+					left: `${dayOffset}%`,
+					width: `${dayWidth}%`
+				} }),
+				__vars: {
+					"--bg-event-bg": colors.background,
+					"--bg-event-color": colors.color
+				},
+				children: bgEventBody
+			};
+			if (typeof renderEvent === "function") return renderEvent(event, bgEventProps);
+			return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_mantine_core.Box, { ...bgEventProps });
+		});
+	});
+	const extraRows = Math.max(...weekEvents.allDayEvents.map((event) => event.position.row), 1) - 1;
+	const content = /* @__PURE__ */ (0, react_jsx_runtime.jsxs)(_mantine_core.Box, {
+		...getStyles("weekView"),
+		mod: {
+			static: mode === "static",
+			"slot-dragging": slotDragSelect.isDragging
+		},
+		...others,
+		children: [withHeader && /* @__PURE__ */ (0, react_jsx_runtime.jsx)(require_ScheduleHeaderBase.ScheduleHeaderBase, {
+			view: "week",
+			navigationHandlers: {
+				previous: () => require_previous_week.previousWeek(date, ctx.getFirstDayOfWeek(firstDayOfWeek)),
+				next: () => require_next_week.nextWeek(date, ctx.getFirstDayOfWeek(firstDayOfWeek)),
+				today: () => require_to_date_string.toDateString((0, dayjs.default)())
+			},
+			control: {
+				miw: 140,
+				title: require_get_week_label.getWeekLabel({
+					weekdays,
+					locale: ctx.getLocale(locale),
+					weekLabelFormat,
+					renderWeekLabel
+				})
+			},
+			labels,
+			onDateChange,
+			onViewChange,
+			previousControlProps,
+			nextControlProps,
+			todayControlProps,
+			viewSelectProps,
+			stylesApiProps
+		}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_mantine_core.Box, {
+			...getStyles("weekViewRoot"),
+			__vars: {
+				"--indicator-offset-index": currentWeekdayIndex === -1 ? void 0 : `${currentWeekdayIndex + 1}`,
+				"--number-of-days": withWeekendDays ? "7" : `${7 - ctx.getWeekendDays(weekendDays).length}`
+			},
+			mod: { "with-weekends": withWeekendDays },
+			children: /* @__PURE__ */ (0, react_jsx_runtime.jsxs)(_mantine_core.ScrollArea.Autosize, {
+				scrollbarSize: 4,
+				...scrollAreaProps,
+				...getStyles("weekViewScrollArea", {
+					className: scrollAreaProps?.className,
+					style: scrollAreaProps?.style
+				}),
+				onScrollPositionChange: (position) => {
+					scrollAreaProps?.onScrollPositionChange?.(position);
+					setScrolled(position.y !== 0);
+				},
+				viewportRef: mergedViewportRef,
+				children: [
+					/* @__PURE__ */ (0, react_jsx_runtime.jsxs)(_mantine_core.Box, {
+						...getStyles("weekViewHeader"),
+						mod: { scrolled },
+						children: [/* @__PURE__ */ (0, react.createElement)("div", {
+							...getStyles("weekViewCorner"),
+							key: "corner"
+						}, withWeekNumber && /* @__PURE__ */ (0, react_jsx_runtime.jsxs)(react_jsx_runtime.Fragment, { children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+							...getStyles("weekViewWeekLabel"),
+							children: require_labels.getLabel("week", labels)
+						}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+							...getStyles("weekViewWeekNumber"),
+							children: require_get_week_number.getWeekNumber(date)
+						})] })), weekdaysLabels]
+					}),
+					withAllDaySlots && /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+						...getStyles("weekViewAllDaySlots"),
+						children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+							...getStyles("weekViewAllDaySlotsLabel"),
+							children: require_labels.getLabel("allDay", labels)
+						}), /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+							...getStyles("weekViewAllDaySlotsList"),
+							children: [
+								allDayBackgroundEventNodes,
+								/* @__PURE__ */ (0, react_jsx_runtime.jsx)(_mantine_core.Box, {
+									...getStyles("weekViewAllDaySlotsEvents"),
+									__vars: { "--extra-rows": `${extraRows}` },
+									children: allDayEvents
+								}),
+								allDaySlots
+							]
+						})]
+					}),
+					/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+						...getStyles("weekViewInner"),
+						children: [
+							/* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+								...getStyles("weekViewSlotLabels"),
+								children: timeValues
+							}),
+							withCurrentTimeIndicator && currentWeekdayIndex !== -1 && /* @__PURE__ */ (0, react_jsx_runtime.jsx)(require_CurrentTimeIndicator.CurrentTimeIndicator, {
+								startOffset: "calc(100% - (100% / var(--number-of-days)) * (var(--number-of-days) - var(--indicator-offset-index) + 1) + ((var(--number-of-days) - var(--indicator-offset-index) + 1) * var(--indicator-labels-offset)))",
+								endOffset: "calc((100% / var(--number-of-days)) * (var(--number-of-days) - var(--indicator-offset-index)) - (var(--number-of-days) - var(--indicator-offset-index)) * var(--indicator-labels-offset))",
+								timeBubbleStartOffset: "calc(var(--week-view-slots-label-width) - var(--time-bubble-width))",
+								currentTimeFormat: slotLabelFormat,
+								withTimeBubble: withCurrentTimeBubble,
+								withThumb: withCurrentTimeBubble ? currentWeekdayIndex !== 0 : true,
+								locale,
+								startTime,
+								endTime,
+								...stylesApiProps
+							}),
+							days
+						]
+					})
+				]
+			})
+		})]
+	});
+	const mergedDragContextValue = (0, react.useMemo)(() => ({
+		isDragging: dragDrop.dragContextValue.isDragging || allDayDragDrop.dragContextValue.isDragging,
+		draggedEventId: dragDrop.dragContextValue.draggedEventId ?? allDayDragDrop.dragContextValue.draggedEventId,
+		draggedEvent: dragDrop.dragContextValue.draggedEvent ?? allDayDragDrop.dragContextValue.draggedEvent,
+		dropTarget: dragDrop.dragContextValue.dropTarget ?? allDayDragDrop.dragContextValue.dropTarget,
+		onDragStart: (event) => {
+			if (allDayEventIds.has(event.id)) allDayDragDrop.handleDragStart(event);
+			else dragDrop.handleDragStart(event);
+		},
+		onDragEnd: () => {
+			dragDrop.handleDragEnd();
+			allDayDragDrop.handleDragEnd();
+		},
+		setDropTarget: dragDrop.dragContextValue.setDropTarget
+	}), [
+		dragDrop.dragContextValue,
+		allDayDragDrop.dragContextValue,
+		allDayEventIds
+	]);
+	if (withEventsDragAndDrop) return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(require_DragContext.DragContext.Provider, {
+		value: mergedDragContextValue,
+		children: content
+	});
+	return content;
 });
 WeekView.displayName = "@mantine/schedule/WeekView";
-WeekView.classes = WeekView_module;
+WeekView.classes = require_WeekView_module.default;
 WeekView.varsResolver = varsResolver;
-
+//#endregion
 exports.WeekView = WeekView;
-//# sourceMappingURL=WeekView.cjs.map
+
+//# sourceMappingURL=WeekView.cjs.map