@primeui/scheduler-core 0.0.1-alpha.1

package/dist/chunk-F5W5HD7S.mjs

@@ -0,0 +1,285 @@
+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';
+
+// src/time-grid/view-model.ts
+var RESOURCE_VIEWS = ["resourceDay", "resourceWeek"];
+var SINGLE_DAY_VIEWS = ["day", "resourceDay", "dateDay"];
+var EMPTY_OVERFLOW_BY_DAY = Object.freeze({});
+function getSlotHeight(density) {
+  switch (density) {
+    case "compact":
+      return 24;
+    case "standard":
+      return 32;
+    case "comfortable":
+      return 44;
+    default:
+      return 48;
+  }
+}
+function getMinutesFromMidnight(date) {
+  return date.getHours() * 60 + date.getMinutes();
+}
+function getColumnKey(date, resourceId) {
+  return `${toDateString(date)}::${resourceId === void 0 ? "__all__" : String(resourceId)}`;
+}
+function matchesEventIdentity(candidate, event) {
+  const eventStart = event.start instanceof Date ? event.start : new Date(event.start);
+  const eventEnd = event.end instanceof Date ? event.end : new Date(event.end || event.start);
+  return candidate.id === event.id && candidate.start.getTime() === eventStart.getTime() && (candidate.end?.getTime() ?? eventStart.getTime()) === eventEnd.getTime();
+}
+function toCalendarDate(view, date, locale, calendar) {
+  const mode = resolveSchedulerCalendarModeForView(calendar ?? "gregory", view);
+  const adapter = getSchedulerCalendarAdapter(mode, { locale });
+  return startOfDay(adapter.toDate(adapter.fromDate(date)));
+}
+function normalizeDaysOfWeek(days) {
+  const normalized = Array.from(new Set((days ?? [0, 1, 2, 3, 4, 5, 6]).filter((day) => Number.isInteger(day) && day >= 0 && day <= 6)));
+  return normalized.length > 0 ? normalized : [0, 1, 2, 3, 4, 5, 6];
+}
+function normalizeNumberOfDays(value) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0 ? Math.floor(value) : void 0;
+}
+function buildTimeGridDays(view, date, firstDayOfWeek, locale, calendar, numberOfDays, daysOfWeek) {
+  const mode = resolveSchedulerCalendarModeForView(calendar ?? "gregory", view);
+  const adapter = getSchedulerCalendarAdapter(mode, { locale });
+  const currentCalendarDate = adapter.fromDate(date);
+  if (SINGLE_DAY_VIEWS.includes(view)) {
+    return [toCalendarDate(view, date, locale, calendar)];
+  }
+  const customDayCount = normalizeNumberOfDays(numberOfDays);
+  const start = customDayCount ? currentCalendarDate : adapter.startOfWeek(currentCalendarDate, firstDayOfWeek);
+  const activeDays = new Set(normalizeDaysOfWeek(daysOfWeek));
+  const totalDays = customDayCount ?? 7;
+  const result = [];
+  for (let i = 0; i < totalDays; i++) {
+    const calendarDay = adapter.add(start, { days: i });
+    if (activeDays.has(adapter.getDayOfWeek(calendarDay))) {
+      result.push(adapter.toDate(calendarDay));
+    }
+  }
+  return result;
+}
+function buildTimeSlots(slotMinTime, slotMaxTime, slotDuration) {
+  const minMinutes = timeStringToMinutes(slotMinTime);
+  const maxMinutes = timeStringToMinutes(slotMaxTime);
+  const slots = [];
+  for (let minutes = minMinutes; minutes < maxMinutes; minutes += slotDuration) {
+    const hour = Math.floor(minutes / 60);
+    const minute = minutes % 60;
+    slots.push({
+      time: `${String(hour).padStart(2, "0")}:${String(minute).padStart(2, "0")}`,
+      minutes
+    });
+  }
+  return slots;
+}
+function resolveNowIndicatorTop(input) {
+  if (!input.enabled) return null;
+  const currentParts = getDatePartsInTimezone(input.now, input.timezone);
+  const todayInView = input.days.some((date) => date.getFullYear() === currentParts.year && date.getMonth() === currentParts.month && date.getDate() === currentParts.day);
+  if (!todayInView) return null;
+  const nowMinutes = currentParts.hour * 60 + currentParts.minute;
+  const minMinutes = timeStringToMinutes(input.slotMinTime);
+  const maxMinutes = timeStringToMinutes(input.slotMaxTime);
+  if (nowMinutes < minMinutes || nowMinutes > maxMinutes) return null;
+  const offset = nowMinutes - minMinutes;
+  return offset / input.slotDuration * input.slotHeight;
+}
+function buildTimeGridViewModel(input) {
+  const slotDuration = input.slotDuration ?? 30;
+  const slotMinTime = input.slotMinTime ?? "00:00";
+  const slotMaxTime = input.slotMaxTime ?? "24:00";
+  const slotHeight = getSlotHeight(input.density);
+  const days = buildTimeGridDays(input.currentView, input.currentDate, input.firstDayOfWeek, input.locale, input.calendar, input.numberOfDays, input.daysOfWeek);
+  const resources = RESOURCE_VIEWS.includes(input.currentView) ? input.resources ?? [] : [];
+  const minMinutes = timeStringToMinutes(slotMinTime);
+  const maxMinutes = timeStringToMinutes(slotMaxTime);
+  const totalSlotCount = Math.ceil((maxMinutes - minMinutes) / slotDuration);
+  const totalHeight = totalSlotCount * slotHeight;
+  const timeSlots = buildTimeSlots(slotMinTime, slotMaxTime, slotDuration);
+  const parsedEvents = parseEvents(input.events);
+  const positioningOptions = {
+    slotMinTime,
+    slotMaxTime,
+    slotDuration,
+    slotHeight
+  };
+  const usesSpanningAllDayRow = days.length > 1;
+  const weekRange = (() => {
+    if (days.length === 0) return null;
+    const start = startOfDay(days[0]);
+    const end = new Date(days[days.length - 1]);
+    end.setHours(23, 59, 59, 999);
+    return { start, end };
+  })();
+  const buildPositionedColumn = (date, resourceId) => {
+    if (resourceId === void 0) {
+      return positionEventsForDay(parsedEvents, date, positioningOptions);
+    }
+    const resourceEvents = getTimedEventsForDayAndResource(parsedEvents, date, resourceId);
+    return positionEventsForDay(resourceEvents, date, positioningOptions);
+  };
+  const positionedTimedColumns = /* @__PURE__ */ new Map();
+  const resourcesForLayouts = resources.map((resource) => resource.id);
+  for (const day of days) {
+    positionedTimedColumns.set(getColumnKey(day), buildPositionedColumn(day));
+    for (const resourceId of resourcesForLayouts) {
+      positionedTimedColumns.set(getColumnKey(day, resourceId), buildPositionedColumn(day, resourceId));
+    }
+  }
+  const getPositionedColumn = (date, resourceId) => {
+    return positionedTimedColumns.get(getColumnKey(date, resourceId)) ?? buildPositionedColumn(date, resourceId);
+  };
+  const getAllDayEventsForDay2 = (date, resourceId) => {
+    const scopedEvents = parsedEvents.filter((event) => eventMatchesResource(event, resourceId));
+    return getAllDayEventsForDay(scopedEvents, date).map((event) => event);
+  };
+  const buildAllDayWeekLayout = (resourceId) => {
+    if (!weekRange) {
+      return {
+        positioned: [],
+        overflowByDay: EMPTY_OVERFLOW_BY_DAY,
+        visibleRowCount: 0,
+        gridRowCount: 1
+      };
+    }
+    const scopedEvents = parsedEvents.filter((event) => eventMatchesResource(event, resourceId));
+    const positioned = positionAllDayEventsForWeek(scopedEvents, weekRange.start, weekRange.end).map((eventPosition) => ({
+      event: eventPosition.event,
+      row: eventPosition.row,
+      startCol: eventPosition.startCol,
+      endCol: eventPosition.endCol,
+      isContinuationStart: !eventPosition.isStart,
+      isContinuationEnd: !eventPosition.isEnd
+    }));
+    const totalRowCount = positioned.length === 0 ? 0 : Math.max(...positioned.map((event) => event.row)) + 1;
+    return {
+      positioned,
+      overflowByDay: EMPTY_OVERFLOW_BY_DAY,
+      visibleRowCount: totalRowCount,
+      gridRowCount: Math.max(totalRowCount, 1)
+    };
+  };
+  const allDayWeekLayouts = /* @__PURE__ */ new Map();
+  allDayWeekLayouts.set("__all__", buildAllDayWeekLayout());
+  for (const resource of resources) {
+    allDayWeekLayouts.set(String(resource.id), buildAllDayWeekLayout(resource.id));
+  }
+  const getWeekAllDayLayout = (resourceId) => {
+    return allDayWeekLayouts.get(resourceId === void 0 ? "__all__" : String(resourceId)) ?? buildAllDayWeekLayout(resourceId);
+  };
+  const getPositionedTimedEvent = (event, date, resourceId) => {
+    const match = getPositionedColumn(date, resourceId).find((candidate) => matchesEventIdentity(candidate, event));
+    if (!match) return null;
+    return {
+      event: match,
+      top: match.top,
+      height: match.height,
+      left: match.left,
+      width: match.width,
+      zIndex: match.zIndex
+    };
+  };
+  const getVisibleAllDayEventsForDay = (date, resourceId) => {
+    if (!usesSpanningAllDayRow) {
+      return getAllDayEventsForDay2(date, resourceId);
+    }
+    const dayKey = toDateString(date);
+    const dayIndex = days.findIndex((day) => toDateString(day) === dayKey);
+    if (dayIndex === -1) return [];
+    return getWeekAllDayLayout(resourceId).positioned.filter((event) => event.startCol <= dayIndex && event.endCol >= dayIndex).map((event) => event.event);
+  };
+  const nowIndicatorTop = resolveNowIndicatorTop({
+    enabled: input.nowIndicator ?? false,
+    now: input.now ?? /* @__PURE__ */ new Date(),
+    days,
+    timezone: input.resolvedDisplayTimezone ?? "UTC",
+    slotMinTime,
+    slotMaxTime,
+    slotDuration,
+    slotHeight
+  });
+  const getBusinessHoursOverlays = (date) => {
+    if (input.showBusinessHours === false) return [];
+    if (!input.businessHours) return [];
+    return getTimedBusinessHoursOverlays(date, input.businessHours, slotMinTime, slotMaxTime, slotDuration, slotHeight);
+  };
+  const getBlockedIntervalOverlays = (date, resourceId) => {
+    return getTimedBlockedIntervalsOverlays(date, input.blockedIntervals, slotMinTime, slotMaxTime, slotDuration, slotHeight, resourceId);
+  };
+  return {
+    days,
+    resources,
+    slotDuration,
+    slotMinTime,
+    slotMaxTime,
+    slotHeight,
+    totalSlotCount,
+    totalHeight,
+    timeSlots,
+    parsedEvents,
+    usesSpanningAllDayRow,
+    hasAllDayEvents: days.some((day) => getAllDayEventsForDay2(day).length > 0),
+    nowIndicatorTop,
+    showNowIndicator: nowIndicatorTop !== null,
+    getTimedEventsForColumn: (date, resourceId) => getPositionedColumn(date, resourceId).map((event) => event),
+    getAllDayEventsForDay: getAllDayEventsForDay2,
+    getVisibleAllDayEventsForDay,
+    getOverflowAllDayEventsForDay: () => [],
+    getPositionedTimedEvent,
+    getEventTopPosition: (event) => {
+      const eventStart = event.start instanceof Date ? event.start : new Date(event.start);
+      const eventMinutes = getMinutesFromMidnight(eventStart);
+      const offset = eventMinutes - minMinutes;
+      return offset / slotDuration * slotHeight;
+    },
+    getEventHeight: (event) => {
+      const eventStart = event.start instanceof Date ? event.start : new Date(event.start);
+      const eventEnd = event.end instanceof Date ? event.end : new Date(event.end || event.start);
+      const durationMinutes = (eventEnd.getTime() - eventStart.getTime()) / 6e4;
+      return Math.max(durationMinutes / slotDuration * slotHeight, slotHeight / 2);
+    },
+    getOverlapLayout: (event, date, resourceId) => {
+      const positioned = getPositionedTimedEvent(event, date, resourceId);
+      return {
+        left: `${positioned?.left ?? 0}%`,
+        width: `${positioned?.width ?? 100}%`,
+        zIndex: positioned?.zIndex ?? 1
+      };
+    },
+    getWeekAllDayLayout,
+    getBusinessHoursOverlays,
+    getBlockedIntervalOverlays,
+    getBlockedIntervalStyle: (interval, date, resourceId) => {
+      if (!input.blockedIntervals) return null;
+      const overlays = getBlockedIntervalOverlays(date, resourceId);
+      const overlay = overlays.find((candidate) => {
+        const candidateInterval = candidate.interval;
+        if (!candidateInterval) return false;
+        if (candidateInterval === interval) return true;
+        if (candidateInterval.id === interval.id) return true;
+        return candidateInterval.originalId === interval.id;
+      });
+      if (!overlay) return null;
+      return overlay.style;
+    },
+    getAppointmentSlotOverlaysForDay: (date, resourceId) => {
+      const config = input.appointmentSlots;
+      if (!config || !config.enabled) return [];
+      return getAppointmentSlotOverlays(config, date, input.events, slotMinTime, slotMaxTime, slotDuration, slotHeight, resourceId);
+    },
+    getAppointmentSlotIndicatorsForDay: (date, resourceId) => {
+      const config = input.appointmentSlots;
+      if (!config || !config.enabled) return [];
+      return getAppointmentSlotIndicators(config, date, input.events, slotMinTime, slotMaxTime, slotDuration, slotHeight, resourceId);
+    }
+  };
+}
+
+export { buildTimeGridViewModel };