@primeui/scheduler-core 0.0.1-alpha.1

package/dist/chunk-ZUKUKGNK.mjs

@@ -0,0 +1,613 @@
+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';
+
+// src/views/agenda.view.ts
+var agendaView = {
+  name: "agenda",
+  getTitle(date, locale) {
+    const options = {
+      month: "long",
+      year: "numeric"
+    };
+    return createSchedulerDateFormatter({ locale }).format(date, options);
+  },
+  getDateRange(date) {
+    const start = startOfDay(date);
+    const end = addDays(start, 30);
+    return { start, end };
+  },
+  navigate(date, direction) {
+    return addDays(date, direction * 30);
+  },
+  navigateToDate(target) {
+    return startOfDay(target);
+  }
+};
+function getAgendaViewData(date, options) {
+  const { locale, events, agendaDays = 30, showEmptyDays = false, calendar, numberingSystem } = options;
+  const displayConfig = { calendar, numberingSystem };
+  const startDate = startOfDay(date);
+  const endDate = addDays(startDate, agendaDays - 1);
+  const days = [];
+  let currentDate = new Date(startDate);
+  for (let i = 0; i < agendaDays; i++) {
+    const dayEvents = getEventsForDay(currentDate, events);
+    if (showEmptyDays || dayEvents.length > 0) {
+      days.push({
+        date: new Date(currentDate),
+        dateStr: toDateString(currentDate),
+        dayName: formatWeekdayName(currentDate, locale, "long", displayConfig),
+        isToday: isToday(currentDate),
+        events: sortEventsByTime(dayEvents)
+      });
+    }
+    currentDate = addDays(currentDate, 1);
+  }
+  return {
+    days,
+    startDate,
+    endDate
+  };
+}
+function getEventsForDay(date, events) {
+  return events.filter((event) => {
+    const eventStart = typeof event.start === "string" ? new Date(event.start) : event.start;
+    return isSameDay(eventStart, date);
+  });
+}
+function sortEventsByTime(events) {
+  return [...events].sort((a, b) => {
+    if (a.allDay && !b.allDay) return -1;
+    if (!a.allDay && b.allDay) return 1;
+    const startA = typeof a.start === "string" ? new Date(a.start) : a.start;
+    const startB = typeof b.start === "string" ? new Date(b.start) : b.start;
+    return startA.getTime() - startB.getTime();
+  });
+}
+function formatEventTime(event, locale, options, timeZone) {
+  if (event.allDay) {
+    return "All day";
+  }
+  const start = typeof event.start === "string" ? new Date(event.start) : event.start;
+  if (event.end) {
+    const end = typeof event.end === "string" ? new Date(event.end) : event.end;
+    return formatTimeRange(start, end, locale, options, timeZone);
+  }
+  return formatTime(start, locale, options, timeZone);
+}
+
+// src/views/week.view.ts
+var weekView = {
+  name: "week",
+  getTitle(date, locale) {
+    const weekStart = startOfWeek(date, 0);
+    const weekEnd = addDays(weekStart, 6);
+    if (weekStart.getMonth() === weekEnd.getMonth()) {
+      return formatMonthYearTitle(weekStart, locale);
+    }
+    const formatter = createSchedulerDateFormatter({ locale });
+    const startMonth = formatter.formatMonth(weekStart, "short");
+    const endMonth = formatter.format(weekEnd, { month: "short", year: "numeric" });
+    return `${startMonth} - ${endMonth}`;
+  },
+  getDateRange(date, options) {
+    const weekStart = startOfWeek(date, options.firstDayOfWeek);
+    const weekEnd = addDays(weekStart, 6);
+    return { start: weekStart, end: weekEnd };
+  },
+  navigate(date, direction) {
+    return addWeeks(date, direction);
+  },
+  navigateToDate(target) {
+    return new Date(target);
+  }
+};
+function getWeekViewData(date, options) {
+  const { locale, firstDayOfWeek, slotDuration, slotMinTime, slotMaxTime, events, daysOfWeek, numberOfDays, timeFormat, dateDisplay, timezone, calendar, numberingSystem } = options;
+  const displayConfig = { calendar, numberingSystem };
+  const weekdayFormat = dateDisplay?.weekdayFormat || "short";
+  const totalDays = numberOfDays ?? 7;
+  const startDate = numberOfDays ? date : startOfWeek(date, firstDayOfWeek);
+  const activeDays = daysOfWeek ?? [0, 1, 2, 3, 4, 5, 6];
+  const columns = [];
+  const allDayEvents = [];
+  for (let i = 0; i < totalDays; i++) {
+    const columnDate = addDays(startDate, i);
+    const dayOfWeek = columnDate.getDay();
+    if (!activeDays.includes(dayOfWeek)) continue;
+    const dayEvents = getEventsForDay2(columnDate, events);
+    const dayAllDayEvents = dayEvents.filter((e) => e.allDay);
+    const timedEvents = dayEvents.filter((e) => !e.allDay);
+    columns.push({
+      date: columnDate,
+      dayName: formatWeekdayName(columnDate, locale, weekdayFormat, displayConfig),
+      dayNumber: columnDate.getDate(),
+      isToday: isToday(columnDate),
+      isWeekend: isWeekend(columnDate),
+      events: timedEvents,
+      allDayEvents: dayAllDayEvents
+    });
+    allDayEvents.push(...dayAllDayEvents.filter((e) => !allDayEvents.some((existing) => existing.id === e.id)));
+  }
+  const timeSlots = generateTimeSlots(slotMinTime, slotMaxTime, slotDuration, date, locale, timeFormat, timezone);
+  const visibleWeekdayNames = numberOfDays || activeDays.length !== 7 ? columns.map((col) => col.dayName) : getWeekdayNames(locale, weekdayFormat, firstDayOfWeek, displayConfig);
+  return {
+    columns,
+    timeSlots,
+    allDayEvents,
+    weekdayNames: visibleWeekdayNames
+  };
+}
+function getCustomRangeTitle(date, numberOfDays, locale, displayConfig) {
+  const startDate = date;
+  const endDate = addDays(date, numberOfDays - 1);
+  const formatter = createSchedulerDateFormatter({ ...displayConfig, locale });
+  const formatOptions = { month: "short", day: "numeric" };
+  if (startDate.getMonth() === endDate.getMonth()) {
+    const monthYear = formatter.format(startDate, { month: "short", year: "numeric" });
+    return `${formatter.formatDayNumber(startDate)}-${formatter.formatDayNumber(endDate)} ${monthYear}`;
+  }
+  if (startDate.getFullYear() === endDate.getFullYear()) {
+    const start2 = formatter.format(startDate, formatOptions);
+    const end2 = formatter.format(endDate, { ...formatOptions, year: "numeric" });
+    return `${start2} - ${end2}`;
+  }
+  const start = formatter.format(startDate, { ...formatOptions, year: "numeric" });
+  const end = formatter.format(endDate, { ...formatOptions, year: "numeric" });
+  return `${start} - ${end}`;
+}
+function generateTimeSlots(minTime, maxTime, slotDuration, date, locale, timeFormat, timeZone) {
+  const slots = [];
+  const minMinutes = timeStringToMinutes(minTime);
+  const maxMinutes = timeStringToMinutes(maxTime);
+  const year = date.getFullYear();
+  const month = date.getMonth();
+  const day = date.getDate();
+  for (let minutes = minMinutes; minutes < maxMinutes; minutes += slotDuration) {
+    const hours = Math.floor(minutes / 60);
+    const mins = minutes % 60;
+    const slotDate = new Date(year, month, day, hours, mins);
+    const isHourStart = mins === 0;
+    const isHourEnd = (minutes + slotDuration) % 60 === 0;
+    slots.push({
+      time: slotDate,
+      timeString: `${String(hours).padStart(2, "0")}:${String(mins).padStart(2, "0")}`,
+      label: isHourStart ? formatSlotTime(slotDate, locale, timeFormat, timeZone) : "",
+      minutes,
+      isHour: isHourEnd
+    });
+  }
+  return slots;
+}
+function getNowIndicatorPosition(slotMinTime, slotMaxTime, slotDuration, slotHeight, timezone) {
+  const now = /* @__PURE__ */ new Date();
+  let currentMinutes;
+  if (timezone) {
+    const parts = getDatePartsInTimezone(now, timezone);
+    currentMinutes = parts.hour * 60 + parts.minute;
+  } else {
+    currentMinutes = now.getHours() * 60 + now.getMinutes();
+  }
+  const minMinutes = timeStringToMinutes(slotMinTime);
+  const maxMinutes = timeStringToMinutes(slotMaxTime);
+  if (currentMinutes < minMinutes || currentMinutes >= maxMinutes) {
+    return { top: 0, visible: false };
+  }
+  const totalSlots = (maxMinutes - minMinutes) / slotDuration;
+  const currentSlot = (currentMinutes - minMinutes) / slotDuration;
+  const top = currentSlot / totalSlots * totalSlots * slotHeight;
+  const visualSlots = Math.floor((maxMinutes - minMinutes) / slotDuration);
+  const maxTop = visualSlots * slotHeight - 2;
+  const clampedTop = Math.min(top, maxTop);
+  return { top: clampedTop, visible: true };
+}
+function getEventTopPosition(event, slotMinTime, slotDuration, slotHeight) {
+  const eventStart = typeof event.start === "string" ? new Date(event.start) : event.start;
+  const eventMinutes = eventStart.getHours() * 60 + eventStart.getMinutes();
+  const minMinutes = timeStringToMinutes(slotMinTime);
+  const offsetMinutes = eventMinutes - minMinutes;
+  return offsetMinutes / slotDuration * slotHeight;
+}
+function getEventHeight(event, slotDuration, slotHeight) {
+  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);
+  const durationMinutes = (eventEnd.getTime() - eventStart.getTime()) / (1e3 * 60);
+  return Math.max(durationMinutes / slotDuration * slotHeight, slotHeight / 2);
+}
+function getEventsForDay2(date, events) {
+  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;
+    if (event.allDay) {
+      const dayStart = new Date(date);
+      dayStart.setHours(0, 0, 0, 0);
+      const dayEnd = new Date(date);
+      dayEnd.setHours(23, 59, 59, 999);
+      return eventStart <= dayEnd && eventEnd >= dayStart;
+    }
+    return isSameDay(eventStart, date);
+  });
+}
+
+// src/views/day.view.ts
+var dayView = {
+  name: "day",
+  getTitle(date, locale) {
+    const options = {
+      weekday: "long",
+      month: "long",
+      day: "numeric",
+      year: "numeric"
+    };
+    return createSchedulerDateFormatter({ locale }).format(date, options);
+  },
+  getDateRange(date) {
+    const dayStart = new Date(date);
+    dayStart.setHours(0, 0, 0, 0);
+    const dayEnd = new Date(date);
+    dayEnd.setHours(23, 59, 59, 999);
+    return { start: dayStart, end: dayEnd };
+  },
+  navigate(date, direction) {
+    return addDays(date, direction);
+  },
+  navigateToDate(target) {
+    return new Date(target);
+  }
+};
+function getDayViewData(date, options) {
+  const { locale, slotDuration, slotMinTime, slotMaxTime, events, timeFormat, dateDisplay, timezone, calendar, numberingSystem } = options;
+  const displayConfig = { calendar, numberingSystem };
+  const weekdayFormat = dateDisplay?.weekdayFormat || "long";
+  const dayEvents = getEventsForDay3(date, events);
+  const allDayEvents = dayEvents.filter((e) => e.allDay);
+  const timedEvents = dayEvents.filter((e) => !e.allDay);
+  const timeSlots = generateTimeSlots(slotMinTime, slotMaxTime, slotDuration, date, locale, timeFormat, timezone);
+  return {
+    date,
+    dayName: formatWeekdayName(date, locale, weekdayFormat, displayConfig),
+    dayNumber: date.getDate(),
+    isToday: isToday(date),
+    timeSlots,
+    events: timedEvents,
+    allDayEvents
+  };
+}
+function getEventsForDay3(date, events) {
+  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;
+    if (event.allDay) {
+      const dayStart = new Date(date);
+      dayStart.setHours(0, 0, 0, 0);
+      const dayEnd = new Date(date);
+      dayEnd.setHours(23, 59, 59, 999);
+      return eventStart <= dayEnd && eventEnd >= dayStart;
+    }
+    return isSameDay(eventStart, date);
+  });
+}
+
+// src/views/month.view.ts
+var monthView = {
+  name: "month",
+  getTitle(date, locale) {
+    return formatMonthYearTitle(date, locale);
+  },
+  getDateRange(date, options) {
+    const calendarAdapter = getSchedulerCalendarAdapter(options.calendar, { locale: options.locale });
+    const monthStart = calendarAdapter.startOfMonth(calendarAdapter.fromDate(date));
+    const gridStart = calendarAdapter.startOfWeek(monthStart, options.firstDayOfWeek);
+    const gridEnd = calendarAdapter.add(gridStart, { days: 41 });
+    return { start: calendarAdapter.toDate(gridStart), end: calendarAdapter.toDate(gridEnd) };
+  },
+  navigate(date, direction) {
+    return addMonths(date, direction);
+  },
+  navigateToDate(target) {
+    return new Date(target);
+  }
+};
+function getMonthViewData(date, options) {
+  const { locale, firstDayOfWeek, minDate, maxDate, events, weekNumbering, calendar, numberingSystem } = options;
+  const displayConfig = { calendar, numberingSystem };
+  const model = buildMonthGridViewModel({
+    currentDate: date,
+    firstDayOfWeek,
+    events,
+    locale,
+    calendar,
+    numberingSystem,
+    weekNumbering,
+    minDate,
+    maxDate,
+    maxVisibleRows: Number.MAX_SAFE_INTEGER
+  });
+  const weeks = model.weeks.map((week) => ({
+    weekNumber: week.weekNumber,
+    days: week.days.map(
+      (day) => ({
+        date: day.date,
+        dayOfMonth: day.dayOfMonth,
+        dayOfMonthLabel: day.dayOfMonthLabel,
+        dayNumberLabel: day.dayNumberLabel,
+        isCurrentMonth: day.isCurrentMonth,
+        isToday: day.isToday,
+        isWeekend: day.isWeekend,
+        isDisabled: day.isDisabled,
+        events: day.events
+      })
+    )
+  }));
+  return {
+    weeks,
+    weekdayNames: getWeekdayNames(locale, "short", firstDayOfWeek, displayConfig)
+  };
+}
+
+// src/views/year.view.ts
+var yearView = {
+  name: "year",
+  getTitle(date, locale) {
+    return formatGregorianYear(date, locale);
+  },
+  getDateRange(date, options) {
+    const calendarAdapter = getSchedulerCalendarAdapter(options.calendar, { locale: options.locale });
+    const calendarDate = calendarAdapter.fromDate(date);
+    const yearStart = calendarAdapter.toDate(calendarAdapter.startOfMonth({ ...calendarDate, month: 1 }));
+    const yearEnd = calendarAdapter.toDate(calendarAdapter.endOfMonth({ ...calendarDate, month: calendarAdapter.getMonthsInYear(calendarDate), day: 1 }));
+    return { start: yearStart, end: yearEnd };
+  },
+  navigate(date, direction) {
+    return addYears(date, direction);
+  },
+  navigateToDate(target) {
+    return new Date(target.getFullYear(), 0, 1);
+  }
+};
+function getYearViewData(date, options) {
+  const { locale, firstDayOfWeek, minDate, maxDate, events, calendar, numberingSystem } = options;
+  const model = buildYearGridViewModel({
+    currentDate: date,
+    firstDayOfWeek,
+    events,
+    locale,
+    calendar,
+    numberingSystem,
+    minDate,
+    maxDate
+  });
+  const months = model.months.map((month) => ({
+    date: month.date,
+    name: month.name,
+    shortName: formatGregorianMonthTitle(month.date, locale, { month: "short", year: void 0 }, { calendar, numberingSystem }),
+    monthIndex: month.monthIndex,
+    weeks: month.weeks.map((week) => ({
+      days: week.days.map(
+        (day) => ({
+          date: day.date,
+          dayOfMonth: day.dayOfMonth,
+          dayOfMonthLabel: day.dayOfMonthLabel,
+          dayNumberLabel: day.dayNumberLabel,
+          isCurrentMonth: day.isCurrentMonth,
+          isToday: day.isToday,
+          isWeekend: day.isWeekend,
+          hasEvents: day.hasEvents,
+          eventCount: day.eventCount,
+          isDisabled: day.isDisabled
+        })
+      )
+    }))
+  }));
+  return {
+    year: model.year,
+    yearLabel: model.yearLabel,
+    months
+  };
+}
+function getYearViewWeekdayNames(locale, firstDayOfWeek, displayConfig) {
+  return getWeekdayNames(locale, "narrow", firstDayOfWeek, displayConfig);
+}
+
+// src/views/resource-day.view.ts
+var resourceDayView = {
+  name: "resourceDay",
+  getTitle(date, locale) {
+    const options = {
+      weekday: "long",
+      month: "long",
+      day: "numeric",
+      year: "numeric"
+    };
+    return createSchedulerDateFormatter({ locale }).format(date, options);
+  },
+  getDateRange(date) {
+    const dayStart = new Date(date);
+    dayStart.setHours(0, 0, 0, 0);
+    const dayEnd = new Date(date);
+    dayEnd.setHours(23, 59, 59, 999);
+    return { start: dayStart, end: dayEnd };
+  },
+  navigate(date, direction) {
+    return addDays(date, direction);
+  },
+  navigateToDate(target) {
+    return new Date(target);
+  }
+};
+function getResourceDayViewData(date, options) {
+  const { locale, slotDuration, slotMinTime, slotMaxTime, events, resources, timeFormat, timezone, calendar, numberingSystem } = options;
+  const displayConfig = { calendar, numberingSystem };
+  const timeSlots = generateTimeSlots(slotMinTime, slotMaxTime, slotDuration, date, locale, timeFormat, timezone);
+  const resourceColumns = [];
+  for (const resource of resources) {
+    const resourceEvents = getEventsForResourceAndDay(date, resource.id, events);
+    const allDayEvents = resourceEvents.filter((e) => e.allDay);
+    const timedEvents = resourceEvents.filter((e) => !e.allDay);
+    resourceColumns.push({
+      resourceId: resource.id,
+      resourceTitle: resource.title,
+      resourceColor: resource.eventColor,
+      date,
+      dayName: formatWeekdayName(date, locale, "long", displayConfig),
+      dayNumber: date.getDate(),
+      isToday: isToday(date),
+      events: timedEvents,
+      allDayEvents
+    });
+  }
+  return {
+    date,
+    dayName: formatWeekdayName(date, locale, "long", displayConfig),
+    dayNumber: date.getDate(),
+    isToday: isToday(date),
+    resources: resourceColumns,
+    timeSlots
+  };
+}
+function getEventsForResourceAndDay(date, resourceId, events) {
+  return events.filter((event) => {
+    const eventResourceId = event.resourceId;
+    const eventResourceIds = event.resourceIds;
+    const matchesResource = eventResourceId === resourceId || eventResourceIds && eventResourceIds.includes(resourceId);
+    if (!matchesResource) {
+      return false;
+    }
+    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 (event.allDay) {
+      const dayStart = new Date(date);
+      dayStart.setHours(0, 0, 0, 0);
+      const dayEnd = new Date(date);
+      dayEnd.setHours(23, 59, 59, 999);
+      return eventStart <= dayEnd && eventEnd >= dayStart;
+    }
+    return isSameDay(eventStart, date);
+  });
+}
+
+// src/views/resource-week.view.ts
+var resourceWeekView = {
+  name: "resourceWeek",
+  getTitle(date, locale) {
+    const weekStart = startOfWeek(date, 0);
+    const weekEnd = addDays(weekStart, 6);
+    if (weekStart.getMonth() === weekEnd.getMonth()) {
+      return formatMonthYearTitle(weekStart, locale);
+    }
+    const formatter = createSchedulerDateFormatter({ locale });
+    const startMonth = formatter.formatMonth(weekStart, "short");
+    const endMonth = formatter.format(weekEnd, { month: "short", year: "numeric" });
+    return `${startMonth} - ${endMonth}`;
+  },
+  getDateRange(date, options) {
+    const weekStart = startOfWeek(date, options.firstDayOfWeek);
+    const weekEnd = addDays(weekStart, 6);
+    return { start: weekStart, end: weekEnd };
+  },
+  navigate(date, direction) {
+    return addWeeks(date, direction);
+  },
+  navigateToDate(target) {
+    return new Date(target);
+  }
+};
+function getResourceWeekViewData(date, options) {
+  const { locale, firstDayOfWeek, slotDuration, slotMinTime, slotMaxTime, events, resources, daysOfWeek, timeFormat, timezone, calendar, numberingSystem } = options;
+  const displayConfig = { calendar, numberingSystem };
+  const weekStart = startOfWeek(date, firstDayOfWeek);
+  const activeDays = daysOfWeek ?? [0, 1, 2, 3, 4, 5, 6];
+  const timeSlots = generateTimeSlots(slotMinTime, slotMaxTime, slotDuration, date, locale, timeFormat, timezone);
+  const resourceColumns = [];
+  for (const resource of resources) {
+    const days = [];
+    for (let i = 0; i < 7; i++) {
+      const columnDate = addDays(weekStart, i);
+      const dayOfWeek = columnDate.getDay();
+      if (!activeDays.includes(dayOfWeek)) continue;
+      const dayEvents = getEventsForResourceAndDay2(columnDate, resource.id, events);
+      const dayAllDayEvents = dayEvents.filter((e) => e.allDay);
+      const timedEvents = dayEvents.filter((e) => !e.allDay);
+      days.push({
+        date: columnDate,
+        dayName: formatWeekdayName(columnDate, locale, "short", displayConfig),
+        dayNumber: columnDate.getDate(),
+        isToday: isToday(columnDate),
+        isWeekend: isWeekend(columnDate),
+        events: timedEvents,
+        allDayEvents: dayAllDayEvents
+      });
+    }
+    resourceColumns.push({
+      resourceId: resource.id,
+      resourceTitle: resource.title,
+      resourceColor: resource.eventColor,
+      days
+    });
+  }
+  const visibleWeekdayNames = activeDays.length === 7 ? getWeekdayNames(locale, "short", firstDayOfWeek, displayConfig) : resourceColumns[0]?.days.map((d) => d.dayName) ?? [];
+  return {
+    resources: resourceColumns,
+    timeSlots,
+    weekdayNames: visibleWeekdayNames
+  };
+}
+function getEventsForResourceAndDay2(date, resourceId, events) {
+  return events.filter((event) => {
+    const eventResourceId = event.resourceId;
+    const eventResourceIds = event.resourceIds;
+    const matchesResource = eventResourceId === resourceId || eventResourceIds && eventResourceIds.includes(resourceId);
+    if (!matchesResource) {
+      return false;
+    }
+    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 (event.allDay) {
+      const dayStart = new Date(date);
+      dayStart.setHours(0, 0, 0, 0);
+      const dayEnd = new Date(date);
+      dayEnd.setHours(23, 59, 59, 999);
+      return eventStart <= dayEnd && eventEnd >= dayStart;
+    }
+    return isSameDay(eventStart, date);
+  });
+}
+
+// src/views/index.ts
+var viewRegistry = {
+  month: monthView,
+  week: weekView,
+  day: dayView,
+  year: yearView,
+  agenda: agendaView,
+  timelineDay: timelineDayView,
+  timelineWeek: timelineWeekView,
+  timelineMonth: timelineMonthView,
+  timelineYear: timelineYearView,
+  resourceTimelineDay: timelineDayView,
+  resourceTimelineWeek: timelineWeekView,
+  resourceTimelineMonth: timelineMonthView,
+  resourceDay: resourceDayView,
+  resourceWeek: resourceWeekView,
+  resourceMonth: monthView,
+  dateDay: dayView,
+  dateWeek: weekView,
+  dateMonth: monthView
+};
+function getView(viewType) {
+  const view = viewRegistry[viewType];
+  if (!view) {
+    throw new Error(`Unknown view type: ${viewType}`);
+  }
+  return view;
+}
+function getAvailableViews() {
+  return Object.keys(viewRegistry);
+}
+
+export { agendaView, dayView, formatEventTime, generateTimeSlots, getAgendaViewData, getAvailableViews, getCustomRangeTitle, getDayViewData, getEventHeight, getEventTopPosition, getMonthViewData, getNowIndicatorPosition, getResourceDayViewData, getResourceWeekViewData, getView, getWeekViewData, getYearViewData, getYearViewWeekdayNames, monthView, resourceDayView, resourceWeekView, viewRegistry, weekView, yearView };