@primeui/scheduler-core 0.0.1-alpha.1 → 1.0.0-rc.1

package/dist/{chunk-KQGRXTP5.mjs → chunks/chunk-HF32DKZY.mjs}

@@ -1,7 +1,6 @@
-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';
+import { getDatePartsInTimezone, isSameDayInTimezone } from './chunk-P7CIUMQZ.mjs';
+import { startOfDay, addDays, isSameDay } from './chunk-XQAYO7CQ.mjs';
+import { resolveSchedulerCalendarModeForView, getSchedulerCalendarAdapter } from './chunk-6OTDPEJM.mjs';
 
 // src/timeline/layout.ts
 var DEFAULT_TIMELINE_EVENT_MIN_HEIGHT = 36;
@@ -301,6 +300,28 @@ function timeToTimelinePixels(input) {
   }
   return totalWidth;
 }
+function timelinePixelsToTime(input) {
+  const { x, view, visibleDayStarts, dayWidth, minTimeMin, visibleMinutesPerDay, totalWidth, snapDurationMin } = input;
+  const clampedX = Math.min(Math.max(x, 0), totalWidth);
+  if (visibleDayStarts.length === 0) {
+    return /* @__PURE__ */ new Date();
+  }
+  if (isTimelineMonthGranularityView(view)) {
+    const dayIndex2 = Math.min(Math.max(Math.round(clampedX / dayWidth), 0), visibleDayStarts.length - 1);
+    return new Date(visibleDayStarts[dayIndex2]);
+  }
+  const dayIndex = Math.min(Math.floor(clampedX / dayWidth), visibleDayStarts.length - 1);
+  const dayStart = new Date(visibleDayStarts[dayIndex]);
+  const offsetWithinDay = clampedX - dayIndex * dayWidth;
+  const dayProgress = dayWidth > 0 ? offsetWithinDay / dayWidth : 0;
+  let minutesIntoDay = minTimeMin + dayProgress * visibleMinutesPerDay;
+  if (snapDurationMin && snapDurationMin > 0) {
+    minutesIntoDay = minTimeMin + Math.round((minutesIntoDay - minTimeMin) / snapDurationMin) * snapDurationMin;
+  }
+  minutesIntoDay = Math.min(Math.max(minutesIntoDay, minTimeMin), minTimeMin + visibleMinutesPerDay);
+  dayStart.setHours(0, Math.round(minutesIntoDay), 0, 0);
+  return dayStart;
+}
 function getTimelineDayGranularityEventRect(event, input) {
   const firstDay = input.visibleDayStarts[0];
   if (!firstDay) {
@@ -382,269 +403,4 @@ function computeTimelineLaneAssignment(events, stackingMode) {
   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 };
+export { DEFAULT_TIMELINE_EVENT_MIN_HEIGHT, TIMELINE_LANE_BASE_PADDING, TIMELINE_LANE_GAP, buildTimelineCells, buildTimelineHeaderTiers, computeTimelineLaneAssignment, filterTimelineLaneEvents, getTimelineEventRect, getTimelineLaneStackHeight, getTimelineVisibleDayStarts, isTimelineMonthGranularityView, resolveTimelineEventMinHeight, resolveTimelineResourceRowHeight, timeToTimelinePixels, timelinePixelsToTime };

package/dist/chunks/chunk-HWGXSE6Q.mjs

@@ -0,0 +1,269 @@
+import { isTimelineMonthGranularityView, buildTimelineCells, getTimelineVisibleDayStarts, resolveTimelineEventMinHeight, buildTimelineHeaderTiers, computeTimelineLaneAssignment, resolveTimelineResourceRowHeight, timeToTimelinePixels, filterTimelineLaneEvents, getTimelineEventRect } from './chunk-HF32DKZY.mjs';
+import { calculateResourceRowLayouts, getTotalResourceHeight } from './chunk-XMU4WSAX.mjs';
+
+// 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 { buildTimelineViewModel };

package/dist/{chunk-HPC5B3AR.mjs → chunks/chunk-JCNXNPGM.mjs}

@@ -1,6 +1,6 @@
-import { parseRRule } from './chunk-FIBAZFC4.mjs';
-import { timeStringToMinutes } from './chunk-WFUJWDST.mjs';
-import { createSchedulerDateFormatter, formatTimeRange } from './chunk-TNKJPFGI.mjs';
+import { parseRRule } from './chunk-6Q5FR4PN.mjs';
+import { timeStringToMinutes } from './chunk-XQAYO7CQ.mjs';
+import { createSchedulerDateFormatter, formatTimeRange } from './chunk-F2LYNUXG.mjs';
 
 // src/utils/blocked-intervals.ts
 function parseDate(date) {

package/dist/{chunk-6OZAPQZ5.mjs → chunks/chunk-LMZ2J5Z5.mjs}

@@ -1,6 +1,6 @@
-import { getLocalTimezone, convertEventsToTimezone } from './chunk-QDMZBJDV.mjs';
-import { formatGregorianYear, formatGregorianMonthTitle, formatGregorianWeekday, formatGregorianDayNumber, toDateString } from './chunk-WFUJWDST.mjs';
-import { getSchedulerCalendarAdapter } from './chunk-DYW6WUHE.mjs';
+import { getLocalTimezone, convertEventsToTimezone } from './chunk-P7CIUMQZ.mjs';
+import { formatGregorianYear, formatGregorianMonthTitle, formatGregorianWeekday, formatGregorianDayNumber, toDateString } from './chunk-XQAYO7CQ.mjs';
+import { getSchedulerCalendarAdapter } from './chunk-6OTDPEJM.mjs';
 
 // src/year/view-model.ts
 function toDate(value) {

package/dist/{chunk-F5W5HD7S.mjs → chunks/chunk-LYPP7W7B.mjs}

@@ -1,10 +1,82 @@
-import { positionEventsForDay, getAllDayEventsForDay, positionAllDayEventsForWeek } from './chunk-6VYWVIGM.mjs';
-import { parseEvents, getTimedEventsForDayAndResource, eventMatchesResource } from './chunk-2B3YLWHA.mjs';
-import { getTimedBusinessHoursOverlays, getTimedBlockedIntervalsOverlays } from './chunk-AAVM7UCG.mjs';
-import { getAppointmentSlotIndicators, getAppointmentSlotOverlays } from './chunk-NZGJN7HG.mjs';
-import { getDatePartsInTimezone } from './chunk-QDMZBJDV.mjs';
-import { timeStringToMinutes, startOfDay, toDateString } from './chunk-WFUJWDST.mjs';
-import { resolveSchedulerCalendarModeForView, getSchedulerCalendarAdapter } from './chunk-DYW6WUHE.mjs';
+import { positionEventsForDay, getAllDayEventsForDay, positionAllDayEventsForWeek } from './chunk-QBTFRSZM.mjs';
+import { parseEvents, getTimedEventsForDayAndResource, eventMatchesResource } from './chunk-UKD2NVDC.mjs';
+import { getAppointmentSlotIndicators, getAppointmentSlotOverlays } from './chunk-RM6OQCEO.mjs';
+import { normalizeBusinessHours, getBlockedIntervalsForDay } from './chunk-JCNXNPGM.mjs';
+import { getDatePartsInTimezone } from './chunk-P7CIUMQZ.mjs';
+import { timeStringToMinutes, startOfDay, toDateString, minutesToPixels } from './chunk-XQAYO7CQ.mjs';
+import { resolveSchedulerCalendarModeForView, getSchedulerCalendarAdapter } from './chunk-6OTDPEJM.mjs';
+
+// src/utils/overlay.ts
+function getTimedBusinessHoursOverlays(date, businessHours, slotMinTime, slotMaxTime, slotDuration, slotHeight) {
+  const configs = normalizeBusinessHours(businessHours);
+  if (configs.length === 0) return [];
+  const dayOfWeek = date.getDay();
+  const config = configs.find((c) => c.daysOfWeek.includes(dayOfWeek));
+  const overlays = [];
+  const slotMinMinutes = timeStringToMinutes(slotMinTime);
+  const slotMaxMinutes = timeStringToMinutes(slotMaxTime);
+  const pushOverlay = (startMinutes, endMinutes) => {
+    const clampedStart = Math.max(startMinutes, slotMinMinutes);
+    const clampedEnd = Math.min(endMinutes, slotMaxMinutes);
+    if (clampedStart >= clampedEnd) return;
+    const top = minutesToPixels(clampedStart - slotMinMinutes, slotDuration, slotHeight);
+    const height = minutesToPixels(clampedEnd - clampedStart, slotDuration, slotHeight);
+    overlays.push({
+      position: "absolute",
+      top: top === 0 ? "0" : `${top}px`,
+      left: "0",
+      right: "0",
+      height: `${height}px`,
+      pointerEvents: "none",
+      zIndex: "0"
+    });
+  };
+  if (!config) {
+    pushOverlay(slotMinMinutes, slotMaxMinutes);
+    return overlays;
+  }
+  const businessStartMinutes = timeStringToMinutes(config.startTime);
+  const businessEndMinutes = timeStringToMinutes(config.endTime);
+  pushOverlay(slotMinMinutes, businessStartMinutes);
+  pushOverlay(businessEndMinutes, slotMaxMinutes);
+  return overlays;
+}
+function getTimedBlockedIntervalsOverlays(date, blockedIntervals, slotMinTime, slotMaxTime, slotDuration, slotHeight, resourceId) {
+  if (!blockedIntervals) return [];
+  const intervals = getBlockedIntervalsForDay(blockedIntervals, date, resourceId);
+  if (intervals.length === 0) return [];
+  const overlays = [];
+  const slotMinMinutes = timeStringToMinutes(slotMinTime);
+  const slotMaxMinutes = timeStringToMinutes(slotMaxTime);
+  for (const interval of intervals) {
+    const intervalStartMinutes = interval.start.getHours() * 60 + interval.start.getMinutes();
+    const intervalEndMinutes = interval.end.getHours() * 60 + interval.end.getMinutes();
+    const clampedStart = Math.max(intervalStartMinutes, slotMinMinutes);
+    const clampedEnd = Math.min(intervalEndMinutes, slotMaxMinutes);
+    if (clampedStart >= clampedEnd) continue;
+    const top = minutesToPixels(clampedStart - slotMinMinutes, slotDuration, slotHeight);
+    const height = minutesToPixels(clampedEnd - clampedStart, slotDuration, slotHeight);
+    const style = {
+      position: "absolute",
+      top: `${top}px`,
+      left: "0",
+      right: "0",
+      height: `${height}px`,
+      pointerEvents: "none",
+      zIndex: "2"
+    };
+    if (interval.background) {
+      style.background = interval.background;
+    }
+    overlays.push({
+      style,
+      title: interval.title,
+      className: interval.className,
+      interval
+    });
+  }
+  return overlays;
+}
 
 // src/time-grid/view-model.ts
 var RESOURCE_VIEWS = ["resourceDay", "resourceWeek"];