@primeui/scheduler-core 0.0.1-alpha.1

package/dist/chunk-NMX4BW42.mjs

@@ -0,0 +1,672 @@
+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';
+
+// src/views/timeline/timeline.utils.ts
+function generateTimelineHeaderCells(startDate, endDate, levels, locale, timeFormat, timeZone, displayConfig) {
+  const result = [];
+  for (const level of levels) {
+    const cells = generateHeaderCellsForLevel(startDate, endDate, level, locale, timeFormat, timeZone, displayConfig);
+    result.push(cells);
+  }
+  return result;
+}
+function generateHeaderCellsForLevel(startDate, endDate, level, locale, timeFormat, timeZone, displayConfig) {
+  const cells = [];
+  let current = new Date(startDate);
+  while (current < endDate) {
+    const { label, nextDate, colspan } = getHeaderCellData(current, endDate, level, locale, timeFormat, timeZone, displayConfig);
+    cells.push({
+      date: new Date(current),
+      label,
+      colspan,
+      unit: level.unit,
+      isToday: level.unit === "day" && isToday(current),
+      isWeekend: level.unit === "day" && isWeekend(current)
+    });
+    current = nextDate;
+  }
+  return cells;
+}
+function getHeaderCellData(date, endDate, level, locale, timeFormat, timeZone, displayConfig) {
+  const formatter = createSchedulerDateFormatter({ ...displayConfig, locale, timeZone });
+  const label = resolveHeaderCellLabel(date, level, formatter, locale, timeFormat, timeZone);
+  let nextDate;
+  let colspan = 1;
+  switch (level.unit) {
+    case "hour":
+      nextDate = addHours(date, 1);
+      break;
+    case "day":
+      nextDate = addDays(date, 1);
+      break;
+    case "week":
+      nextDate = addDays(date, 7);
+      colspan = 7;
+      break;
+    case "month":
+      nextDate = addMonths(date, 1);
+      colspan = getDaysInMonthRange(date, endDate);
+      break;
+    case "quarter":
+      nextDate = addMonths(date, 3);
+      colspan = 3;
+      break;
+    case "year":
+      nextDate = new Date(date.getFullYear() + 1, 0, 1);
+      colspan = 12;
+      break;
+    default:
+      nextDate = addDays(date, 1);
+  }
+  if (nextDate > endDate) {
+    nextDate = endDate;
+  }
+  return { label, nextDate, colspan };
+}
+function resolveHeaderCellLabel(date, level, formatter, locale, timeFormat, timeZone) {
+  if (level.unit === "hour" && !level.format) {
+    return formatSlotTime(date, locale, timeFormat, timeZone);
+  }
+  if (level.unit === "day" && !level.format) {
+    return formatter.formatWeekdayDayNumber(date);
+  }
+  return formatter.format(date, getFormatOptionsForUnit(level.unit, level.format));
+}
+function getFormatOptionsForUnit(unit, customFormat) {
+  if (customFormat) {
+    return {};
+  }
+  switch (unit) {
+    case "hour":
+      return { hour: "numeric", minute: "2-digit" };
+    case "day":
+      return { weekday: "short", day: "numeric" };
+    case "week":
+      return { month: "short", day: "numeric" };
+    case "month":
+      return { month: "long" };
+    case "quarter":
+      return { month: "short" };
+    case "year":
+      return { year: "numeric" };
+    default:
+      return {};
+  }
+}
+function getDaysInMonthRange(monthStart, endDate) {
+  const nextMonth = addMonths(monthStart, 1);
+  const monthEnd = nextMonth < endDate ? nextMonth : endDate;
+  const diffTime = monthEnd.getTime() - monthStart.getTime();
+  return Math.ceil(diffTime / (1e3 * 60 * 60 * 24));
+}
+function generateTimelineCells(startDate, endDate, options) {
+  const cells = [];
+  const { timelineSlotDuration, timelineSlotWidth, timelineMinTime, timelineMaxTime } = options;
+  const minMinutes = timeStringToMinutes(timelineMinTime);
+  const maxMinutes = timeStringToMinutes(timelineMaxTime);
+  const slotsPerDay = Math.ceil((maxMinutes - minMinutes) / timelineSlotDuration);
+  let current = startOfDay(startDate);
+  let index = 0;
+  while (current < endDate) {
+    for (let slot = 0; slot < slotsPerDay; slot++) {
+      const slotMinutes = minMinutes + slot * timelineSlotDuration;
+      const hours = Math.floor(slotMinutes / 60);
+      const minutes = slotMinutes % 60;
+      const slotStart = new Date(current);
+      slotStart.setHours(hours, minutes, 0, 0);
+      const slotEnd = new Date(slotStart);
+      slotEnd.setMinutes(slotEnd.getMinutes() + timelineSlotDuration);
+      cells.push({
+        date: new Date(current),
+        startTime: slotStart,
+        endTime: slotEnd,
+        isToday: isToday(current),
+        isWeekend: isWeekend(current),
+        isBusinessHour: isWithinBusinessHours(slotStart),
+        width: timelineSlotWidth,
+        index
+      });
+      index++;
+    }
+    current = addDays(current, 1);
+  }
+  return cells;
+}
+function generateDayCells(startDate, endDate, cellWidth) {
+  const cells = [];
+  let current = startOfDay(startDate);
+  let index = 0;
+  while (current < endDate) {
+    const dayEnd = addDays(current, 1);
+    cells.push({
+      date: new Date(current),
+      startTime: new Date(current),
+      endTime: dayEnd,
+      isToday: isToday(current),
+      isWeekend: isWeekend(current),
+      isBusinessHour: !isWeekend(current),
+      width: cellWidth,
+      index
+    });
+    current = dayEnd;
+    index++;
+  }
+  return cells;
+}
+function calculateTimelineEventPosition(event, viewStart, viewEnd, totalWidth, totalDuration) {
+  const eventStart = typeof event.start === "string" ? new Date(event.start) : event.start;
+  const eventEnd = event.end ? typeof event.end === "string" ? new Date(event.end) : event.end : addHours(eventStart, 1);
+  if (eventEnd <= viewStart || eventStart >= viewEnd) {
+    return null;
+  }
+  const clampedStart = eventStart < viewStart ? viewStart : eventStart;
+  const clampedEnd = eventEnd > viewEnd ? viewEnd : eventEnd;
+  const startOffset = clampedStart.getTime() - viewStart.getTime();
+  const eventDuration = clampedEnd.getTime() - clampedStart.getTime();
+  const left = startOffset / totalDuration * totalWidth;
+  const width = eventDuration / totalDuration * totalWidth;
+  return {
+    left,
+    width: Math.max(width, 20),
+    row: 0,
+    event,
+    continuesBefore: eventStart < viewStart,
+    continuesAfter: eventEnd > viewEnd
+  };
+}
+function positionTimelineEvents(events, viewStart, viewEnd, totalWidth) {
+  const totalDuration = viewEnd.getTime() - viewStart.getTime();
+  const positions = [];
+  for (const event of events) {
+    const position = calculateTimelineEventPosition(event, viewStart, viewEnd, totalWidth, totalDuration);
+    if (position) {
+      positions.push(position);
+    }
+  }
+  return assignEventRows(positions);
+}
+function positionTimelineEventsWithBusinessHours(events, viewStart, viewEnd, totalWidth, minTimeMinutes, maxTimeMinutes) {
+  const businessMinutesPerDay = maxTimeMinutes - minTimeMinutes;
+  const msPerBusinessDay = businessMinutesPerDay * 60 * 1e3;
+  const dayCount = Math.ceil((viewEnd.getTime() - viewStart.getTime()) / (24 * 60 * 60 * 1e3));
+  const totalBusinessMs = dayCount * msPerBusinessDay;
+  const positions = [];
+  for (const event of events) {
+    const eventStart = typeof event.start === "string" ? new Date(event.start) : event.start;
+    const eventEnd = event.end ? typeof event.end === "string" ? new Date(event.end) : event.end : addHours(eventStart, 1);
+    if (eventEnd <= viewStart || eventStart >= viewEnd) {
+      continue;
+    }
+    const startBusinessOffset = calculateBusinessTimeOffset(eventStart, viewStart, minTimeMinutes, maxTimeMinutes, msPerBusinessDay);
+    const endBusinessOffset = calculateBusinessTimeOffset(eventEnd, viewStart, minTimeMinutes, maxTimeMinutes, msPerBusinessDay);
+    const clampedStartOffset = Math.max(0, startBusinessOffset);
+    const clampedEndOffset = Math.min(totalBusinessMs, endBusinessOffset);
+    if (clampedEndOffset <= clampedStartOffset) {
+      continue;
+    }
+    const left = clampedStartOffset / totalBusinessMs * totalWidth;
+    const width = (clampedEndOffset - clampedStartOffset) / totalBusinessMs * totalWidth;
+    positions.push({
+      left,
+      width: Math.max(width, 20),
+      row: 0,
+      event,
+      continuesBefore: eventStart < viewStart,
+      continuesAfter: eventEnd > viewEnd
+    });
+  }
+  return assignEventRows(positions);
+}
+function calculateBusinessTimeOffset(datetime, viewStart, minTimeMinutes, maxTimeMinutes, msPerBusinessDay) {
+  const viewStartDay = startOfDay(viewStart);
+  const targetDay = startOfDay(datetime);
+  const daysDiff = Math.floor((targetDay.getTime() - viewStartDay.getTime()) / (24 * 60 * 60 * 1e3));
+  const fullDaysOffset = daysDiff * msPerBusinessDay;
+  const timeMinutes = datetime.getHours() * 60 + datetime.getMinutes();
+  const clampedMinutes = Math.max(minTimeMinutes, Math.min(maxTimeMinutes, timeMinutes));
+  const minutesIntoBusinessDay = clampedMinutes - minTimeMinutes;
+  return fullDaysOffset + minutesIntoBusinessDay * 60 * 1e3;
+}
+function positionTimelineEventsForDayGranularity(events, viewStart, viewEnd, cellWidth) {
+  const positions = [];
+  const msPerDay = 24 * 60 * 60 * 1e3;
+  const viewStartTime = startOfDay(viewStart).getTime();
+  for (const event of events) {
+    const eventStart = typeof event.start === "string" ? new Date(event.start) : event.start;
+    const eventEnd = event.end ? typeof event.end === "string" ? new Date(event.end) : event.end : eventStart;
+    if (eventEnd <= viewStart || eventStart >= viewEnd) {
+      continue;
+    }
+    const eventStartDay = startOfDay(eventStart);
+    const eventEndDay = startOfDay(eventEnd);
+    const clampedStartDay = eventStartDay < viewStart ? startOfDay(viewStart) : eventStartDay;
+    const clampedEndDay = eventEndDay >= viewEnd ? startOfDay(addDays(viewEnd, -1)) : eventEndDay;
+    const startDayIndex = Math.floor((clampedStartDay.getTime() - viewStartTime) / msPerDay);
+    const endDayIndex = Math.floor((clampedEndDay.getTime() - viewStartTime) / msPerDay);
+    const left = startDayIndex * cellWidth;
+    const width = (endDayIndex - startDayIndex + 1) * cellWidth;
+    positions.push({
+      left,
+      width: Math.max(width, cellWidth),
+      row: 0,
+      event,
+      continuesBefore: eventStart < viewStart,
+      continuesAfter: eventEnd > viewEnd,
+      // Store day indices for overlap detection in day-granularity views
+      _startDayIndex: startDayIndex,
+      _endDayIndex: endDayIndex
+    });
+  }
+  return assignEventRowsForDayGranularity(positions);
+}
+function assignEventRowsForDayGranularity(positions) {
+  if (positions.length === 0) return positions;
+  const sortedPositions = [...positions].sort((a, b) => {
+    const aStart = a._startDayIndex;
+    const bStart = b._startDayIndex;
+    const aEnd = a._endDayIndex;
+    const bEnd = b._endDayIndex;
+    if (aStart !== bStart) {
+      return aStart - bStart;
+    }
+    const aSpan = aEnd - aStart;
+    const bSpan = bEnd - bStart;
+    if (aSpan !== bSpan) {
+      return bSpan - aSpan;
+    }
+    return String(a.event.id).localeCompare(String(b.event.id));
+  });
+  const rows = [];
+  for (const pos of sortedPositions) {
+    const startDay = pos._startDayIndex;
+    const endDay = pos._endDayIndex;
+    let assignedRow = -1;
+    for (let rowIdx = 0; rowIdx < rows.length; rowIdx++) {
+      const rowRanges = rows[rowIdx];
+      let hasOverlap = false;
+      for (const [existingStart, existingEnd] of rowRanges) {
+        if (startDay <= existingEnd && endDay >= existingStart) {
+          hasOverlap = true;
+          break;
+        }
+      }
+      if (!hasOverlap) {
+        assignedRow = rowIdx;
+        rowRanges.push([startDay, endDay]);
+        break;
+      }
+    }
+    if (assignedRow === -1) {
+      assignedRow = rows.length;
+      rows.push([[startDay, endDay]]);
+    }
+    pos.row = assignedRow;
+  }
+  return sortedPositions;
+}
+function getEventTimeRange(event) {
+  const eventStart = typeof event.start === "string" ? new Date(event.start) : event.start;
+  const eventEnd = event.end ? typeof event.end === "string" ? new Date(event.end) : event.end : new Date(eventStart.getTime() + 60 * 60 * 1e3);
+  return {
+    start: eventStart.getTime(),
+    end: eventEnd.getTime()
+  };
+}
+function timeRangesOverlap(a, b) {
+  return a.start < b.end && a.end > b.start;
+}
+function assignEventRows(positions) {
+  if (positions.length === 0) return positions;
+  const eventTimes = /* @__PURE__ */ new Map();
+  for (const pos of positions) {
+    eventTimes.set(pos.event.id, getEventTimeRange(pos.event));
+  }
+  const sortedPositions = [...positions].sort((a, b) => {
+    const aTime = eventTimes.get(a.event.id);
+    const bTime = eventTimes.get(b.event.id);
+    if (aTime.start !== bTime.start) {
+      return aTime.start - bTime.start;
+    }
+    const aDuration = aTime.end - aTime.start;
+    const bDuration = bTime.end - bTime.start;
+    if (aDuration !== bDuration) {
+      return bDuration - aDuration;
+    }
+    return String(a.event.id).localeCompare(String(b.event.id));
+  });
+  const rows = [];
+  for (const pos of sortedPositions) {
+    const eventTime = eventTimes.get(pos.event.id);
+    let assignedRow = -1;
+    for (let rowIdx = 0; rowIdx < rows.length; rowIdx++) {
+      const rowEvents = rows[rowIdx];
+      let hasOverlap = false;
+      for (const existingEvent of rowEvents) {
+        if (timeRangesOverlap(eventTime, existingEvent)) {
+          hasOverlap = true;
+          break;
+        }
+      }
+      if (!hasOverlap) {
+        assignedRow = rowIdx;
+        rowEvents.push(eventTime);
+        break;
+      }
+    }
+    if (assignedRow === -1) {
+      assignedRow = rows.length;
+      rows.push([eventTime]);
+    }
+    pos.row = assignedRow;
+  }
+  return sortedPositions;
+}
+function getEventsInDateRange(events, startDate, endDate) {
+  return events.filter((event) => {
+    const eventStart = typeof event.start === "string" ? new Date(event.start) : event.start;
+    const eventEnd = event.end ? typeof event.end === "string" ? new Date(event.end) : event.end : eventStart;
+    return eventStart < endDate && eventEnd > startDate;
+  });
+}
+function getDefaultTimelineHeaderLevels(viewType) {
+  switch (viewType) {
+    case "timelineDay":
+      return [{ unit: "hour", height: 40 }];
+    case "timelineWeek":
+      return [
+        { unit: "day", height: 30 },
+        { unit: "hour", height: 30 }
+      ];
+    case "timelineMonth":
+      return [
+        { unit: "week", height: 30 },
+        { unit: "day", height: 30 }
+      ];
+    case "timelineYear":
+      return [{ unit: "month", height: 40 }];
+    default:
+      return [{ unit: "day", height: 40 }];
+  }
+}
+function isWithinBusinessHours(date) {
+  const day = date.getDay();
+  const isWeekday = day >= 1 && day <= 5;
+  const hour = date.getHours();
+  const isBusinessHour = hour >= 9 && hour < 17;
+  return isWeekday && isBusinessHour;
+}
+function formatTimelineTitle(startDate, endDate, viewType, locale, displayConfig) {
+  const formatter = createSchedulerDateFormatter({ ...displayConfig, locale });
+  switch (viewType) {
+    case "timelineDay":
+      return formatter.format(startDate, { weekday: "long", month: "long", day: "numeric", year: "numeric" });
+    case "timelineWeek": {
+      const weekStart = formatter.format(startDate, { month: "short", day: "numeric" });
+      const weekEnd = formatter.format(endDate, { month: "short", day: "numeric", year: "numeric" });
+      return `${weekStart} - ${weekEnd}`;
+    }
+    case "timelineMonth":
+      return formatter.formatMonthTitle(startDate);
+    case "timelineYear":
+      return formatter.formatYear(startDate);
+    default:
+      return formatter.formatMonthTitle(startDate);
+  }
+}
+
+// src/views/timeline/timeline-day.view.ts
+var timelineDayView = {
+  name: "timelineDay",
+  getTitle(date, locale) {
+    return formatTimelineTitle(date, addDays(date, 1), "timelineDay", locale);
+  },
+  getDateRange(date) {
+    const dayStart = startOfDay(date);
+    const dayEnd = addDays(dayStart, 1);
+    return { start: dayStart, end: dayEnd };
+  },
+  navigate(date, direction) {
+    return addDays(date, direction);
+  },
+  navigateToDate(target) {
+    return startOfDay(target);
+  }
+};
+function getTimelineDayViewData(date, options) {
+  const { locale, events, timelineSlotDuration, timelineSlotWidth, timelineMinTime, timelineMaxTime, timelineHeaderLevels, calendar, numberingSystem } = options;
+  const displayConfig = { calendar, numberingSystem };
+  const dayStart = startOfDay(date);
+  const dayEnd = addDays(dayStart, 1);
+  const minMinutes = timeStringToMinutes(timelineMinTime);
+  const maxMinutes = timeStringToMinutes(timelineMaxTime);
+  const totalMinutes = maxMinutes - minMinutes;
+  const slotsCount = Math.ceil(totalMinutes / timelineSlotDuration);
+  const totalWidth = slotsCount * timelineSlotWidth;
+  const visibleStart = new Date(dayStart);
+  visibleStart.setHours(Math.floor(minMinutes / 60), minMinutes % 60, 0, 0);
+  const visibleEnd = new Date(dayStart);
+  visibleEnd.setHours(Math.floor(maxMinutes / 60), maxMinutes % 60, 0, 0);
+  const headerLevels = timelineHeaderLevels || getDefaultTimelineHeaderLevels("timelineDay");
+  const headerCells = generateTimelineHeaderCells(dayStart, dayEnd, headerLevels, locale, options.timeFormat, options.timezone, displayConfig);
+  const cells = generateTimelineCells(dayStart, dayEnd, options);
+  const dayEvents = getEventsInDateRange(events, dayStart, dayEnd);
+  const eventPositions = positionTimelineEventsWithBusinessHours(dayEvents, dayStart, dayEnd, totalWidth, minMinutes, maxMinutes);
+  return {
+    date: dayStart,
+    title: formatTimelineTitle(dayStart, dayEnd, "timelineDay", locale, displayConfig),
+    headerLevels: headerCells,
+    cells,
+    timeSlots: [],
+    events: eventPositions,
+    totalWidth,
+    dateRange: { start: visibleStart, end: visibleEnd }
+  };
+}
+
+// src/views/timeline/timeline-week.view.ts
+var timelineWeekView = {
+  name: "timelineWeek",
+  getTitle(date, locale) {
+    const weekStart = startOfWeek(date, 0);
+    const weekEnd = addDays(weekStart, 6);
+    return formatTimelineTitle(weekStart, weekEnd, "timelineWeek", locale);
+  },
+  getDateRange(date, options) {
+    const weekStart = startOfWeek(date, options.firstDayOfWeek);
+    const weekEnd = addDays(weekStart, 7);
+    return { start: weekStart, end: weekEnd };
+  },
+  navigate(date, direction) {
+    return addWeeks(date, direction);
+  },
+  navigateToDate(target) {
+    return new Date(target);
+  }
+};
+function getTimelineWeekViewData(date, options) {
+  const { locale, firstDayOfWeek, events, timelineSlotDuration, timelineSlotWidth, timelineMinTime, timelineMaxTime, timelineHeaderLevels, daysOfWeek, numberOfDays, calendar, numberingSystem } = options;
+  const displayConfig = { calendar, numberingSystem };
+  const totalDaysToCheck = numberOfDays ?? 7;
+  const startDate = numberOfDays ? date : startOfWeek(date, firstDayOfWeek);
+  const activeDays = daysOfWeek ?? [0, 1, 2, 3, 4, 5, 6];
+  const minMinutes = timeStringToMinutes(timelineMinTime);
+  const maxMinutes = timeStringToMinutes(timelineMaxTime);
+  const totalMinutes = maxMinutes - minMinutes;
+  const slotsPerDay = Math.ceil(totalMinutes / timelineSlotDuration);
+  const days = generateDayColumns(startDate, slotsPerDay, timelineSlotWidth, locale, activeDays, totalDaysToCheck, displayConfig);
+  const numDays = days.length;
+  const totalWidth = slotsPerDay * timelineSlotWidth * numDays;
+  const visibleDates = days.map((d) => d.date);
+  const actualStartDate = visibleDates[0] || startDate;
+  const actualEndDate = visibleDates.length > 0 ? addDays(visibleDates[visibleDates.length - 1], 1) : addDays(startDate, totalDaysToCheck);
+  const headerLevels = timelineHeaderLevels || getDefaultTimelineHeaderLevels("timelineWeek");
+  const headerCells = generateTimelineHeaderCells(actualStartDate, actualEndDate, headerLevels, locale, options.timeFormat, options.timezone, displayConfig);
+  const cells = generateTimelineCells(actualStartDate, actualEndDate, options);
+  const weekEvents = getEventsInDateRange(events, actualStartDate, actualEndDate).filter((event) => {
+    const eventStart = typeof event.start === "string" ? new Date(event.start) : event.start;
+    return activeDays.includes(eventStart.getDay());
+  });
+  const eventPositions = positionTimelineEventsWithBusinessHours(weekEvents, actualStartDate, actualEndDate, totalWidth, minMinutes, maxMinutes);
+  return {
+    startDate: actualStartDate,
+    endDate: actualEndDate,
+    title: formatTimelineTitle(actualStartDate, visibleDates[visibleDates.length - 1] || startDate, "timelineWeek", locale, displayConfig),
+    headerLevels: headerCells,
+    cells,
+    days,
+    events: eventPositions,
+    totalWidth,
+    dateRange: { start: actualStartDate, end: actualEndDate }
+  };
+}
+function generateDayColumns(startDate, slotsPerDay, slotWidth, locale, daysOfWeek, totalDays = 7, displayConfig) {
+  const columns = [];
+  const dayNames = getWeekdayNames(locale, "short", 0, displayConfig);
+  const dayWidth = slotsPerDay * slotWidth;
+  const activeDays = daysOfWeek ?? [0, 1, 2, 3, 4, 5, 6];
+  let columnIndex = 0;
+  for (let i = 0; i < totalDays; i++) {
+    const dayDate = addDays(startDate, i);
+    const dayOfWeek = dayDate.getDay();
+    if (!activeDays.includes(dayOfWeek)) continue;
+    columns.push({
+      date: dayDate,
+      dayName: dayNames[dayOfWeek],
+      dayNumber: dayDate.getDate(),
+      isToday: isToday(dayDate),
+      isWeekend: isWeekend(dayDate),
+      startIndex: columnIndex * slotsPerDay,
+      endIndex: (columnIndex + 1) * slotsPerDay - 1,
+      width: dayWidth
+    });
+    columnIndex++;
+  }
+  return columns;
+}
+
+// src/views/timeline/timeline-month.view.ts
+var timelineMonthView = {
+  name: "timelineMonth",
+  getTitle(date, locale) {
+    return formatMonthYearTitle(date, locale);
+  },
+  getDateRange(date) {
+    const monthStart = startOfMonth(date);
+    const monthEnd = endOfMonth(date);
+    return { start: monthStart, end: addDays(monthEnd, 1) };
+  },
+  navigate(date, direction) {
+    return addMonths(date, direction);
+  },
+  navigateToDate(target) {
+    return startOfMonth(target);
+  }
+};
+function getTimelineMonthViewData(date, options) {
+  const { locale, events, timelineHeaderLevels, timelineSlotWidth = 60, calendar, numberingSystem } = options;
+  const displayConfig = { calendar, numberingSystem };
+  const cellWidth = timelineSlotWidth;
+  const monthStart = startOfMonth(date);
+  const monthEnd = endOfMonth(date);
+  const monthEndPlusOne = addDays(monthEnd, 1);
+  const daysInMonth = monthEnd.getDate();
+  const totalWidth = daysInMonth * cellWidth;
+  const headerLevels = timelineHeaderLevels || getDefaultTimelineHeaderLevels("timelineMonth");
+  const headerCells = generateTimelineHeaderCells(monthStart, monthEndPlusOne, headerLevels, locale, options.timeFormat, options.timezone, displayConfig);
+  const cells = generateDayCells(monthStart, monthEndPlusOne, cellWidth);
+  const days = generateMonthDays(monthStart, daysInMonth, cellWidth, locale, displayConfig);
+  const monthEvents = getEventsInDateRange(events, monthStart, monthEndPlusOne);
+  const eventPositions = positionTimelineEventsForDayGranularity(monthEvents, monthStart, monthEndPlusOne, cellWidth);
+  return {
+    year: date.getFullYear(),
+    month: date.getMonth(),
+    title: formatMonthYearTitle(date, locale, displayConfig),
+    headerLevels: headerCells,
+    cells,
+    days,
+    events: eventPositions,
+    totalWidth,
+    dateRange: { start: monthStart, end: monthEndPlusOne }
+  };
+}
+function generateMonthDays(monthStart, daysInMonth, cellWidth, locale, displayConfig) {
+  const days = [];
+  const dayNames = getWeekdayNames(locale, "short", 0, displayConfig);
+  for (let i = 0; i < daysInMonth; i++) {
+    const dayDate = addDays(monthStart, i);
+    days.push({
+      date: dayDate,
+      dayOfMonth: i + 1,
+      dayName: dayNames[dayDate.getDay()],
+      isToday: isToday(dayDate),
+      isWeekend: isWeekend(dayDate),
+      width: cellWidth,
+      index: i
+    });
+  }
+  return days;
+}
+
+// src/views/timeline/timeline-year.view.ts
+var timelineYearView = {
+  name: "timelineYear",
+  getTitle(date, locale) {
+    return createSchedulerDateFormatter({ locale }).formatYear(date);
+  },
+  getDateRange(date) {
+    const yearStart = new Date(date.getFullYear(), 0, 1);
+    const yearEnd = new Date(date.getFullYear() + 1, 0, 1);
+    return { start: yearStart, end: yearEnd };
+  },
+  navigate(date, direction) {
+    return addYears(date, direction);
+  },
+  navigateToDate(target) {
+    return new Date(target.getFullYear(), 0, 1);
+  }
+};
+function getTimelineYearViewData(date, options) {
+  const { locale, events, timelineYearEventsPerRow = 2, timelineYearShowTime = true, timeFormat, timezone, calendar, numberingSystem } = options;
+  const displayConfig = { calendar, numberingSystem };
+  const year = date.getFullYear();
+  const yearStart = new Date(year, 0, 1);
+  const yearEnd = new Date(year + 1, 0, 1);
+  const monthNames = getMonthNames(locale, "long", displayConfig);
+  const shortMonthNames = getMonthNames(locale, "short", displayConfig);
+  const formatter = createSchedulerDateFormatter({ ...displayConfig, locale });
+  const months = [];
+  for (let monthIndex = 0; monthIndex < 12; monthIndex++) {
+    const monthStart = new Date(year, monthIndex, 1);
+    const monthEnd = endOfMonth(monthStart);
+    const monthEndPlusOne = addDays(monthEnd, 1);
+    const monthEvents = getEventsInDateRange(events, monthStart, monthEndPlusOne);
+    const visibleEvents = monthEvents.slice(0, timelineYearEventsPerRow);
+    const overflowCount = Math.max(0, monthEvents.length - timelineYearEventsPerRow);
+    const yearEvents = visibleEvents.map((event) => ({
+      event,
+      startTime: timelineYearShowTime ? formatEventTime(event.start, locale, timeFormat, timezone) : "",
+      endTime: timelineYearShowTime ? formatEventTime(event.end || event.start, locale, timeFormat, timezone) : ""
+    }));
+    months.push({
+      date: monthStart,
+      name: monthNames[monthIndex],
+      shortName: shortMonthNames[monthIndex],
+      monthIndex,
+      events: yearEvents,
+      overflowCount
+    });
+  }
+  return {
+    year,
+    title: formatter.formatYear(date),
+    months,
+    dateRange: { start: yearStart, end: yearEnd }
+  };
+}
+function formatEventTime(dateInput, locale, options, timeZone) {
+  if (!dateInput) return "";
+  const date = typeof dateInput === "string" ? new Date(dateInput) : dateInput;
+  return formatTime(date, locale, options, timeZone);
+}
+
+export { calculateTimelineEventPosition, formatTimelineTitle, generateDayCells, generateTimelineCells, generateTimelineHeaderCells, getDefaultTimelineHeaderLevels, getEventsInDateRange, getTimelineDayViewData, getTimelineMonthViewData, getTimelineWeekViewData, getTimelineYearViewData, positionTimelineEvents, positionTimelineEventsForDayGranularity, positionTimelineEventsWithBusinessHours, timelineDayView, timelineMonthView, timelineWeekView, timelineYearView };