@primeui/scheduler-core 0.0.1-alpha.1

package/dist/chunk-KQGRXTP5.mjs

@@ -0,0 +1,650 @@
+import { getDatePartsInTimezone, isSameDayInTimezone } from './chunk-QDMZBJDV.mjs';
+import { startOfDay, addDays, isSameDay } from './chunk-WFUJWDST.mjs';
+import { resolveSchedulerCalendarModeForView, getSchedulerCalendarAdapter } from './chunk-DYW6WUHE.mjs';
+import { calculateResourceRowLayouts, getTotalResourceHeight } from './chunk-QR2SVYAD.mjs';
+
+// src/timeline/layout.ts
+var DEFAULT_TIMELINE_EVENT_MIN_HEIGHT = 36;
+var TIMELINE_LANE_GAP = 2;
+var TIMELINE_LANE_BASE_PADDING = 4;
+var DAY_MS = 24 * 60 * 60 * 1e3;
+function resolveTimelineEventMinHeight(value) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : DEFAULT_TIMELINE_EVENT_MIN_HEIGHT;
+}
+function getTimelineLaneStackHeight(laneCount, eventMinHeight, eventGap = TIMELINE_LANE_GAP) {
+  const gap = Number.isFinite(eventGap) && eventGap >= 0 ? eventGap : TIMELINE_LANE_GAP;
+  return TIMELINE_LANE_BASE_PADDING * 2 + Math.max(1, laneCount) * (eventMinHeight + gap);
+}
+function resolveTimelineResourceRowHeight(input) {
+  const eventHeight = resolveTimelineEventMinHeight(input.eventHeight);
+  const eventGap = typeof input.eventGap === "number" && Number.isFinite(input.eventGap) && input.eventGap >= 0 ? input.eventGap : TIMELINE_LANE_GAP;
+  const compactRowHeight = getTimelineLaneStackHeight(1, eventHeight, eventGap);
+  const minRowHeight = typeof input.minRowHeight === "number" && Number.isFinite(input.minRowHeight) && input.minRowHeight > 0 ? input.minRowHeight : compactRowHeight;
+  if (input.mode === "fixed") {
+    return minRowHeight;
+  }
+  return Math.max(minRowHeight, getTimelineLaneStackHeight(input.laneCount, eventHeight, eventGap));
+}
+function isTimelineMonthGranularityView(view) {
+  return view === "timelineMonth" || view === "resourceTimelineMonth";
+}
+function getTimelineVisibleDayStarts(view, start, end) {
+  const dates = [];
+  if (view === "timelineYear") return dates;
+  if (view === "timelineDay" || view === "resourceTimelineDay") {
+    dates.push(startOfDay(start));
+    return dates;
+  }
+  let current = startOfDay(start);
+  const stop = startOfDay(end);
+  const includeStopDay = end.getTime() > stop.getTime();
+  while (current < stop || includeStopDay && current.getTime() === stop.getTime()) {
+    dates.push(new Date(current));
+    current = addDays(current, 1);
+  }
+  return dates;
+}
+function getTimelineCalendarAdapter(view, calendar, locale) {
+  const mode = resolveSchedulerCalendarModeForView(calendar ?? "gregory", view);
+  return getSchedulerCalendarAdapter(mode, { locale });
+}
+function getCalendarMonthKey(date) {
+  return `${date.era ?? ""}:${date.year}:${date.month}`;
+}
+function buildTimelineCells(input) {
+  const result = [];
+  const { view, start, end, now, slotsPerDay, slotDurationMin, slotWidth, minTimeMin, dayWidth, timezone, labels } = input;
+  const calendarAdapter = getTimelineCalendarAdapter(view, input.calendar, input.locale);
+  const getDayState = (day) => {
+    if (timezone) {
+      const parts = getDatePartsInTimezone(day, timezone);
+      return {
+        isWeekend: parts.dayOfWeek === 0 || parts.dayOfWeek === 6,
+        isToday: isSameDayInTimezone(day, now, timezone)
+      };
+    }
+    const dow = day.getDay();
+    return {
+      isWeekend: dow === 0 || dow === 6,
+      isToday: isSameDay(day, now)
+    };
+  };
+  if (view === "timelineYear") {
+    const startCalendarDate = calendarAdapter.fromDate(start);
+    const yearStart = calendarAdapter.startOfMonth({ ...startCalendarDate, month: 1, day: 1 });
+    const monthsInYear = calendarAdapter.getMonthsInYear(startCalendarDate);
+    const nowCalendarDate = calendarAdapter.fromDate(now);
+    const monthCellWidth = Math.max(120, slotWidth);
+    for (let month = 0; month < monthsInYear; month++) {
+      const cellStartCalendarDate = calendarAdapter.add(yearStart, { months: month });
+      const cellEndCalendarDate = calendarAdapter.add(cellStartCalendarDate, { months: 1 });
+      const cellStart = calendarAdapter.toDate(cellStartCalendarDate);
+      const cellEnd = calendarAdapter.toDate(cellEndCalendarDate);
+      result.push({
+        startDate: cellStart,
+        endDate: cellEnd,
+        width: monthCellWidth,
+        label: labels.month(cellStart),
+        isToday: nowCalendarDate.year === cellStartCalendarDate.year && nowCalendarDate.month === cellStartCalendarDate.month,
+        isWeekend: false
+      });
+    }
+    return result;
+  }
+  if (isTimelineMonthGranularityView(view)) {
+    for (const day of getTimelineVisibleDayStarts(view, start, end)) {
+      const { isWeekend, isToday } = getDayState(day);
+      result.push({
+        startDate: startOfDay(day),
+        endDate: addDays(startOfDay(day), 1),
+        width: slotWidth,
+        label: labels.day(day),
+        isToday,
+        isWeekend
+      });
+    }
+    return result;
+  }
+  const pushSlotsForDay = (day) => {
+    const { isWeekend, isToday } = getDayState(day);
+    for (let slot = 0; slot < slotsPerDay; slot++) {
+      const slotStartMin = minTimeMin + slot * slotDurationMin;
+      const cellStart = new Date(day);
+      cellStart.setHours(0, 0, 0, 0);
+      cellStart.setMinutes(slotStartMin);
+      const cellEnd = new Date(cellStart);
+      cellEnd.setMinutes(cellEnd.getMinutes() + slotDurationMin);
+      result.push({
+        startDate: cellStart,
+        endDate: cellEnd,
+        width: slotWidth,
+        label: labels.hour(cellStart),
+        isToday,
+        isWeekend
+      });
+    }
+  };
+  const days = getTimelineVisibleDayStarts(view, start, end);
+  for (const day of days) {
+    pushSlotsForDay(day);
+  }
+  if (result.length === 0) {
+    const current = startOfDay(start);
+    const { isWeekend, isToday } = getDayState(current);
+    result.push({
+      startDate: new Date(current),
+      endDate: addDays(current, 1),
+      width: dayWidth,
+      label: labels.day(current),
+      isToday,
+      isWeekend
+    });
+  }
+  return result;
+}
+function buildTimelineHeaderTiers(input) {
+  const { view, cells, visibleDayStarts, dayWidth, labels } = input;
+  const calendarAdapter = getTimelineCalendarAdapter(view, input.calendar, input.locale);
+  if (cells.length === 0) return [];
+  const groupByDay = () => ({
+    cells: visibleDayStarts.map((day, index) => ({
+      label: labels.day(day),
+      width: dayWidth,
+      left: index * dayWidth,
+      startDate: new Date(day),
+      endDate: addDays(day, 1)
+    }))
+  });
+  const slotTier = () => {
+    let left = 0;
+    return {
+      cells: cells.map((cell) => {
+        const result = {
+          label: cell.label,
+          width: cell.width,
+          left,
+          startDate: cell.startDate,
+          endDate: cell.endDate
+        };
+        left += cell.width;
+        return result;
+      })
+    };
+  };
+  if (view === "timelineDay" || view === "resourceTimelineDay") {
+    return [slotTier()];
+  }
+  if (view === "timelineWeek" || view === "resourceTimelineWeek" || view === "timelineMonth" || view === "resourceTimelineMonth") {
+    const monthTier = { cells: [] };
+    const dayTier = groupByDay();
+    const hourTier = slotTier();
+    let currentMonthKey = "";
+    let monthWidth = 0;
+    let monthLeft = 0;
+    let timelineLeft = 0;
+    let monthAnchor = null;
+    for (const day of visibleDayStarts) {
+      const monthKey = getCalendarMonthKey(calendarAdapter.fromDate(day));
+      if (monthKey !== currentMonthKey) {
+        if (monthAnchor !== null) {
+          monthTier.cells.push({
+            label: labels.monthYear(monthAnchor),
+            width: monthWidth,
+            left: monthLeft,
+            startDate: monthAnchor,
+            endDate: day
+          });
+        }
+        currentMonthKey = monthKey;
+        monthWidth = 0;
+        monthLeft = timelineLeft;
+        monthAnchor = day;
+      }
+      monthWidth += dayWidth;
+      timelineLeft += dayWidth;
+    }
+    if (monthAnchor !== null) {
+      const lastDay = visibleDayStarts[visibleDayStarts.length - 1];
+      monthTier.cells.push({
+        label: labels.monthYear(monthAnchor),
+        width: monthWidth,
+        left: monthLeft,
+        startDate: monthAnchor,
+        endDate: addDays(lastDay, 1)
+      });
+    }
+    return isTimelineMonthGranularityView(view) ? [monthTier, dayTier] : [monthTier, dayTier, hourTier];
+  }
+  if (view === "timelineYear") {
+    const quarterTier = { cells: [] };
+    const monthTier = { cells: [] };
+    let quarterLeft = 0;
+    for (let quarter = 0; quarter < Math.ceil(cells.length / 3); quarter++) {
+      const quarterCells = cells.slice(quarter * 3, quarter * 3 + 3);
+      const quarterWidth = quarterCells.reduce((sum, cell) => sum + cell.width, 0);
+      if (quarterCells.length > 0) {
+        quarterTier.cells.push({
+          label: labels.quarter(quarter),
+          width: quarterWidth,
+          left: quarterLeft,
+          startDate: quarterCells[0].startDate,
+          endDate: quarterCells[quarterCells.length - 1].endDate
+        });
+      }
+      quarterLeft += quarterWidth;
+    }
+    let monthLeft = 0;
+    for (const cell of cells) {
+      monthTier.cells.push({
+        label: cell.label,
+        width: cell.width,
+        left: monthLeft,
+        startDate: cell.startDate,
+        endDate: cell.endDate
+      });
+      monthLeft += cell.width;
+    }
+    return [quarterTier, monthTier];
+  }
+  return [slotTier()];
+}
+function filterTimelineLaneEvents(events, input) {
+  const { resourceId, matchIds, viewStart, viewEnd } = input;
+  return events.filter((event) => {
+    if (resourceId !== void 0) {
+      if (matchIds) {
+        const primary = event.resourceId;
+        const secondary = event.resourceIds;
+        const primaryMatch = primary != null && matchIds.has(primary);
+        const secondaryMatch = secondary ? secondary.some((rid) => matchIds.has(rid)) : false;
+        if (!primaryMatch && !secondaryMatch) return false;
+      } else if (event.resourceId !== resourceId && !(event.resourceIds && event.resourceIds.includes(resourceId))) {
+        return false;
+      }
+    }
+    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 < viewEnd && eventEnd > viewStart;
+  });
+}
+function timeToTimelinePixels(input) {
+  const { date, view, cells, visibleDayStarts, dayWidth, minTimeMin, visibleMinutesPerDay, totalWidth } = input;
+  if (view === "timelineYear") {
+    const first = cells[0]?.startDate;
+    const last = cells[cells.length - 1]?.endDate;
+    if (!first || !last) return 0;
+    const total = last.getTime() - first.getTime();
+    const offset = date.getTime() - first.getTime();
+    return offset / total * totalWidth;
+  }
+  if (visibleDayStarts.length === 0) return 0;
+  if (isTimelineMonthGranularityView(view)) {
+    const firstDay2 = visibleDayStarts[0].getTime();
+    const targetDay = startOfDay(date).getTime();
+    const dayIndex = Math.floor((targetDay - firstDay2) / DAY_MS);
+    return Math.min(Math.max(dayIndex * dayWidth, 0), totalWidth);
+  }
+  const target = date.getTime();
+  const firstDay = visibleDayStarts[0].getTime();
+  const lastDay = visibleDayStarts[visibleDayStarts.length - 1].getTime();
+  if (target <= firstDay) return 0;
+  if (target >= lastDay + 24 * 36e5) return totalWidth;
+  for (let index = 0; index < visibleDayStarts.length; index++) {
+    const dayStart = visibleDayStarts[index].getTime();
+    const nextDayStart = dayStart + 24 * 36e5;
+    if (target < nextDayStart) {
+      const minutesIntoDay = (target - dayStart) / 6e4;
+      const clamped = Math.min(Math.max(minutesIntoDay, minTimeMin), minTimeMin + visibleMinutesPerDay);
+      const dayProgress = (clamped - minTimeMin) / visibleMinutesPerDay;
+      return index * dayWidth + dayProgress * dayWidth;
+    }
+  }
+  return totalWidth;
+}
+function getTimelineDayGranularityEventRect(event, input) {
+  const firstDay = input.visibleDayStarts[0];
+  if (!firstDay) {
+    return { left: 0, width: input.dayWidth };
+  }
+  const lastIndex = Math.max(0, input.visibleDayStarts.length - 1);
+  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 startDay = startOfDay(eventStart);
+  let endDay = startOfDay(eventEnd);
+  if (eventEnd.getTime() > eventStart.getTime() && eventEnd.getTime() === endDay.getTime()) {
+    endDay = addDays(endDay, -1);
+  }
+  const firstDayTime = firstDay.getTime();
+  const startIndex = Math.min(Math.max(Math.floor((startDay.getTime() - firstDayTime) / DAY_MS), 0), lastIndex);
+  const endIndex = Math.min(Math.max(Math.floor((endDay.getTime() - firstDayTime) / DAY_MS), startIndex), lastIndex);
+  return {
+    left: startIndex * input.dayWidth,
+    width: Math.max((endIndex - startIndex + 1) * input.dayWidth, input.dayWidth)
+  };
+}
+function getTimelineEventRect(event, input) {
+  if (isTimelineMonthGranularityView(input.view)) {
+    return getTimelineDayGranularityEventRect(event, input);
+  }
+  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) : new Date(eventStart.getTime() + input.fallbackDurationMinutes * 6e4);
+  const left = timeToTimelinePixels({ ...input, date: eventStart });
+  const right = timeToTimelinePixels({ ...input, date: eventEnd });
+  return {
+    left,
+    width: Math.max(right - left, 20)
+  };
+}
+function computeTimelineLaneAssignment(events, stackingMode) {
+  const sorted = [...events].sort((a, b) => {
+    const as = (a.start instanceof Date ? a.start : new Date(a.start)).getTime();
+    const bs = (b.start instanceof Date ? b.start : new Date(b.start)).getTime();
+    if (as !== bs) return as - bs;
+    const ae = a.end ? (a.end instanceof Date ? a.end : new Date(a.end)).getTime() : as;
+    const be = b.end ? (b.end instanceof Date ? b.end : new Date(b.end)).getTime() : bs;
+    return be - ae;
+  });
+  const assignment = /* @__PURE__ */ new Map();
+  if (stackingMode === "collapse") {
+    for (const event of sorted) {
+      if (event.id != null) assignment.set(event.id, 0);
+    }
+    return { assignment, laneCount: 1 };
+  }
+  if (stackingMode === "expand") {
+    let index = 0;
+    for (const event of sorted) {
+      if (event.id != null) assignment.set(event.id, index);
+      index++;
+    }
+    return { assignment, laneCount: Math.max(1, sorted.length) };
+  }
+  const lanes = [];
+  for (const event of sorted) {
+    const start = (event.start instanceof Date ? event.start : new Date(event.start)).getTime();
+    const end = event.end ? (event.end instanceof Date ? event.end : new Date(event.end)).getTime() : start;
+    let laneIndex = -1;
+    for (let index = 0; index < lanes.length; index++) {
+      const occupants = lanes[index];
+      const overlaps = occupants.some((occupant) => !(occupant.end <= start || occupant.start >= end));
+      if (!overlaps) {
+        laneIndex = index;
+        break;
+      }
+    }
+    if (laneIndex < 0) {
+      laneIndex = lanes.length;
+      lanes.push([]);
+    }
+    lanes[laneIndex].push({ start, end });
+    if (event.id != null) assignment.set(event.id, laneIndex);
+  }
+  return { assignment, laneCount: Math.max(1, lanes.length) };
+}
+
+// src/timeline/view-model.ts
+var TIMELINE_VIEWS_WITH_RESOURCES = /* @__PURE__ */ new Set(["timelineDay", "timelineWeek", "timelineMonth", "resourceTimelineDay", "resourceTimelineWeek", "resourceTimelineMonth"]);
+function getEffectiveViewStart(cells, fallback) {
+  return cells[0]?.startDate ?? fallback;
+}
+function getEffectiveViewEnd(cells, fallback) {
+  return cells[cells.length - 1]?.endDate ?? fallback;
+}
+function buildDescendantIdMap(resources) {
+  const map = /* @__PURE__ */ new Map();
+  const collect = (resource) => {
+    const ids = /* @__PURE__ */ new Set([resource.id]);
+    for (const child of resource.children ?? []) {
+      const childIds = collect(child);
+      childIds.forEach((id) => ids.add(id));
+    }
+    map.set(resource.id, ids);
+    return ids;
+  };
+  for (const resource of resources) {
+    collect(resource);
+  }
+  return map;
+}
+function buildVisibleHeaderTiers(input) {
+  const { headerTiers, visibleCells, virtualRange } = input;
+  if (!virtualRange) return headerTiers;
+  const visibleWidth = visibleCells.reduce((sum, cell) => sum + cell.width, 0);
+  const windowStart = virtualRange.startOffset;
+  const windowEnd = windowStart + visibleWidth;
+  return headerTiers.map((tier) => {
+    let offset = 0;
+    return {
+      cells: tier.cells.flatMap((cell) => {
+        const cellStart = Number.isFinite(cell.left) ? cell.left : offset;
+        const cellEnd = cellStart + cell.width;
+        offset = cellEnd;
+        if (cellEnd <= windowStart || cellStart >= windowEnd) {
+          return [];
+        }
+        return [
+          {
+            ...cell,
+            left: Math.max(cellStart, windowStart),
+            width: Math.max(0, Math.min(cellEnd, windowEnd) - Math.max(cellStart, windowStart))
+          }
+        ];
+      })
+    };
+  });
+}
+function eventIntersectsRange(event, viewStart, viewEnd) {
+  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 < viewEnd && eventEnd > viewStart;
+}
+function computeVisualLaneAssignment(events, getRect, stackingMode) {
+  if (stackingMode === "collapse" || stackingMode === "expand") {
+    return computeTimelineLaneAssignment(events, stackingMode);
+  }
+  const sorted = [...events].map((event) => ({ event, rect: getRect(event) })).sort((a, b) => {
+    if (a.rect.left !== b.rect.left) return a.rect.left - b.rect.left;
+    return b.rect.width - a.rect.width;
+  });
+  const assignment = /* @__PURE__ */ new Map();
+  const lanes = [];
+  for (const item of sorted) {
+    const start = item.rect.left;
+    const end = item.rect.left + item.rect.width;
+    let laneIndex = -1;
+    for (let index = 0; index < lanes.length; index++) {
+      const overlaps = lanes[index].some((occupant) => !(occupant.end <= start || occupant.start >= end));
+      if (!overlaps) {
+        laneIndex = index;
+        break;
+      }
+    }
+    if (laneIndex < 0) {
+      laneIndex = lanes.length;
+      lanes.push([]);
+    }
+    lanes[laneIndex].push({ start, end });
+    if (item.event.id != null) {
+      assignment.set(item.event.id, laneIndex);
+    }
+  }
+  return { assignment, laneCount: Math.max(1, lanes.length) };
+}
+function buildTimelineViewModel(input) {
+  const monthGranularity = isTimelineMonthGranularityView(input.view);
+  const slotsPerDay = monthGranularity ? 1 : Math.max(1, Math.ceil((input.maxTimeMin - input.minTimeMin) / input.slotDurationMin));
+  const slotWidth = Math.max(20, input.slotWidth);
+  const dayWidth = monthGranularity ? slotWidth : slotsPerDay * slotWidth;
+  const cells = buildTimelineCells({
+    view: input.view,
+    start: input.viewStart,
+    end: input.viewEnd,
+    now: input.now,
+    slotsPerDay,
+    slotDurationMin: input.slotDurationMin,
+    slotWidth,
+    minTimeMin: input.minTimeMin,
+    dayWidth,
+    timezone: input.timezone,
+    locale: input.locale,
+    calendar: input.calendar,
+    labels: input.labels
+  });
+  const visibleDayStarts = getTimelineVisibleDayStarts(input.view, input.viewStart, input.viewEnd);
+  const effectiveViewStart = getEffectiveViewStart(cells, input.viewStart);
+  const effectiveViewEnd = getEffectiveViewEnd(cells, input.viewEnd);
+  const totalWidth = cells.reduce((sum, cell) => sum + cell.width, 0);
+  const visibleMinutesPerDay = Math.max(1, input.maxTimeMin - input.minTimeMin);
+  const resources = TIMELINE_VIEWS_WITH_RESOURCES.has(input.view) ? input.resources ?? [] : [];
+  const visibleResources = resources.length > 0 ? input.visibleResources ?? [] : [];
+  const descendantIdMap = buildDescendantIdMap(resources);
+  const timelineEventMinHeight = resolveTimelineEventMinHeight(input.timelineEventMinHeight);
+  const rowAutoHeight = input.rowAutoHeight ?? input.view.startsWith("resourceTimeline");
+  const rowHeightMode = rowAutoHeight ? "auto" : "fixed";
+  const headerTiers = buildTimelineHeaderTiers({
+    view: input.view,
+    cells,
+    visibleDayStarts,
+    dayWidth,
+    labels: {
+      day: input.labels.day,
+      monthYear: input.labels.monthYear,
+      quarter: input.labels.quarter
+    },
+    locale: input.locale,
+    calendar: input.calendar
+  });
+  const positionInput = {
+    view: input.view,
+    cells,
+    visibleDayStarts,
+    dayWidth,
+    minTimeMin: input.minTimeMin,
+    visibleMinutesPerDay,
+    totalWidth
+  };
+  const getEventsForLane = (resourceId) => filterTimelineLaneEvents(input.events, {
+    resourceId,
+    matchIds: null,
+    viewStart: effectiveViewStart,
+    viewEnd: effectiveViewEnd
+  });
+  const isAggregatedRow = (resourceId) => {
+    if (resourceId === void 0 || !input.showAggregatedEvents) return false;
+    const descendants = descendantIdMap.get(resourceId);
+    if (!descendants || descendants.size <= 1) return false;
+    return !(input.isResourceExpanded?.(resourceId) ?? true);
+  };
+  const getAggregateEvents = (resourceId) => {
+    if (resourceId === void 0 || !isAggregatedRow(resourceId)) return [];
+    return filterTimelineLaneEvents(input.events, {
+      resourceId,
+      matchIds: descendantIdMap.get(resourceId) ?? /* @__PURE__ */ new Set([resourceId]),
+      viewStart: effectiveViewStart,
+      viewEnd: effectiveViewEnd
+    });
+  };
+  const getTimelineEventPosition = (event) => getTimelineEventRect(event, {
+    ...positionInput,
+    fallbackDurationMinutes: input.slotDurationMin
+  });
+  const laneModels = /* @__PURE__ */ new Map();
+  const laneResourceIds = visibleResources.length > 0 ? visibleResources.map((resource) => resource.id) : [void 0];
+  for (const resourceId of laneResourceIds) {
+    const events = getEventsForLane(resourceId);
+    const { assignment, laneCount } = monthGranularity ? computeVisualLaneAssignment(events, getTimelineEventPosition, input.stackingMode) : computeTimelineLaneAssignment(events, input.stackingMode);
+    const aggregateEvents = getAggregateEvents(resourceId);
+    laneModels.set(resourceId, {
+      resourceId,
+      events,
+      assignment,
+      laneCount,
+      aggregateEvents,
+      aggregateCount: aggregateEvents.length,
+      isAggregated: isAggregatedRow(resourceId)
+    });
+  }
+  const laneCounts = /* @__PURE__ */ new Map();
+  const expandedRowHeights = /* @__PURE__ */ new Map();
+  const baseRowHeight = resolveTimelineResourceRowHeight({
+    laneCount: 1,
+    eventHeight: timelineEventMinHeight,
+    minRowHeight: input.resourceRowHeight,
+    mode: rowHeightMode
+  });
+  for (const resource of visibleResources) {
+    const laneCount = laneModels.get(resource.id)?.laneCount ?? 1;
+    laneCounts.set(resource.id, laneCount);
+    expandedRowHeights.set(
+      resource.id,
+      resolveTimelineResourceRowHeight({
+        laneCount,
+        eventHeight: timelineEventMinHeight,
+        minRowHeight: input.resourceRowHeight,
+        mode: rowHeightMode
+      })
+    );
+  }
+  const resourceLayouts = visibleResources.length > 0 ? calculateResourceRowLayouts(visibleResources, baseRowHeight, expandedRowHeights, laneCounts) : [];
+  const totalResourceHeight = getTotalResourceHeight(resourceLayouts);
+  const virtualScrollCells = cells.map((cell, index) => ({
+    date: cell.startDate,
+    startTime: cell.startDate,
+    endTime: cell.endDate,
+    isToday: cell.isToday,
+    isWeekend: cell.isWeekend,
+    isBusinessHour: false,
+    width: cell.width,
+    index
+  }));
+  const virtualScrollEvents = input.events.filter((event) => eventIntersectsRange(event, input.viewStart, input.viewEnd)).map((event) => {
+    const rect = getTimelineEventPosition(event);
+    return {
+      left: rect.left,
+      width: rect.width,
+      row: 0,
+      event,
+      continuesBefore: false,
+      continuesAfter: false
+    };
+  });
+  const visibleCells = input.virtualRange ? cells.slice(input.virtualRange.startIndex, input.virtualRange.endIndex + 1) : cells;
+  const visibleHeaderTiers = buildVisibleHeaderTiers({
+    headerTiers,
+    visibleCells,
+    virtualRange: input.virtualRange
+  });
+  return {
+    cells,
+    visibleDayStarts,
+    effectiveViewStart,
+    effectiveViewEnd,
+    totalWidth,
+    visibleMinutesPerDay,
+    resources,
+    visibleResources,
+    headerTiers,
+    visibleCells,
+    visibleHeaderTiers,
+    laneModels,
+    resourceLayouts,
+    totalResourceHeight,
+    virtualScrollCells,
+    virtualScrollEvents,
+    getEventsForLane,
+    getAggregateEvents,
+    getAggregateCount: (resourceId) => getAggregateEvents(resourceId).length,
+    getEventLeft: (event) => getTimelineEventPosition(event).left,
+    getEventWidth: (event) => getTimelineEventPosition(event).width,
+    getEventLane: (event, resourceId) => {
+      const entry = laneModels.get(resourceId);
+      if (!entry || event.id == null) return 0;
+      return entry.assignment.get(event.id) ?? 0;
+    },
+    getLaneCount: (resourceId) => laneModels.get(resourceId)?.laneCount ?? 1,
+    isAggregatedRow,
+    timeToPixels: (date) => timeToTimelinePixels({ ...positionInput, date })
+  };
+}
+
+export { DEFAULT_TIMELINE_EVENT_MIN_HEIGHT, TIMELINE_LANE_BASE_PADDING, TIMELINE_LANE_GAP, buildTimelineCells, buildTimelineHeaderTiers, buildTimelineViewModel, computeTimelineLaneAssignment, filterTimelineLaneEvents, getTimelineEventRect, getTimelineLaneStackHeight, getTimelineVisibleDayStarts, isTimelineMonthGranularityView, resolveTimelineEventMinHeight, resolveTimelineResourceRowHeight, timeToTimelinePixels };