@primeui/scheduler-core 0.0.1-alpha.1

package/dist/chunk-6OZAPQZ5.mjs

@@ -0,0 +1,229 @@
+import { getLocalTimezone, convertEventsToTimezone } from './chunk-QDMZBJDV.mjs';
+import { formatGregorianYear, formatGregorianMonthTitle, formatGregorianWeekday, formatGregorianDayNumber, toDateString } from './chunk-WFUJWDST.mjs';
+import { getSchedulerCalendarAdapter } from './chunk-DYW6WUHE.mjs';
+
+// src/year/view-model.ts
+function toDate(value) {
+  if (!value) return null;
+  return value instanceof Date ? value : new Date(value);
+}
+function getFallbackEnd(start, event) {
+  if (typeof event.duration === "number" && Number.isFinite(event.duration) && event.duration > 0) {
+    return new Date(start.getTime() + event.duration);
+  }
+  return new Date(start.getTime() + 60 * 60 * 1e3);
+}
+function normalizeEventToDisplayTimezone(event, schedulerTimezone, displayTimezone) {
+  const start = toDate(event.start);
+  if (!start) {
+    return event;
+  }
+  const end = toDate(event.end) ?? getFallbackEnd(start, event);
+  const sourceTimezone = event.timezone ?? schedulerTimezone ?? getLocalTimezone();
+  const normalized = {
+    ...event,
+    start,
+    end,
+    timezone: sourceTimezone
+  };
+  if (sourceTimezone === displayTimezone) {
+    return {
+      ...normalized,
+      timezone: displayTimezone
+    };
+  }
+  const [converted] = convertEventsToTimezone([normalized], displayTimezone);
+  return {
+    ...converted,
+    timezone: displayTimezone
+  };
+}
+function normalizeEventsToDisplayTimezone(events, schedulerTimezone, resolvedDisplayTimezone) {
+  if (!resolvedDisplayTimezone) {
+    return events;
+  }
+  return events.map((event) => normalizeEventToDisplayTimezone(event, schedulerTimezone, resolvedDisplayTimezone));
+}
+function buildWeekdayHeaders(firstDayOfWeek, locale, displayConfig) {
+  return Array.from({ length: 7 }, (_, index) => {
+    const dayIndex = (firstDayOfWeek + index) % 7;
+    return {
+      dayIndex,
+      label: formatGregorianWeekday(new Date(2024, 0, 7 + dayIndex), locale, "narrow", {}, displayConfig)
+    };
+  });
+}
+function getRangeInfo(date, selectedRange, calendarAdapter) {
+  if (!selectedRange?.start || !selectedRange.end) {
+    return { isInRange: false, isRangeStart: false, isRangeEnd: false };
+  }
+  const day = calendarAdapter.fromDate(date);
+  const start = calendarAdapter.fromDate(selectedRange.start);
+  const end = calendarAdapter.fromDate(selectedRange.end);
+  const min = calendarAdapter.compare(start, end) <= 0 ? start : end;
+  const max = calendarAdapter.compare(start, end) <= 0 ? end : start;
+  if (calendarAdapter.compare(day, min) < 0 || calendarAdapter.compare(day, max) > 0) {
+    return { isInRange: false, isRangeStart: false, isRangeEnd: false };
+  }
+  return {
+    isInRange: true,
+    isRangeStart: calendarAdapter.isSameDay(day, start),
+    isRangeEnd: calendarAdapter.isSameDay(day, end)
+  };
+}
+function isDateSelected(date, selectedDates, calendarAdapter) {
+  const calendarDate = calendarAdapter.fromDate(date);
+  return Boolean(selectedDates?.some((selectedDate) => calendarAdapter.isSameDay(calendarAdapter.fromDate(selectedDate), calendarDate)));
+}
+function getCategoryColor(event, categories, categoryField) {
+  const categoryId = event[categoryField];
+  const categoryColor = categoryId != null ? categories.find((category) => category.id === categoryId)?.color : void 0;
+  return categoryColor ?? event.color;
+}
+function getEventsForDate(date, events, calendarAdapter) {
+  const calendarDate = calendarAdapter.fromDate(date);
+  const dayStart = calendarAdapter.toDate(calendarDate);
+  const dayEnd = calendarAdapter.toDate(calendarAdapter.add(calendarDate, { days: 1 }));
+  return events.filter((event) => {
+    const start = toDate(event.start);
+    if (!start) {
+      return false;
+    }
+    const end = toDate(event.end) ?? getFallbackEnd(start, event);
+    return start < dayEnd && end > dayStart;
+  });
+}
+function isDateInCalendarRange(date, minDate, maxDate, calendarAdapter) {
+  const calendarDate = calendarAdapter.fromDate(date);
+  if (minDate && calendarAdapter.compare(calendarDate, calendarAdapter.fromDate(minDate)) < 0) {
+    return false;
+  }
+  if (maxDate && calendarAdapter.compare(calendarDate, calendarAdapter.fromDate(maxDate)) > 0) {
+    return false;
+  }
+  return true;
+}
+function buildDayCell(input) {
+  const calendarDate = input.calendarAdapter.fromDate(input.date);
+  const todayCalendarDate = input.calendarAdapter.fromDate(input.today);
+  const dayOfWeek = input.calendarAdapter.getDayOfWeek(calendarDate);
+  const isOtherMonth = calendarDate.month !== input.monthDate.month || calendarDate.year !== input.monthDate.year;
+  const rangeInfo = isOtherMonth ? { isInRange: false, isRangeStart: false, isRangeEnd: false } : getRangeInfo(input.date, input.selectedRange, input.calendarAdapter);
+  const events = isOtherMonth ? [] : getEventsForDate(input.date, input.events, input.calendarAdapter);
+  const eventCount = events.length;
+  const indicatorColor = events.map((event) => getCategoryColor(event, input.categories, input.categoryField)).find((color) => Boolean(color));
+  const indicator = eventCount > 0 ? { count: eventCount, color: indicatorColor } : null;
+  const dayOfMonthLabel = formatGregorianDayNumber(input.date, input.locale, {}, { calendar: input.calendar, numberingSystem: input.numberingSystem });
+  return {
+    date: input.date,
+    dateKey: toDateString(input.date),
+    dayOfMonth: calendarDate.day,
+    dayOfMonthLabel,
+    dayNumberLabel: dayOfMonthLabel,
+    isOtherMonth,
+    isPlaceholder: isOtherMonth,
+    isCurrentMonth: !isOtherMonth,
+    isToday: !isOtherMonth && input.calendarAdapter.isSameDay(calendarDate, todayCalendarDate),
+    isWeekend: dayOfWeek === 0 || dayOfWeek === 6,
+    isDisabled: !isDateInCalendarRange(input.date, input.minDate, input.maxDate, input.calendarAdapter),
+    isSelected: !isOtherMonth && isDateSelected(input.date, input.selectedDates, input.calendarAdapter),
+    isInRange: rangeInfo.isInRange,
+    isRangeStart: rangeInfo.isRangeStart,
+    isRangeEnd: rangeInfo.isRangeEnd,
+    events,
+    eventCount,
+    hasEvents: eventCount > 0,
+    indicator,
+    indicatorColor
+  };
+}
+function buildMonthWeeks(input) {
+  const monthDate = input.calendarAdapter.startOfMonth({ year: input.year, month: input.month + 1, day: 1 });
+  const lastDay = input.calendarAdapter.endOfMonth(monthDate);
+  const gridStart = input.calendarAdapter.startOfWeek(monthDate, input.firstDayOfWeek);
+  const weeks = [];
+  let cursor = gridStart;
+  while (input.calendarAdapter.compare(cursor, lastDay) <= 0 || weeks.length === 0 || weeks[weeks.length - 1].days.length < 7) {
+    const days = [];
+    for (let dayIndex = 0; dayIndex < 7; dayIndex++) {
+      const date = input.calendarAdapter.toDate(cursor);
+      days.push(
+        buildDayCell({
+          date,
+          monthDate,
+          calendarAdapter: input.calendarAdapter,
+          today: input.today,
+          events: input.events,
+          categories: input.categories,
+          categoryField: input.categoryField,
+          minDate: input.minDate,
+          maxDate: input.maxDate,
+          selectedDates: input.selectedDates,
+          selectedRange: input.selectedRange,
+          locale: input.locale,
+          calendar: input.calendar,
+          numberingSystem: input.numberingSystem
+        })
+      );
+      cursor = input.calendarAdapter.add(cursor, { days: 1 });
+    }
+    weeks.push({ days });
+    if ((cursor.month !== monthDate.month || cursor.year !== monthDate.year) && weeks.length >= 4) {
+      break;
+    }
+  }
+  return weeks;
+}
+function buildYearGridViewModel(input) {
+  const calendarAdapter = getSchedulerCalendarAdapter(input.calendar, { locale: input.locale });
+  const currentCalendarDate = calendarAdapter.fromDate(input.currentDate);
+  const year = currentCalendarDate.year;
+  const displayConfig = { calendar: input.calendar, numberingSystem: input.numberingSystem };
+  const weekdayHeaders = buildWeekdayHeaders(input.firstDayOfWeek, input.locale, displayConfig);
+  const displayEvents = normalizeEventsToDisplayTimezone(input.events, input.schedulerTimezone, input.resolvedDisplayTimezone);
+  const categories = input.categories ?? [];
+  const categoryField = input.categoryField ?? "categoryId";
+  const today = input.now ?? /* @__PURE__ */ new Date();
+  const yearStart = calendarAdapter.toDate({ ...calendarAdapter.startOfMonth(currentCalendarDate), month: 1 });
+  const monthsInYear = calendarAdapter.getMonthsInYear(currentCalendarDate);
+  const yearLabel = formatGregorianYear(yearStart, input.locale, {}, displayConfig);
+  const months = Array.from({ length: monthsInYear }, (_, monthIndex) => {
+    const date = calendarAdapter.toDate({ year, month: monthIndex + 1, day: 1 });
+    const weeks = buildMonthWeeks({
+      year,
+      month: monthIndex,
+      firstDayOfWeek: input.firstDayOfWeek,
+      calendarAdapter,
+      today,
+      events: displayEvents,
+      categories,
+      categoryField,
+      minDate: input.minDate,
+      maxDate: input.maxDate,
+      selectedDates: input.selectedDates,
+      selectedRange: input.selectedRange,
+      locale: input.locale,
+      calendar: input.calendar,
+      numberingSystem: input.numberingSystem
+    });
+    const days = weeks.flatMap((week) => week.days);
+    const monthLabel = formatGregorianMonthTitle(date, input.locale, { year: void 0 }, displayConfig);
+    return {
+      monthIndex,
+      date,
+      name: monthLabel,
+      monthLabel,
+      weekdayHeaders,
+      weeks,
+      days
+    };
+  });
+  return {
+    year,
+    yearLabel,
+    weekdayHeaders,
+    months
+  };
+}
+
+export { buildYearGridViewModel };

package/dist/chunk-6PK5WSKT.mjs

@@ -0,0 +1,369 @@
+import { getLocalTimezone, convertEventsToTimezone } from './chunk-QDMZBJDV.mjs';
+import { startOfDay, isSameDay, addDays, toDateString, formatGregorianMonthTitle, getWeekNumber, formatGregorianDayNumber } from './chunk-WFUJWDST.mjs';
+import { getSchedulerCalendarAdapter } from './chunk-DYW6WUHE.mjs';
+
+// src/month/layout.ts
+function daysBetween(a, b) {
+  const aMs = new Date(a.getFullYear(), a.getMonth(), a.getDate()).getTime();
+  const bMs = new Date(b.getFullYear(), b.getMonth(), b.getDate()).getTime();
+  return Math.round((bMs - aMs) / 864e5);
+}
+function durationDays(event) {
+  const start = event.start instanceof Date ? event.start : new Date(event.start);
+  const end = event.end ? event.end instanceof Date ? event.end : new Date(event.end) : start;
+  return Math.max(1, Math.ceil((end.getTime() - start.getTime()) / 864e5));
+}
+function getEventsForMonthWeek(events, days) {
+  const weekStart = startOfDay(days[0]);
+  const weekEnd = new Date(startOfDay(days[6]));
+  weekEnd.setHours(23, 59, 59, 999);
+  return events.filter((event) => {
+    const eventStart = event.start instanceof Date ? event.start : new Date(event.start);
+    const eventEnd = event.end ? event.end instanceof Date ? event.end : new Date(event.end) : eventStart;
+    return eventStart <= weekEnd && eventEnd >= weekStart;
+  });
+}
+function getEventsForMonthDay(events, date) {
+  const dayStart = startOfDay(date);
+  const dayEnd = new Date(dayStart);
+  dayEnd.setHours(23, 59, 59, 999);
+  return events.filter((event) => {
+    const eventStart = event.start instanceof Date ? event.start : new Date(event.start);
+    const eventEnd = event.end ? event.end instanceof Date ? event.end : new Date(event.end) : eventStart;
+    return eventStart <= dayEnd && eventEnd >= dayStart;
+  });
+}
+function getMonthSpanningEventLayout(event, weekStart) {
+  const eventStart = event.start instanceof Date ? event.start : new Date(event.start);
+  const eventEnd = event.end ? event.end instanceof Date ? event.end : new Date(event.end) : eventStart;
+  if (isSameDay(eventStart, eventEnd)) return null;
+  const weekEnd = new Date(addDays(weekStart, 6));
+  weekEnd.setHours(23, 59, 59, 999);
+  let colStart = 1;
+  for (let index = 0; index < 7; index++) {
+    const day = addDays(weekStart, index);
+    if (isSameDay(day, eventStart) || day >= eventStart) {
+      colStart = index + 1;
+      break;
+    }
+  }
+  if (eventStart < weekStart) {
+    colStart = 1;
+  }
+  let colEnd = colStart + 1;
+  for (let index = colStart - 1; index < 7; index++) {
+    const day = addDays(weekStart, index);
+    if (isSameDay(day, eventEnd) || day >= eventEnd) {
+      colEnd = index + 2;
+      break;
+    }
+    if (index === 6) {
+      colEnd = 8;
+    }
+  }
+  if (eventEnd > weekEnd) {
+    colEnd = 8;
+  }
+  return { gridColumnStart: colStart, gridColumnEnd: colEnd, row: 0 };
+}
+function buildMonthWeekEventLayout(input) {
+  const { events, maxVisibleRows, stackingMode } = input;
+  const weekStartDay = startOfDay(input.weekStart);
+  const weekEndDay = startOfDay(addDays(weekStartDay, 6));
+  const weekDays = Array.from({ length: 7 }, (_, index) => addDays(weekStartDay, index));
+  const overlapping = events.filter((event) => {
+    const eventStart = event.start instanceof Date ? event.start : new Date(event.start);
+    const eventEnd = event.end ? event.end instanceof Date ? event.end : new Date(event.end) : eventStart;
+    const eventStartDay = startOfDay(eventStart);
+    const eventEndDay = startOfDay(eventEnd);
+    return eventStartDay <= weekEndDay && eventEndDay >= weekStartDay;
+  });
+  const sorted = [...overlapping].sort((a, b) => {
+    const da = durationDays(a);
+    const db = durationDays(b);
+    if (da !== db) return db - da;
+    const aStart = a.start instanceof Date ? a.start.getTime() : new Date(a.start).getTime();
+    const bStart = b.start instanceof Date ? b.start.getTime() : new Date(b.start).getTime();
+    return aStart - bStart;
+  });
+  const lanes = [];
+  const allPositioned = [];
+  const rawTimedByDay = {};
+  for (const event of sorted) {
+    const eventStart = event.start instanceof Date ? event.start : new Date(event.start);
+    const eventEnd = event.end ? event.end instanceof Date ? event.end : new Date(event.end) : eventStart;
+    const eventStartDay = startOfDay(eventStart);
+    const eventEndDay = startOfDay(eventEnd);
+    const rawStartCol = daysBetween(weekStartDay, eventStartDay);
+    const rawEndCol = daysBetween(weekStartDay, eventEndDay);
+    const startCol = Math.max(0, Math.min(6, rawStartCol));
+    const endCol = Math.max(0, Math.min(6, rawEndCol));
+    if (endCol < startCol) continue;
+    const isSpanning = event.allDay === true || eventStartDay.getTime() !== eventEndDay.getTime();
+    if (!isSpanning) {
+      const key = toDateString(weekDays[startCol]);
+      if (!rawTimedByDay[key]) rawTimedByDay[key] = [];
+      rawTimedByDay[key].push(event);
+      continue;
+    }
+    const isContinuationStart = rawStartCol < 0;
+    const isContinuationEnd = rawEndCol > 6;
+    let laneIndex;
+    if (stackingMode === "collapse") {
+      laneIndex = 0;
+      if (lanes.length === 0) lanes.push([]);
+      lanes[0].push({ start: startCol, end: endCol });
+    } else if (stackingMode === "expand") {
+      laneIndex = lanes.length;
+      lanes.push([{ start: startCol, end: endCol }]);
+    } else {
+      laneIndex = -1;
+      for (let index = 0; index < lanes.length; index++) {
+        const lane = lanes[index];
+        const conflict = lane.some((occupant) => !(endCol < occupant.start || startCol > occupant.end));
+        if (!conflict) {
+          laneIndex = index;
+          break;
+        }
+      }
+      if (laneIndex === -1) {
+        laneIndex = lanes.length;
+        lanes.push([]);
+      }
+      lanes[laneIndex].push({ start: startCol, end: endCol });
+    }
+    allPositioned.push({
+      event,
+      row: laneIndex,
+      startCol,
+      endCol,
+      isContinuationStart,
+      isContinuationEnd
+    });
+  }
+  const computeLayout = (budget) => {
+    const visibleBars = allPositioned.filter((positioned) => positioned.row < budget);
+    const overflowBars = allPositioned.filter((positioned) => positioned.row >= budget);
+    const timedByDay = {};
+    const overflowByDay = {};
+    for (const bar of overflowBars) {
+      for (let column = bar.startCol; column <= bar.endCol; column++) {
+        const key = toDateString(weekDays[column]);
+        if (!overflowByDay[key]) overflowByDay[key] = [];
+        overflowByDay[key].push(bar.event);
+      }
+    }
+    const dayStats = [];
+    for (let column = 0; column < 7; column++) {
+      const key = toDateString(weekDays[column]);
+      const barsInDay = visibleBars.filter((positioned) => positioned.startCol <= column && column <= positioned.endCol);
+      const spanningDepth = barsInDay.length === 0 ? 0 : Math.max(...barsInDay.map((positioned) => positioned.row)) + 1;
+      const timedBudget = Math.max(0, budget - spanningDepth);
+      const timedList = rawTimedByDay[key] ?? [];
+      const visibleTimed = timedList.slice(0, timedBudget);
+      const overflowTimed = timedList.slice(timedBudget);
+      if (visibleTimed.length > 0) timedByDay[key] = visibleTimed;
+      if (overflowTimed.length > 0) {
+        if (!overflowByDay[key]) overflowByDay[key] = [];
+        overflowByDay[key].push(...overflowTimed);
+      }
+      dayStats.push({ spanningDepth, overflowCount: (overflowByDay[key] ?? []).length });
+    }
+    return { positioned: visibleBars, overflowByDay, timedByDay, dayStats };
+  };
+  const withoutReservation = computeLayout(maxVisibleRows);
+  const hasOverflow = withoutReservation.dayStats.some((stats) => stats.overflowCount > 0);
+  if (!hasOverflow || maxVisibleRows === 0) return withoutReservation;
+  return computeLayout(Math.max(0, maxVisibleRows - 1));
+}
+
+// src/month/view-model.ts
+function toDate(value) {
+  if (!value) return null;
+  return value instanceof Date ? value : new Date(value);
+}
+function getFallbackEnd(start, event) {
+  if (typeof event.duration === "number" && Number.isFinite(event.duration) && event.duration > 0) {
+    return new Date(start.getTime() + event.duration);
+  }
+  return new Date(start.getTime() + 60 * 60 * 1e3);
+}
+function normalizeEventToDisplayTimezone(event, schedulerTimezone, displayTimezone) {
+  const start = toDate(event.start);
+  if (!start) {
+    return event;
+  }
+  const end = toDate(event.end) ?? getFallbackEnd(start, event);
+  const sourceTimezone = event.timezone ?? schedulerTimezone ?? getLocalTimezone();
+  const normalized = {
+    ...event,
+    start,
+    end,
+    timezone: sourceTimezone
+  };
+  if (sourceTimezone === displayTimezone) {
+    return {
+      ...normalized,
+      timezone: displayTimezone
+    };
+  }
+  const [converted] = convertEventsToTimezone([normalized], displayTimezone);
+  return {
+    ...converted,
+    timezone: displayTimezone
+  };
+}
+function normalizeEventsToDisplayTimezone(events, schedulerTimezone, resolvedDisplayTimezone) {
+  if (!resolvedDisplayTimezone) {
+    return events;
+  }
+  return events.map((event) => normalizeEventToDisplayTimezone(event, schedulerTimezone, resolvedDisplayTimezone));
+}
+function isDateSelected(date, selectedDates, calendarAdapter) {
+  const calendarDate = calendarAdapter.fromDate(date);
+  return Boolean(selectedDates?.some((selectedDate) => calendarAdapter.isSameDay(calendarAdapter.fromDate(selectedDate), calendarDate)));
+}
+function getRangeInfo(date, selectedRange, calendarAdapter) {
+  if (!selectedRange?.start || !selectedRange.end) {
+    return { isInRange: false, isRangeStart: false, isRangeEnd: false };
+  }
+  const day = calendarAdapter.fromDate(date);
+  const start = calendarAdapter.fromDate(selectedRange.start);
+  const end = calendarAdapter.fromDate(selectedRange.end);
+  if (calendarAdapter.compare(day, start) < 0 || calendarAdapter.compare(day, end) > 0) {
+    return { isInRange: false, isRangeStart: false, isRangeEnd: false };
+  }
+  return {
+    isInRange: true,
+    isRangeStart: calendarAdapter.isSameDay(day, start),
+    isRangeEnd: calendarAdapter.isSameDay(day, end)
+  };
+}
+function isDateInCalendarRange(date, minDate, maxDate, calendarAdapter) {
+  const calendarDate = calendarAdapter.fromDate(date);
+  if (minDate && calendarAdapter.compare(calendarDate, calendarAdapter.fromDate(minDate)) < 0) {
+    return false;
+  }
+  if (maxDate && calendarAdapter.compare(calendarDate, calendarAdapter.fromDate(maxDate)) > 0) {
+    return false;
+  }
+  return true;
+}
+function getOwningEventCount(events, date, calendarAdapter) {
+  const calendarDate = calendarAdapter.fromDate(date);
+  return events.filter((event) => {
+    const eventStart = event.start instanceof Date ? event.start : new Date(event.start);
+    return calendarAdapter.isSameDay(calendarAdapter.fromDate(eventStart), calendarDate);
+  }).length;
+}
+function getVisibleEventsForDay(layout, date, columnIndex) {
+  const key = toDateString(date);
+  const spanning = layout.positioned.filter((positioned) => positioned.startCol <= columnIndex && columnIndex <= positioned.endCol).map((positioned) => positioned.event);
+  return [...spanning, ...layout.timedByDay[key] ?? []];
+}
+function buildMonthGridViewModel(input) {
+  const calendarAdapter = getSchedulerCalendarAdapter(input.calendar, { locale: input.locale });
+  const currentCalendarDate = calendarAdapter.fromDate(input.currentDate);
+  const monthStartCalendarDate = calendarAdapter.startOfMonth(currentCalendarDate);
+  const monthEndCalendarDate = calendarAdapter.endOfMonth(currentCalendarDate);
+  const monthStart = calendarAdapter.toDate(monthStartCalendarDate);
+  const monthEnd = calendarAdapter.toDate(monthEndCalendarDate);
+  const displayEvents = normalizeEventsToDisplayTimezone(input.events, input.schedulerTimezone, input.resolvedDisplayTimezone);
+  const gridStartCalendarDate = calendarAdapter.startOfWeek(monthStartCalendarDate, input.firstDayOfWeek);
+  const today = input.now ?? /* @__PURE__ */ new Date();
+  const todayCalendarDate = calendarAdapter.fromDate(today);
+  const weekLayouts = /* @__PURE__ */ new Map();
+  const dayCells = [];
+  const weeks = [];
+  const displayConfig = { calendar: input.calendar, numberingSystem: input.numberingSystem };
+  const monthTitle = formatGregorianMonthTitle(monthStart, input.locale, {}, displayConfig);
+  const getEventsForWeek = (days) => getEventsForMonthWeek(displayEvents, days);
+  const getEventsForDay = (date) => getEventsForMonthDay(displayEvents, date);
+  for (let weekIndex = 0; weekIndex < 6; weekIndex++) {
+    const weekStartCalendarDate = calendarAdapter.add(gridStartCalendarDate, { days: weekIndex * 7 });
+    const weekStart = calendarAdapter.toDate(weekStartCalendarDate);
+    const dates = Array.from({ length: 7 }, (_, index) => calendarAdapter.toDate(calendarAdapter.add(weekStartCalendarDate, { days: index })));
+    const weekEvents = getEventsForWeek(dates);
+    const layout = buildMonthWeekEventLayout({
+      events: displayEvents,
+      weekStart,
+      maxVisibleRows: input.maxVisibleRows,
+      stackingMode: input.stackingMode
+    });
+    const weekNumber = getWeekNumber(weekStart, input.weekNumbering, input.locale);
+    const days = dates.map((date, columnIndex) => {
+      const calendarDate = calendarAdapter.fromDate(date);
+      const dayOfWeek = calendarAdapter.getDayOfWeek(calendarDate);
+      const dateKey = toDateString(date);
+      const events = getEventsForDay(date);
+      const rangeInfo = getRangeInfo(date, input.selectedRange, calendarAdapter);
+      const dayOfMonthLabel = formatGregorianDayNumber(date, input.locale, {}, displayConfig);
+      const dayCell = {
+        date,
+        dateKey,
+        dayOfMonth: calendarDate.day,
+        dayOfMonthLabel,
+        dayNumberLabel: dayOfMonthLabel,
+        isCurrentMonth: calendarDate.month === monthStartCalendarDate.month && calendarDate.year === monthStartCalendarDate.year,
+        isToday: calendarAdapter.isSameDay(calendarDate, todayCalendarDate),
+        isWeekend: dayOfWeek === 0 || dayOfWeek === 6,
+        isDisabled: !isDateInCalendarRange(date, input.minDate, input.maxDate, calendarAdapter),
+        isSelected: isDateSelected(date, input.selectedDates, calendarAdapter),
+        isInRange: rangeInfo.isInRange,
+        isRangeStart: rangeInfo.isRangeStart,
+        isRangeEnd: rangeInfo.isRangeEnd,
+        events,
+        timedEvents: layout.timedByDay[dateKey] ?? [],
+        visibleEvents: getVisibleEventsForDay(layout, date, columnIndex),
+        overflowEvents: layout.overflowByDay[dateKey] ?? [],
+        spanningDepth: layout.dayStats[columnIndex]?.spanningDepth ?? 0,
+        overflowCount: layout.dayStats[columnIndex]?.overflowCount ?? 0,
+        eventCount: events.length,
+        owningEventCount: getOwningEventCount(displayEvents, date, calendarAdapter)
+      };
+      dayCells.push(dayCell);
+      return dayCell;
+    });
+    weekLayouts.set(toDateString(weekStart), layout);
+    weeks.push({
+      days,
+      weekNumber,
+      events: weekEvents,
+      layout
+    });
+  }
+  const getWeekLayout = (weekStart) => {
+    const key = toDateString(calendarAdapter.toDate(calendarAdapter.fromDate(weekStart)));
+    return weekLayouts.get(key) ?? buildMonthWeekEventLayout({
+      events: displayEvents,
+      weekStart,
+      maxVisibleRows: input.maxVisibleRows,
+      stackingMode: input.stackingMode
+    });
+  };
+  const getOverflowEvents = (date) => {
+    const calendarDate = calendarAdapter.fromDate(date);
+    return dayCells.find((day) => calendarAdapter.isSameDay(calendarAdapter.fromDate(day.date), calendarDate))?.overflowEvents ?? [];
+  };
+  return {
+    monthStart,
+    monthEnd,
+    monthTitle,
+    events: displayEvents,
+    weeks,
+    dayCells,
+    getEventsForDay,
+    getEventsForWeek,
+    getEventLayout: getMonthSpanningEventLayout,
+    getWeekLayout,
+    getOverflowCount: (date, maxRows) => {
+      if (maxRows == null) {
+        return getOverflowEvents(date).length;
+      }
+      return Math.max(0, getEventsForDay(date).length - maxRows);
+    },
+    getOverflowEvents
+  };
+}
+
+export { buildMonthGridViewModel, buildMonthWeekEventLayout, daysBetween, durationDays, getEventsForMonthDay, getEventsForMonthWeek, getMonthSpanningEventLayout };