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

package/dist/{overlay-BYM9B6nC.d.mts → appointment-slots-DCiNFFed.d.mts}

@@ -1,4 +1,4 @@
-import { TimeFormatOptions, AppointmentSlot, AppointmentSlotStatus, AppointmentSlotDisplayMode, AppointmentSlotsOptions, SchedulerEvent, SchedulerResource, ExpandedBlockedInterval, BlockedIntervalsOptions, BusinessHours } from '@primeui/scheduler-types/scheduler';
+import { TimeFormatOptions, AppointmentSlot, AppointmentSlotStatus, AppointmentSlotDisplayMode, AppointmentSlotsOptions, SchedulerEvent, SchedulerResource } from '@primeui/scheduler-types/scheduler';
 import { S as SchedulerCalendarDisplayConfigInput } from './display-format-CLVvRt4I.mjs';
 
 declare const DEFAULT_APPOINTMENT_SLOTS_OPTIONS: AppointmentSlotsOptions;
@@ -50,15 +50,4 @@ declare function getAppointmentSlotIndicators(options: AppointmentSlotsOptions,
 declare function getSlotOverlayClasses(overlay: AppointmentSlotOverlay): string[];
 declare function getSlotOverlayStyle(overlay: AppointmentSlotOverlay): Record<string, string>;
 
-interface TimedOverlay {
-    style: Record<string, string>;
-    title?: string;
-    className?: string;
-    interval?: ExpandedBlockedInterval;
-}
-declare function getTimedBusinessHoursOverlays(date: Date, businessHours: BusinessHours, slotMinTime: string, slotMaxTime: string, slotDuration: number, slotHeight: number): Array<Record<string, string>>;
-declare function getTimedBlockedIntervalsOverlays(date: Date, blockedIntervals: BlockedIntervalsOptions | undefined, slotMinTime: string, slotMaxTime: string, slotDuration: number, slotHeight: number, resourceId?: string | number): TimedOverlay[];
-declare function isSlotInBusinessHours(slotTime: Date, date: Date, businessHours: BusinessHours | undefined): boolean;
-declare function isSlotInBlockedInterval(slotTime: Date, date: Date, slotDuration: number, blockedIntervals: BlockedIntervalsOptions | undefined, resourceId?: string | number): boolean;
-
-export { type AppointmentSlotDisplayLabels as A, DEFAULT_APPOINTMENT_SLOTS_OPTIONS as D, type TimedOverlay as T, type AppointmentSlotDisplayOptions as a, type AppointmentSlotIndicator as b, type AppointmentSlotOverlay as c, canBookSlot as d, createSlotFromTimeRange as e, getAppointmentSlotDisplayLabels as f, generateAppointmentSlots as g, getAppointmentSlotIndicators as h, getAppointmentSlotOverlays as i, getAvailableSlots as j, getSlotAtTime as k, getSlotById as l, getSlotCapacityDisplay as m, getSlotOverlayClasses as n, getSlotOverlayStyle as o, getSlotsForDay as p, getSlotsForTimeRange as q, getSlotsInTimeRange as r, getTimedBlockedIntervalsOverlays as s, getTimedBusinessHoursOverlays as t, isSlotInBlockedInterval as u, isSlotInBusinessHours as v, normalizeAppointmentSlotsOptions as w, updateSlotAvailability as x, updateSlotsAvailability as y };
+export { type AppointmentSlotDisplayLabels as A, DEFAULT_APPOINTMENT_SLOTS_OPTIONS as D, type AppointmentSlotDisplayOptions as a, type AppointmentSlotIndicator as b, type AppointmentSlotOverlay as c, canBookSlot as d, createSlotFromTimeRange as e, getAppointmentSlotDisplayLabels as f, generateAppointmentSlots as g, getAppointmentSlotIndicators as h, getAppointmentSlotOverlays as i, getAvailableSlots as j, getSlotAtTime as k, getSlotById as l, getSlotCapacityDisplay as m, getSlotOverlayClasses as n, getSlotOverlayStyle as o, getSlotsForDay as p, getSlotsForTimeRange as q, getSlotsInTimeRange as r, normalizeAppointmentSlotsOptions as s, updateSlotsAvailability as t, updateSlotAvailability as u };

package/dist/calendar/index.mjs

@@ -1 +1 @@
-export { addCalendarDaysToDate, differenceInCalendarDays, getSchedulerCalendarAdapter, gregorianCalendarAdapter, isCalendarAdapterCorrectView, moveDateToCalendarDay, resolveSchedulerCalendarId, resolveSchedulerCalendarModeForView, schedulerInternationalCalendarIds } from '../chunk-DYW6WUHE.mjs';
+export { addCalendarDaysToDate, differenceInCalendarDays, getSchedulerCalendarAdapter, gregorianCalendarAdapter, isCalendarAdapterCorrectView, moveDateToCalendarDay, resolveSchedulerCalendarId, resolveSchedulerCalendarModeForView, schedulerInternationalCalendarIds } from '../chunks/chunk-6OTDPEJM.mjs';

package/dist/{chunk-NMX4BW42.mjs → chunks/chunk-2YXHUV2A.mjs}

@@ -1,5 +1,5 @@
-import { isWeekend, isToday, addDays, addMonths, addHours, timeStringToMinutes, startOfDay, addWeeks, startOfWeek, getWeekdayNames, startOfMonth, endOfMonth, formatMonthYearTitle, addYears, getMonthNames } from './chunk-WFUJWDST.mjs';
-import { createSchedulerDateFormatter, formatSlotTime, formatTime } from './chunk-TNKJPFGI.mjs';
+import { isWeekend, isToday, addDays, addMonths, addHours, timeStringToMinutes, startOfDay, addWeeks, startOfWeek, getWeekdayNames, startOfMonth, endOfMonth, formatMonthYearTitle, addYears, getMonthNames } from './chunk-XQAYO7CQ.mjs';
+import { createSchedulerDateFormatter, formatSlotTime, formatTime } from './chunk-F2LYNUXG.mjs';
 
 // src/views/timeline/timeline.utils.ts
 function generateTimelineHeaderCells(startDate, endDate, levels, locale, timeFormat, timeZone, displayConfig) {

package/dist/{chunk-6PK5WSKT.mjs → chunks/chunk-56LJ2UG5.mjs}

@@ -1,6 +1,6 @@
-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';
+import { getLocalTimezone, convertEventsToTimezone } from './chunk-P7CIUMQZ.mjs';
+import { startOfDay, isSameDay, addDays, toDateString, formatGregorianMonthTitle, getWeekNumber, formatGregorianDayNumber } from './chunk-XQAYO7CQ.mjs';
+import { getSchedulerCalendarAdapter } from './chunk-6OTDPEJM.mjs';
 
 // src/month/layout.ts
 function daysBetween(a, b) {

package/dist/{chunk-FIBAZFC4.mjs → chunks/chunk-6Q5FR4PN.mjs}

@@ -1,4 +1,4 @@
-import { createSchedulerDateFormatter } from './chunk-TNKJPFGI.mjs';
+import { createSchedulerDateFormatter } from './chunk-F2LYNUXG.mjs';
 
 // src/event/recurrence.ts
 var WEEKDAY_MAP = {

package/dist/{chunk-NX46LPLF.mjs → chunks/chunk-BJFVXDZC.mjs}

@@ -1,5 +1,5 @@
-import { isRangeWithinBusinessHours } from './chunk-HPC5B3AR.mjs';
-import { addDays, isSameDay, startOfDay } from './chunk-WFUJWDST.mjs';
+import { isRangeWithinBusinessHours } from './chunk-JCNXNPGM.mjs';
+import { addDays, isSameDay, startOfDay } from './chunk-XQAYO7CQ.mjs';
 
 // src/utils/resource-constraints.ts
 var DEFAULT_CONFLICT_OPTIONS = {

package/dist/{chunk-ZUKUKGNK.mjs → chunks/chunk-DIYUG3BH.mjs}

@@ -1,10 +1,10 @@
-import { buildMonthGridViewModel } from './chunk-6PK5WSKT.mjs';
-import { buildYearGridViewModel } from './chunk-6OZAPQZ5.mjs';
-import { timelineMonthView, timelineWeekView, timelineDayView, timelineYearView } from './chunk-NMX4BW42.mjs';
-import { getDatePartsInTimezone } from './chunk-QDMZBJDV.mjs';
-import { startOfDay, addDays, isToday, formatWeekdayName, toDateString, isSameDay, addWeeks, startOfWeek, formatMonthYearTitle, isWeekend, getWeekdayNames, timeStringToMinutes, addMonths, addYears, formatGregorianYear, formatGregorianMonthTitle } from './chunk-WFUJWDST.mjs';
-import { createSchedulerDateFormatter, formatTimeRange, formatTime, formatSlotTime } from './chunk-TNKJPFGI.mjs';
-import { getSchedulerCalendarAdapter } from './chunk-DYW6WUHE.mjs';
+import { buildMonthGridViewModel } from './chunk-56LJ2UG5.mjs';
+import { buildYearGridViewModel } from './chunk-LMZ2J5Z5.mjs';
+import { timelineMonthView, timelineWeekView, timelineDayView, timelineYearView } from './chunk-2YXHUV2A.mjs';
+import { getDatePartsInTimezone } from './chunk-P7CIUMQZ.mjs';
+import { startOfDay, addDays, isToday, formatWeekdayName, toDateString, isSameDay, addWeeks, startOfWeek, formatMonthYearTitle, isWeekend, getWeekdayNames, timeStringToMinutes, addMonths, addYears, formatGregorianYear, formatGregorianMonthTitle } from './chunk-XQAYO7CQ.mjs';
+import { createSchedulerDateFormatter, formatTimeRange, formatTime, formatSlotTime } from './chunk-F2LYNUXG.mjs';
+import { getSchedulerCalendarAdapter } from './chunk-6OTDPEJM.mjs';
 
 // src/views/agenda.view.ts
 var agendaView = {

package/dist/{chunk-TNKJPFGI.mjs → chunks/chunk-F2LYNUXG.mjs}

@@ -1,4 +1,4 @@
-import { resolveSchedulerCalendarModeForView, getSchedulerCalendarAdapter } from './chunk-DYW6WUHE.mjs';
+import { resolveSchedulerCalendarModeForView, getSchedulerCalendarAdapter } from './chunk-6OTDPEJM.mjs';
 
 // src/utils/display-format.ts
 var DEFAULT_TIME_FORMAT_OPTIONS = {

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 };