@primeui/scheduler-core 0.0.1-alpha.1

package/dist/chunk-HPC5B3AR.mjs

@@ -0,0 +1,558 @@
+import { parseRRule } from './chunk-FIBAZFC4.mjs';
+import { timeStringToMinutes } from './chunk-WFUJWDST.mjs';
+import { createSchedulerDateFormatter, formatTimeRange } from './chunk-TNKJPFGI.mjs';
+
+// src/utils/blocked-intervals.ts
+function parseDate(date) {
+  return typeof date === "string" ? new Date(date) : new Date(date);
+}
+function isTimeOnlyFormat(value) {
+  return /^\d{1,2}:\d{2}(:\d{2})?$/.test(value);
+}
+function combineDateAndTime(date, timeStr) {
+  const result = new Date(date);
+  const parts = timeStr.split(":").map(Number);
+  const hours = parts[0] ?? 0;
+  const minutes = parts[1] ?? 0;
+  const seconds = parts[2] ?? 0;
+  result.setHours(hours, minutes, seconds, 0);
+  return result;
+}
+function getBlockedIntervalDisplayRange(interval, referenceDate) {
+  const startIsTimeOnly = typeof interval.start === "string" && isTimeOnlyFormat(interval.start);
+  const endIsTimeOnly = typeof interval.end === "string" && isTimeOnlyFormat(interval.end);
+  const baseDate = referenceDate ?? /* @__PURE__ */ new Date();
+  if (startIsTimeOnly && endIsTimeOnly) {
+    return {
+      start: combineDateAndTime(baseDate, interval.start),
+      end: combineDateAndTime(baseDate, interval.end)
+    };
+  }
+  return {
+    start: parseDate(interval.start),
+    end: parseDate(interval.end)
+  };
+}
+function getBlockedIntervalDisplayLabels(interval, options = {}) {
+  const { start, end } = getBlockedIntervalDisplayRange(interval, options.referenceDate);
+  const formatter = createSchedulerDateFormatter(options);
+  const titleLabel = interval.title ?? "Blocked interval";
+  const dateLabel = formatter.format(start, options.dateOptions ?? { weekday: "long", year: "numeric", month: "long", day: "numeric" });
+  const timeRangeLabel = formatTimeRange(start, end, formatter.config.locale, options.timeFormat, formatter.config.timeZone);
+  const rangeLabel = options.includeDate === false ? timeRangeLabel : `${dateLabel}, ${timeRangeLabel}`;
+  const summaryLabel = `${titleLabel}, ${rangeLabel}`;
+  return {
+    titleLabel,
+    dateLabel,
+    timeRangeLabel,
+    summaryLabel,
+    ariaLabel: `Blocked interval, ${summaryLabel}`
+  };
+}
+function addDays(date, days) {
+  const result = new Date(date);
+  result.setDate(result.getDate() + days);
+  return result;
+}
+function startOfDay(date) {
+  const result = new Date(date);
+  result.setHours(0, 0, 0, 0);
+  return result;
+}
+function endOfDay(date) {
+  const result = new Date(date);
+  result.setHours(23, 59, 59, 999);
+  return result;
+}
+function dateRangesOverlap(start1, end1, start2, end2) {
+  return start1 < end2 && start2 < end1;
+}
+function expandBlockedInterval(interval, rangeStart, rangeEnd, maxOccurrences = 365) {
+  const results = [];
+  const isStartTimeOnly = typeof interval.start === "string" && isTimeOnlyFormat(interval.start);
+  const isEndTimeOnly = typeof interval.end === "string" && isTimeOnlyFormat(interval.end);
+  if (interval.rrule) {
+    const rrule = typeof interval.rrule === "string" ? parseRRule(interval.rrule) : interval.rrule;
+    if (!rrule) return results;
+    const baseStart = isStartTimeOnly ? combineDateAndTime(rangeStart, interval.start) : parseDate(interval.start);
+    const baseDuration = isEndTimeOnly ? (() => {
+      const startTime = combineDateAndTime(new Date(2e3, 0, 1), interval.start);
+      const endTime = combineDateAndTime(new Date(2e3, 0, 1), interval.end);
+      return endTime.getTime() - startTime.getTime();
+    })() : parseDate(interval.end).getTime() - parseDate(interval.start).getTime();
+    const occurrences = expandRRuleForBlocked(rrule, baseStart, rangeStart, rangeEnd, interval.exdate, maxOccurrences);
+    for (const occStart of occurrences) {
+      const occEnd = new Date(occStart.getTime() + baseDuration);
+      if (dateRangesOverlap(occStart, occEnd, rangeStart, rangeEnd)) {
+        results.push({
+          id: `${interval.id}_${occStart.getTime()}`,
+          originalId: interval.id,
+          start: occStart,
+          end: occEnd,
+          resourceId: interval.resourceId,
+          resourceIds: interval.resourceIds,
+          title: interval.title,
+          className: interval.className,
+          background: interval.background,
+          isRecurring: true
+        });
+      }
+    }
+  } else if (isStartTimeOnly && isEndTimeOnly) {
+    let current = startOfDay(rangeStart);
+    while (current <= rangeEnd) {
+      const occStart = combineDateAndTime(current, interval.start);
+      const occEnd = combineDateAndTime(current, interval.end);
+      if (dateRangesOverlap(occStart, occEnd, rangeStart, rangeEnd)) {
+        results.push({
+          id: `${interval.id}_${occStart.getTime()}`,
+          originalId: interval.id,
+          start: occStart,
+          end: occEnd,
+          resourceId: interval.resourceId,
+          resourceIds: interval.resourceIds,
+          title: interval.title,
+          className: interval.className,
+          background: interval.background,
+          isRecurring: false
+        });
+      }
+      current = addDays(current, 1);
+    }
+  } else {
+    const start = parseDate(interval.start);
+    const end = parseDate(interval.end);
+    if (dateRangesOverlap(start, end, rangeStart, rangeEnd)) {
+      results.push({
+        id: `${interval.id}`,
+        originalId: interval.id,
+        start,
+        end,
+        resourceId: interval.resourceId,
+        resourceIds: interval.resourceIds,
+        title: interval.title,
+        className: interval.className,
+        background: interval.background,
+        isRecurring: false
+      });
+    }
+  }
+  return results;
+}
+function expandRRuleForBlocked(rrule, baseStart, rangeStart, rangeEnd, exdate, maxOccurrences = 365) {
+  const occurrences = [];
+  const exdates = /* @__PURE__ */ new Set();
+  if (exdate) {
+    for (const exd of exdate) {
+      const d = typeof exd === "string" ? new Date(exd) : exd;
+      exdates.add(`${d.getFullYear()}-${d.getMonth()}-${d.getDate()}`);
+    }
+  }
+  const interval = rrule.interval || 1;
+  const until = rrule.until ? typeof rrule.until === "string" ? new Date(rrule.until) : rrule.until : null;
+  const count = rrule.count;
+  let current = new Date(baseStart);
+  let totalCount = 0;
+  const effectiveEnd = until && until < rangeEnd ? until : rangeEnd;
+  const adjustedStart = new Date(rangeStart);
+  adjustedStart.setDate(adjustedStart.getDate() - 7);
+  while (current <= effectiveEnd && totalCount < maxOccurrences) {
+    if (count !== void 0 && totalCount >= count) break;
+    const matchingDates = getMatchingDatesForRRule(current, rrule, baseStart);
+    for (const date of matchingDates) {
+      if (count !== void 0 && totalCount >= count) break;
+      if (date > effectiveEnd) continue;
+      if (date < baseStart) continue;
+      const dateKey = `${date.getFullYear()}-${date.getMonth()}-${date.getDate()}`;
+      if (exdates.has(dateKey)) continue;
+      if (date >= adjustedStart && date <= rangeEnd) {
+        occurrences.push(new Date(date));
+      }
+      totalCount++;
+    }
+    current = advanceToNextPeriod(current, rrule.freq, interval);
+  }
+  return occurrences;
+}
+var WEEKDAY_MAP = {
+  SU: 0,
+  MO: 1,
+  TU: 2,
+  WE: 3,
+  TH: 4,
+  FR: 5,
+  SA: 6
+};
+var WEEKDAY_REVERSE = {
+  0: "SU",
+  1: "MO",
+  2: "TU",
+  3: "WE",
+  4: "TH",
+  5: "FR",
+  6: "SA"
+};
+function getMatchingDatesForRRule(current, rrule, baseStart) {
+  const dates = [];
+  const { freq, byday } = rrule;
+  switch (freq) {
+    case "DAILY": {
+      dates.push(new Date(current));
+      break;
+    }
+    case "WEEKLY": {
+      if (byday && byday.length > 0) {
+        const weekStart = getWeekStart(current, 1);
+        for (let i = 0; i < 7; i++) {
+          const dayDate = addDays(weekStart, i);
+          const dayName = WEEKDAY_REVERSE[dayDate.getDay()];
+          if (byday.includes(dayName)) {
+            const occurrence = new Date(dayDate);
+            occurrence.setHours(baseStart.getHours(), baseStart.getMinutes(), baseStart.getSeconds(), baseStart.getMilliseconds());
+            dates.push(occurrence);
+          }
+        }
+      } else {
+        dates.push(new Date(current));
+      }
+      break;
+    }
+    case "MONTHLY": {
+      if (byday && byday.length > 0) {
+        for (const day of byday) {
+          const parsed = parsePositionalWeekday(day);
+          if (!parsed) continue;
+          const weekday = WEEKDAY_MAP[parsed.weekday];
+          if (parsed.position !== void 0) {
+            const matchDate = getWeekdayOfMonth(current, weekday, parsed.position);
+            if (matchDate) {
+              matchDate.setHours(baseStart.getHours(), baseStart.getMinutes(), baseStart.getSeconds(), baseStart.getMilliseconds());
+              dates.push(matchDate);
+            }
+          }
+        }
+      } else {
+        const dayOfMonth = baseStart.getDate();
+        const daysInMonth = getDaysInMonth(current.getFullYear(), current.getMonth());
+        const actualDay = Math.min(dayOfMonth, daysInMonth);
+        const occurrence = new Date(current.getFullYear(), current.getMonth(), actualDay);
+        occurrence.setHours(baseStart.getHours(), baseStart.getMinutes(), baseStart.getSeconds(), baseStart.getMilliseconds());
+        dates.push(occurrence);
+      }
+      break;
+    }
+    case "YEARLY": {
+      const year = current.getFullYear();
+      const occurrence = new Date(year, baseStart.getMonth(), baseStart.getDate());
+      occurrence.setHours(baseStart.getHours(), baseStart.getMinutes(), baseStart.getSeconds(), baseStart.getMilliseconds());
+      dates.push(occurrence);
+      break;
+    }
+  }
+  return dates;
+}
+function getWeekStart(date, wkst) {
+  const d = new Date(date);
+  const day = d.getDay();
+  const diff = (day - wkst + 7) % 7;
+  d.setDate(d.getDate() - diff);
+  d.setHours(0, 0, 0, 0);
+  return d;
+}
+function advanceToNextPeriod(date, freq, interval) {
+  const result = new Date(date);
+  switch (freq) {
+    case "DAILY":
+      result.setDate(result.getDate() + interval);
+      break;
+    case "WEEKLY":
+      result.setDate(result.getDate() + 7 * interval);
+      break;
+    case "MONTHLY":
+      result.setMonth(result.getMonth() + interval);
+      break;
+    case "YEARLY":
+      result.setFullYear(result.getFullYear() + interval);
+      break;
+    default:
+      result.setDate(result.getDate() + 1);
+  }
+  return result;
+}
+function parsePositionalWeekday(byday) {
+  const match = byday.match(/^(-?\d)?([A-Z]{2})$/);
+  if (!match) return null;
+  const position = match[1] ? parseInt(match[1], 10) : void 0;
+  const weekday = match[2];
+  return { weekday, position };
+}
+function getDaysInMonth(year, month) {
+  return new Date(year, month + 1, 0).getDate();
+}
+function getWeekdayOfMonth(date, weekday, position) {
+  const year = date.getFullYear();
+  const month = date.getMonth();
+  const daysInMonth = getDaysInMonth(year, month);
+  if (position > 0) {
+    let count = 0;
+    for (let day = 1; day <= daysInMonth; day++) {
+      const d = new Date(year, month, day);
+      if (d.getDay() === weekday) {
+        count++;
+        if (count === position) return d;
+      }
+    }
+  } else if (position < 0) {
+    let count = 0;
+    for (let day = daysInMonth; day >= 1; day--) {
+      const d = new Date(year, month, day);
+      if (d.getDay() === weekday) {
+        count--;
+        if (count === position) return d;
+      }
+    }
+  }
+  return null;
+}
+function getExpandedBlockedIntervals(options, rangeStart, rangeEnd) {
+  if (!options || !options.intervals || options.intervals.length === 0) {
+    return [];
+  }
+  const results = [];
+  for (const interval of options.intervals) {
+    const expanded = expandBlockedInterval(interval, rangeStart, rangeEnd);
+    results.push(...expanded);
+  }
+  return results;
+}
+function getBlockedIntervalsForDay(options, date, resourceId) {
+  const dayStart = startOfDay(date);
+  const dayEnd = endOfDay(date);
+  const intervals = getExpandedBlockedIntervals(options, dayStart, dayEnd);
+  if (resourceId !== void 0) {
+    return intervals.filter((interval) => {
+      if (!interval.resourceId && !interval.resourceIds) return true;
+      if (interval.resourceId === resourceId) return true;
+      if (interval.resourceIds && interval.resourceIds.includes(resourceId)) return true;
+      return false;
+    });
+  }
+  return intervals.filter((interval) => !interval.resourceId && !interval.resourceIds);
+}
+function isTimeWithinBlockedInterval(date, options, resourceId) {
+  const intervals = getBlockedIntervalsForDay(options, date, resourceId);
+  return intervals.some((interval) => {
+    return date >= interval.start && date < interval.end;
+  });
+}
+function isRangeWithinBlockedInterval(start, end, options, resourceId) {
+  if (!options || !options.intervals || options.intervals.length === 0) {
+    return false;
+  }
+  const intervals = getExpandedBlockedIntervals(options, start, end);
+  const filteredIntervals = resourceId !== void 0 ? intervals.filter((interval) => !interval.resourceId && !interval.resourceIds || interval.resourceId === resourceId || interval.resourceIds && interval.resourceIds.includes(resourceId)) : intervals.filter((interval) => !interval.resourceId && !interval.resourceIds);
+  return filteredIntervals.some((interval) => {
+    return dateRangesOverlap(start, end, interval.start, interval.end);
+  });
+}
+function canDropWithBlockedIntervals(start, end, _allDay, _view, options, resourceId) {
+  if (!options) return true;
+  if (options.preventDragInto === false && options.allowOverlap === true) {
+    return true;
+  }
+  if (options.preventDragInto !== false) {
+    if (isRangeWithinBlockedInterval(start, end, options, resourceId)) {
+      return false;
+    }
+  }
+  return true;
+}
+function canCreateWithBlockedIntervals(start, end, options, resourceId) {
+  if (!options) return true;
+  if (options.preventCreate === false) return true;
+  return !isRangeWithinBlockedInterval(start, end, options, resourceId);
+}
+
+// src/utils/constraints.ts
+var DEFAULT_BUSINESS_HOURS = {
+  daysOfWeek: [1, 2, 3, 4, 5],
+  startTime: "09:00",
+  endTime: "17:00"
+};
+function normalizeBusinessHours(businessHours) {
+  if (businessHours === false) {
+    return [];
+  }
+  if (businessHours === true) {
+    return [DEFAULT_BUSINESS_HOURS];
+  }
+  if (Array.isArray(businessHours)) {
+    return businessHours;
+  }
+  return [businessHours];
+}
+function isWithinBusinessHours(date, businessHours) {
+  const configs = normalizeBusinessHours(businessHours);
+  if (configs.length === 0) {
+    return true;
+  }
+  const dayOfWeek = date.getDay();
+  const timeMinutes = date.getHours() * 60 + date.getMinutes();
+  return configs.some((config) => {
+    if (!config.daysOfWeek.includes(dayOfWeek)) {
+      return false;
+    }
+    const startMinutes = timeStringToMinutes(config.startTime);
+    const endMinutes = timeStringToMinutes(config.endTime);
+    return timeMinutes >= startMinutes && timeMinutes < endMinutes;
+  });
+}
+function isRangeWithinBusinessHours(start, end, businessHours) {
+  const configs = normalizeBusinessHours(businessHours);
+  if (configs.length === 0) {
+    return true;
+  }
+  const startDayOfWeek = start.getDay();
+  const endDayOfWeek = end.getDay();
+  if (startDayOfWeek !== endDayOfWeek) {
+    return false;
+  }
+  const startMinutes = start.getHours() * 60 + start.getMinutes();
+  const endMinutes = end.getHours() * 60 + end.getMinutes();
+  return configs.some((config) => {
+    if (!config.daysOfWeek.includes(startDayOfWeek)) {
+      return false;
+    }
+    const businessStart = timeStringToMinutes(config.startTime);
+    const businessEnd = timeStringToMinutes(config.endTime);
+    return startMinutes >= businessStart && endMinutes <= businessEnd;
+  });
+}
+function isTimeSlotInBusinessHours(date, slotDuration, businessHours) {
+  const configs = normalizeBusinessHours(businessHours);
+  if (configs.length === 0) {
+    return false;
+  }
+  const dayOfWeek = date.getDay();
+  const slotStartMinutes = date.getHours() * 60 + date.getMinutes();
+  const slotEndMinutes = slotStartMinutes + slotDuration;
+  return configs.some((config) => {
+    if (!config.daysOfWeek.includes(dayOfWeek)) {
+      return false;
+    }
+    const businessStart = timeStringToMinutes(config.startTime);
+    const businessEnd = timeStringToMinutes(config.endTime);
+    return slotStartMinutes >= businessStart && slotEndMinutes <= businessEnd;
+  });
+}
+function getBusinessHoursForDay(dayOfWeek, businessHours) {
+  const configs = normalizeBusinessHours(businessHours);
+  for (const config of configs) {
+    if (config.daysOfWeek.includes(dayOfWeek)) {
+      return {
+        start: config.startTime,
+        end: config.endTime
+      };
+    }
+  }
+  return null;
+}
+function isDateWithinConstraint(date, constraint) {
+  if (!constraint) {
+    return true;
+  }
+  const dayOfWeek = date.getDay();
+  if (constraint.daysOfWeek && !constraint.daysOfWeek.includes(dayOfWeek)) {
+    return false;
+  }
+  const timeMinutes = date.getHours() * 60 + date.getMinutes();
+  if (constraint.startTime) {
+    const startMinutes = timeStringToMinutes(constraint.startTime);
+    if (timeMinutes < startMinutes) {
+      return false;
+    }
+  }
+  if (constraint.endTime) {
+    const endMinutes = timeStringToMinutes(constraint.endTime);
+    if (timeMinutes > endMinutes) {
+      return false;
+    }
+  }
+  return true;
+}
+function canSelect(start, end, allDay, view, selectConstraint, selectAllow) {
+  if (selectConstraint) {
+    if (!isDateWithinConstraint(start, selectConstraint)) {
+      return false;
+    }
+    if (!isDateWithinConstraint(end, selectConstraint)) {
+      return false;
+    }
+  }
+  if (selectAllow) {
+    const selectInfo = { start, end, allDay, view };
+    if (!selectAllow(selectInfo)) {
+      return false;
+    }
+  }
+  return true;
+}
+function canDropEvent(start, end, allDay, view, event, eventConstraint, eventAllow, businessHours, blockedIntervals, resourceId) {
+  if (eventConstraint) {
+    if (eventConstraint === "businessHours") {
+      if (!isRangeWithinBusinessHours(start, end, businessHours)) {
+        return false;
+      }
+    } else if (eventConstraint === "blockedIntervals") {
+      if (isRangeWithinBlockedInterval(start, end, blockedIntervals, resourceId)) {
+        return false;
+      }
+    } else {
+      if (!isDateWithinConstraint(start, eventConstraint)) {
+        return false;
+      }
+      if (!isDateWithinConstraint(end, eventConstraint)) {
+        return false;
+      }
+    }
+  }
+  if (blockedIntervals && blockedIntervals.preventDragInto !== false) {
+    if (isRangeWithinBlockedInterval(start, end, blockedIntervals, resourceId)) {
+      return false;
+    }
+  }
+  if (eventAllow) {
+    const dropInfo = { start, end, allDay, view, resourceId };
+    if (!eventAllow(dropInfo, event)) {
+      return false;
+    }
+  }
+  return true;
+}
+function getTimeSlotBusinessHoursInfo(date, slotDuration, businessHours) {
+  const configs = normalizeBusinessHours(businessHours);
+  if (configs.length === 0) {
+    return { isBusinessHour: false, isBusinessStart: false, isBusinessEnd: false };
+  }
+  const dayOfWeek = date.getDay();
+  const slotStartMinutes = date.getHours() * 60 + date.getMinutes();
+  const slotEndMinutes = slotStartMinutes + slotDuration;
+  for (const config of configs) {
+    if (!config.daysOfWeek.includes(dayOfWeek)) {
+      continue;
+    }
+    const businessStart = timeStringToMinutes(config.startTime);
+    const businessEnd = timeStringToMinutes(config.endTime);
+    const isWithin = slotStartMinutes >= businessStart && slotEndMinutes <= businessEnd;
+    if (isWithin) {
+      return {
+        isBusinessHour: true,
+        isBusinessStart: slotStartMinutes === businessStart,
+        isBusinessEnd: slotEndMinutes === businessEnd
+      };
+    }
+  }
+  return { isBusinessHour: false, isBusinessStart: false, isBusinessEnd: false };
+}
+
+export { DEFAULT_BUSINESS_HOURS, canCreateWithBlockedIntervals, canDropEvent, canDropWithBlockedIntervals, canSelect, expandBlockedInterval, getBlockedIntervalDisplayLabels, getBlockedIntervalsForDay, getBusinessHoursForDay, getExpandedBlockedIntervals, getTimeSlotBusinessHoursInfo, isDateWithinConstraint, isRangeWithinBlockedInterval, isRangeWithinBusinessHours, isTimeSlotInBusinessHours, isTimeWithinBlockedInterval, isWithinBusinessHours, normalizeBusinessHours };