@primeui/scheduler-core 0.0.1-alpha.1

package/dist/chunk-AAVM7UCG.mjs

@@ -0,0 +1,100 @@
+import { normalizeBusinessHours, getBlockedIntervalsForDay } from './chunk-HPC5B3AR.mjs';
+import { timeStringToMinutes, minutesToPixels } from './chunk-WFUJWDST.mjs';
+
+// src/utils/overlay.ts
+function getTimedBusinessHoursOverlays(date, businessHours, slotMinTime, slotMaxTime, slotDuration, slotHeight) {
+  const configs = normalizeBusinessHours(businessHours);
+  if (configs.length === 0) return [];
+  const dayOfWeek = date.getDay();
+  const config = configs.find((c) => c.daysOfWeek.includes(dayOfWeek));
+  const overlays = [];
+  const slotMinMinutes = timeStringToMinutes(slotMinTime);
+  const slotMaxMinutes = timeStringToMinutes(slotMaxTime);
+  const pushOverlay = (startMinutes, endMinutes) => {
+    const clampedStart = Math.max(startMinutes, slotMinMinutes);
+    const clampedEnd = Math.min(endMinutes, slotMaxMinutes);
+    if (clampedStart >= clampedEnd) return;
+    const top = minutesToPixels(clampedStart - slotMinMinutes, slotDuration, slotHeight);
+    const height = minutesToPixels(clampedEnd - clampedStart, slotDuration, slotHeight);
+    overlays.push({
+      position: "absolute",
+      top: top === 0 ? "0" : `${top}px`,
+      left: "0",
+      right: "0",
+      height: `${height}px`,
+      pointerEvents: "none",
+      zIndex: "0"
+    });
+  };
+  if (!config) {
+    pushOverlay(slotMinMinutes, slotMaxMinutes);
+    return overlays;
+  }
+  const businessStartMinutes = timeStringToMinutes(config.startTime);
+  const businessEndMinutes = timeStringToMinutes(config.endTime);
+  pushOverlay(slotMinMinutes, businessStartMinutes);
+  pushOverlay(businessEndMinutes, slotMaxMinutes);
+  return overlays;
+}
+function getTimedBlockedIntervalsOverlays(date, blockedIntervals, slotMinTime, slotMaxTime, slotDuration, slotHeight, resourceId) {
+  if (!blockedIntervals) return [];
+  const intervals = getBlockedIntervalsForDay(blockedIntervals, date, resourceId);
+  if (intervals.length === 0) return [];
+  const overlays = [];
+  const slotMinMinutes = timeStringToMinutes(slotMinTime);
+  const slotMaxMinutes = timeStringToMinutes(slotMaxTime);
+  for (const interval of intervals) {
+    const intervalStartMinutes = interval.start.getHours() * 60 + interval.start.getMinutes();
+    const intervalEndMinutes = interval.end.getHours() * 60 + interval.end.getMinutes();
+    const clampedStart = Math.max(intervalStartMinutes, slotMinMinutes);
+    const clampedEnd = Math.min(intervalEndMinutes, slotMaxMinutes);
+    if (clampedStart >= clampedEnd) continue;
+    const top = minutesToPixels(clampedStart - slotMinMinutes, slotDuration, slotHeight);
+    const height = minutesToPixels(clampedEnd - clampedStart, slotDuration, slotHeight);
+    const style = {
+      position: "absolute",
+      top: `${top}px`,
+      left: "0",
+      right: "0",
+      height: `${height}px`,
+      pointerEvents: "none",
+      zIndex: "2"
+    };
+    if (interval.background) {
+      style.background = interval.background;
+    }
+    overlays.push({
+      style,
+      title: interval.title,
+      className: interval.className,
+      interval
+    });
+  }
+  return overlays;
+}
+function isSlotInBusinessHours(slotTime, date, businessHours) {
+  if (!businessHours) return false;
+  const configs = normalizeBusinessHours(businessHours);
+  if (configs.length === 0) return false;
+  const dayOfWeek = date.getDay();
+  const config = configs.find((c) => c.daysOfWeek.includes(dayOfWeek));
+  if (!config) return false;
+  const slotMinutes = slotTime.getHours() * 60 + slotTime.getMinutes();
+  const bhStart = timeStringToMinutes(config.startTime);
+  const bhEnd = timeStringToMinutes(config.endTime);
+  return slotMinutes >= bhStart && slotMinutes < bhEnd;
+}
+function isSlotInBlockedInterval(slotTime, date, slotDuration, blockedIntervals, resourceId) {
+  if (!blockedIntervals) return false;
+  const intervals = getBlockedIntervalsForDay(blockedIntervals, date, resourceId);
+  if (intervals.length === 0) return false;
+  const slotMinutes = slotTime.getHours() * 60 + slotTime.getMinutes();
+  const slotEndMinutes = slotMinutes + slotDuration;
+  return intervals.some((interval) => {
+    const intStart = interval.start.getHours() * 60 + interval.start.getMinutes();
+    const intEnd = interval.end.getHours() * 60 + interval.end.getMinutes();
+    return slotMinutes < intEnd && slotEndMinutes > intStart;
+  });
+}
+
+export { getTimedBlockedIntervalsOverlays, getTimedBusinessHoursOverlays, isSlotInBlockedInterval, isSlotInBusinessHours };

package/dist/chunk-C7ADJGNV.mjs

@@ -0,0 +1,157 @@
+// src/utils/event-categories.ts
+var SCHEDULER_AUTO_TEXT_COLOR_KEY = "__primeuiSchedulerAutoTextColor";
+var DEFAULT_CATEGORY_OPTIONS = {
+  categories: [],
+  categoryField: "categoryId",
+  allowMultiple: false,
+  showLegend: true,
+  legendPosition: "top",
+  filterByCategory: false
+};
+function normalizeCategoryOptions(options) {
+  if (!options) {
+    return { ...DEFAULT_CATEGORY_OPTIONS };
+  }
+  return { ...DEFAULT_CATEGORY_OPTIONS, ...options };
+}
+function getCategoryById(categories, id) {
+  if (id === void 0) return void 0;
+  return categories.find((cat) => cat.id === id);
+}
+function getCategoriesByIds(categories, ids) {
+  if (!ids || ids.length === 0) return [];
+  return categories.filter((cat) => ids.includes(cat.id));
+}
+function getEventCategory(event, categories, categoryField = "categoryId") {
+  const categoryId = event[categoryField];
+  return getCategoryById(categories, categoryId);
+}
+function getEventCategories(event, categories, categoryField = "categoryId", allowMultiple = false) {
+  if (allowMultiple) {
+    const categoryIds = event[`${categoryField}s`];
+    if (categoryIds && categoryIds.length > 0) {
+      return getCategoriesByIds(categories, categoryIds);
+    }
+  }
+  const category = getEventCategory(event, categories, categoryField);
+  return category ? [category] : [];
+}
+function getEventCategoryColor(event, categories, categoryField = "categoryId") {
+  if (event.color) return event.color;
+  const category = getEventCategory(event, categories, categoryField);
+  return category?.color;
+}
+function getEventCategoryTextColor(event, categories, categoryField = "categoryId") {
+  if (event.textColor) return event.textColor;
+  const category = getEventCategory(event, categories, categoryField);
+  return category?.textColor;
+}
+function getEventCategoryBorderColor(event, categories, categoryField = "categoryId") {
+  if (event.borderColor) return event.borderColor;
+  const category = getEventCategory(event, categories, categoryField);
+  return category?.borderColor || category?.color;
+}
+function getEventCategoryIcon(event, categories, categoryField = "categoryId") {
+  const category = getEventCategory(event, categories, categoryField);
+  return category?.icon;
+}
+function getEventCategoryStyle(event, categories, categoryField = "categoryId") {
+  const style = {};
+  const category = getEventCategory(event, categories, categoryField);
+  const bgColor = event.color || category?.color;
+  const textColor = event.textColor || category?.textColor;
+  const borderColor = event.borderColor || category?.borderColor || bgColor;
+  if (bgColor) {
+    style.background = bgColor;
+    style.borderLeftColor = borderColor;
+  }
+  if (textColor) {
+    style.color = textColor;
+  }
+  if (borderColor) {
+    style.borderColor = borderColor;
+  }
+  return style;
+}
+function filterEventsByCategory(events, categoryIds, categories, categoryField = "categoryId", allowMultiple = false) {
+  if (categoryIds.length === 0) return events;
+  return events.filter((event) => {
+    const eventCategories = getEventCategories(event, categories, categoryField, allowMultiple);
+    return eventCategories.some((cat) => categoryIds.includes(cat.id));
+  });
+}
+function filterEventsByCategoryExclude(events, excludeCategoryIds, categories, categoryField = "categoryId", allowMultiple = false) {
+  if (excludeCategoryIds.length === 0) return events;
+  return events.filter((event) => {
+    const eventCategories = getEventCategories(event, categories, categoryField, allowMultiple);
+    return !eventCategories.some((cat) => excludeCategoryIds.includes(cat.id));
+  });
+}
+function groupEventsByCategory(events, categories, categoryField = "categoryId") {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const category of categories) {
+    grouped.set(category.id, []);
+  }
+  grouped.set("uncategorized", []);
+  for (const event of events) {
+    const categoryId = event[categoryField];
+    if (categoryId !== void 0 && grouped.has(categoryId)) {
+      grouped.get(categoryId).push(event);
+    } else {
+      grouped.get("uncategorized").push(event);
+    }
+  }
+  return grouped;
+}
+function getCategoryCounts(events, categories, categoryField = "categoryId") {
+  const counts = /* @__PURE__ */ new Map();
+  for (const category of categories) {
+    counts.set(category.id, 0);
+  }
+  for (const event of events) {
+    const categoryId = event[categoryField];
+    if (categoryId !== void 0 && counts.has(categoryId)) {
+      counts.set(categoryId, counts.get(categoryId) + 1);
+    }
+  }
+  return counts;
+}
+function getSortedCategories(categories) {
+  return [...categories].sort((a, b) => {
+    const orderA = a.sortOrder ?? Number.MAX_SAFE_INTEGER;
+    const orderB = b.sortOrder ?? Number.MAX_SAFE_INTEGER;
+    if (orderA !== orderB) return orderA - orderB;
+    return a.name.localeCompare(b.name);
+  });
+}
+function calculateContrastTextColor(backgroundColor) {
+  const hex = backgroundColor.replace("#", "");
+  const r = parseInt(hex.substring(0, 2), 16);
+  const g = parseInt(hex.substring(2, 4), 16);
+  const b = parseInt(hex.substring(4, 6), 16);
+  const luminance = (0.299 * r + 0.587 * g + 0.114 * b) / 255;
+  return luminance > 0.5 ? "#000000" : "#ffffff";
+}
+function getCategoryWithAutoTextColor(category) {
+  if (category.textColor) return category;
+  return {
+    ...category,
+    textColor: calculateContrastTextColor(category.color)
+  };
+}
+function getCategoriesWithAutoTextColor(categories) {
+  return categories.map(getCategoryWithAutoTextColor);
+}
+function markSchedulerAutoTextColor(event) {
+  Object.defineProperty(event, SCHEDULER_AUTO_TEXT_COLOR_KEY, {
+    value: true,
+    enumerable: true,
+    configurable: true
+  });
+  return event;
+}
+function isSchedulerAutoTextColor(event) {
+  return Boolean(event && event[SCHEDULER_AUTO_TEXT_COLOR_KEY] === true);
+}
+
+export { DEFAULT_CATEGORY_OPTIONS, calculateContrastTextColor, filterEventsByCategory, filterEventsByCategoryExclude, getCategoriesByIds, getCategoriesWithAutoTextColor, getCategoryById, getCategoryCounts, getCategoryWithAutoTextColor, getEventCategories, getEventCategory, getEventCategoryBorderColor, getEventCategoryColor, getEventCategoryIcon, getEventCategoryStyle, getEventCategoryTextColor, getSortedCategories, groupEventsByCategory, isSchedulerAutoTextColor, markSchedulerAutoTextColor, normalizeCategoryOptions };

package/dist/chunk-DYW6WUHE.mjs

@@ -0,0 +1,277 @@
+import { GregorianCalendar, toCalendar, CalendarDate, TaiwanCalendar, PersianCalendar, JapaneseCalendar, IslamicUmalquraCalendar, IslamicTabularCalendar, IslamicCivilCalendar, IndianCalendar, HebrewCalendar, CopticCalendar, EthiopicAmeteAlemCalendar, EthiopicCalendar, BuddhistCalendar } from '@internationalized/date';
+
+// src/calendar/index.ts
+var schedulerInternationalCalendarIds = ["gregory", "buddhist", "ethiopic", "ethioaa", "coptic", "hebrew", "indian", "islamic-civil", "islamic-tbla", "islamic-umalqura", "japanese", "persian", "roc"];
+var supportedCalendarIds = new Set(schedulerInternationalCalendarIds);
+var calendarAdaptedViews = /* @__PURE__ */ new Set([
+  "month",
+  "year",
+  "dateDay",
+  "dateWeek",
+  "dateMonth",
+  "resourceMonth",
+  "day",
+  "week",
+  "resourceDay",
+  "resourceWeek",
+  "agenda",
+  "timelineDay",
+  "timelineWeek",
+  "timelineMonth",
+  "timelineYear",
+  "resourceTimelineDay",
+  "resourceTimelineWeek",
+  "resourceTimelineMonth"
+]);
+var gregorianInternationalCalendar = new GregorianCalendar();
+function toGregorianDate(date) {
+  return new Date(date.year, date.month - 1, date.day);
+}
+function fromGregorianDate(date) {
+  return {
+    year: date.getFullYear(),
+    month: date.getMonth() + 1,
+    day: date.getDate()
+  };
+}
+function addMonths(date, amount) {
+  const next = new Date(date);
+  const day = next.getDate();
+  next.setMonth(next.getMonth() + amount);
+  if (next.getDate() !== day) {
+    next.setDate(0);
+  }
+  return next;
+}
+var gregorianCalendarAdapter = {
+  id: "gregory",
+  fromDate: fromGregorianDate,
+  toDate: toGregorianDate,
+  add(date, duration) {
+    let next = toGregorianDate(date);
+    if (duration.years) {
+      next.setFullYear(next.getFullYear() + duration.years);
+    }
+    if (duration.months) {
+      next = addMonths(next, duration.months);
+    }
+    if (duration.days) {
+      next.setDate(next.getDate() + duration.days);
+    }
+    return fromGregorianDate(next);
+  },
+  startOfMonth(date) {
+    return { year: date.year, month: date.month, day: 1 };
+  },
+  endOfMonth(date) {
+    return { year: date.year, month: date.month, day: this.getDaysInMonth(date) };
+  },
+  startOfWeek(date, firstDayOfWeek) {
+    const dayOfWeek = this.getDayOfWeek(date);
+    const diff = (dayOfWeek - firstDayOfWeek + 7) % 7;
+    return this.add(date, { days: -diff });
+  },
+  getDayOfWeek(date) {
+    return toGregorianDate(date).getDay();
+  },
+  getDaysInMonth(date) {
+    return new Date(date.year, date.month, 0).getDate();
+  },
+  getMonthsInYear() {
+    return 12;
+  },
+  compare(a, b) {
+    return toGregorianDate(a).getTime() - toGregorianDate(b).getTime();
+  },
+  isSameDay(a, b) {
+    return a.year === b.year && a.month === b.month && a.day === b.day;
+  }
+};
+function isSupportedInternationalCalendarId(calendarId) {
+  return supportedCalendarIds.has(calendarId);
+}
+function resolveLocaleCalendarId(locale) {
+  try {
+    return new Intl.DateTimeFormat(locale).resolvedOptions().calendar || "gregory";
+  } catch {
+    return "gregory";
+  }
+}
+function resolveSchedulerCalendarId(calendar = "gregory", options = {}) {
+  const locale = options.locale || "en";
+  const calendarId = calendar === "locale" ? resolveLocaleCalendarId(locale) : calendar;
+  const isSupported = Boolean(options.createCalendar) || isSupportedInternationalCalendarId(calendarId);
+  return {
+    requestedCalendar: calendar,
+    locale,
+    calendarId: isSupported ? calendarId : "gregory",
+    isSupported,
+    fallbackCalendarId: isSupported ? null : "gregory"
+  };
+}
+function isCalendarAdapterCorrectView(view) {
+  return Boolean(view && calendarAdaptedViews.has(view));
+}
+function resolveSchedulerCalendarModeForView(calendar, view) {
+  if (!calendar || calendar === "gregory") {
+    return "gregory";
+  }
+  if (!view) {
+    return calendar;
+  }
+  return isCalendarAdapterCorrectView(view) ? calendar : "gregory";
+}
+function getCalendarInteractionAdapter(options = {}) {
+  const mode = resolveSchedulerCalendarModeForView(options.calendar ?? "gregory", options.view);
+  return getSchedulerCalendarAdapter(mode, { locale: options.locale });
+}
+function copyTime(source, target) {
+  const result = new Date(target);
+  result.setHours(source.getHours(), source.getMinutes(), source.getSeconds(), source.getMilliseconds());
+  return result;
+}
+function localDayStart(date) {
+  return new Date(date.getFullYear(), date.getMonth(), date.getDate());
+}
+function moveDateToCalendarDay(sourceDate, targetDay, options = {}) {
+  const source = new Date(sourceDate);
+  const adapter = getCalendarInteractionAdapter(options);
+  const targetCalendarDate = adapter.fromDate(targetDay);
+  return copyTime(source, adapter.toDate(targetCalendarDate));
+}
+function addCalendarDaysToDate(sourceDate, days, options = {}) {
+  const source = new Date(sourceDate);
+  if (days === 0) {
+    return new Date(source);
+  }
+  const adapter = getCalendarInteractionAdapter(options);
+  const sourceCalendarDate = adapter.fromDate(source);
+  const targetCalendarDate = adapter.add(sourceCalendarDate, { days });
+  return copyTime(source, adapter.toDate(targetCalendarDate));
+}
+function differenceInCalendarDays(startDate, endDate, options = {}) {
+  const adapter = getCalendarInteractionAdapter(options);
+  const startCalendarDate = adapter.fromDate(startDate);
+  const endCalendarDate = adapter.fromDate(endDate);
+  if (adapter.isSameDay(startCalendarDate, endCalendarDate)) {
+    return 0;
+  }
+  let days = Math.round((localDayStart(endDate).getTime() - localDayStart(startDate).getTime()) / (24 * 60 * 60 * 1e3));
+  let candidate = adapter.add(startCalendarDate, { days });
+  while (adapter.compare(candidate, endCalendarDate) < 0) {
+    days += 1;
+    candidate = adapter.add(startCalendarDate, { days });
+  }
+  while (adapter.compare(candidate, endCalendarDate) > 0) {
+    days -= 1;
+    candidate = adapter.add(startCalendarDate, { days });
+  }
+  return days;
+}
+function createBuiltInInternationalCalendar(calendarId) {
+  switch (calendarId) {
+    case "buddhist":
+      return new BuddhistCalendar();
+    case "ethiopic":
+      return new EthiopicCalendar();
+    case "ethioaa":
+      return new EthiopicAmeteAlemCalendar();
+    case "coptic":
+      return new CopticCalendar();
+    case "hebrew":
+      return new HebrewCalendar();
+    case "indian":
+      return new IndianCalendar();
+    case "islamic-civil":
+      return new IslamicCivilCalendar();
+    case "islamic-tbla":
+      return new IslamicTabularCalendar();
+    case "islamic-umalqura":
+      return new IslamicUmalquraCalendar();
+    case "japanese":
+      return new JapaneseCalendar();
+    case "persian":
+      return new PersianCalendar();
+    case "roc":
+      return new TaiwanCalendar();
+    case "gregory":
+    default:
+      return new GregorianCalendar();
+  }
+}
+function toSchedulerCalendarDate(date) {
+  return {
+    era: date.era,
+    year: date.year,
+    month: date.month,
+    day: date.day
+  };
+}
+function toInternationalizedCalendarDate(date, calendar) {
+  return date.era ? new CalendarDate(calendar, date.era, date.year, date.month, date.day) : new CalendarDate(calendar, date.year, date.month, date.day);
+}
+function toLocalDateFromGregorianCalendarDate(date) {
+  return new Date(date.year, date.month - 1, date.day);
+}
+function createInternationalizedSchedulerCalendarAdapter(id, calendar) {
+  return {
+    id,
+    fromDate(date) {
+      const gregorianDate = new CalendarDate(gregorianInternationalCalendar, date.getFullYear(), date.getMonth() + 1, date.getDate());
+      return toSchedulerCalendarDate(toCalendar(gregorianDate, calendar));
+    },
+    toDate(date) {
+      const calendarDate = toInternationalizedCalendarDate(date, calendar);
+      const gregorianDate = toCalendar(calendarDate, gregorianInternationalCalendar);
+      return toLocalDateFromGregorianCalendarDate(gregorianDate);
+    },
+    add(date, duration) {
+      return toSchedulerCalendarDate(toInternationalizedCalendarDate(date, calendar).add(duration));
+    },
+    startOfMonth(date) {
+      const calendarDate = toInternationalizedCalendarDate(date, calendar);
+      return toSchedulerCalendarDate(calendarDate.set({ day: calendar.getMinimumDayInMonth?.(calendarDate) ?? 1 }));
+    },
+    endOfMonth(date) {
+      const calendarDate = toInternationalizedCalendarDate(date, calendar);
+      return toSchedulerCalendarDate(calendarDate.set({ day: calendar.getDaysInMonth(calendarDate) }));
+    },
+    startOfWeek(date, firstDayOfWeek) {
+      const dayOfWeek = this.getDayOfWeek(date);
+      const diff = (dayOfWeek - firstDayOfWeek + 7) % 7;
+      return this.add(date, { days: -diff });
+    },
+    getDayOfWeek(date) {
+      return this.toDate(date).getDay();
+    },
+    getDaysInMonth(date) {
+      return calendar.getDaysInMonth(toInternationalizedCalendarDate(date, calendar));
+    },
+    getMonthsInYear(date) {
+      return calendar.getMonthsInYear(toInternationalizedCalendarDate(date, calendar));
+    },
+    compare(a, b) {
+      return toInternationalizedCalendarDate(a, calendar).compare(toInternationalizedCalendarDate(b, calendar));
+    },
+    isSameDay(a, b) {
+      return this.compare(a, b) === 0;
+    }
+  };
+}
+function getSchedulerCalendarAdapter(calendar, options = {}) {
+  const requestedCalendar = calendar ?? "gregory";
+  const resolution = resolveSchedulerCalendarId(requestedCalendar, options);
+  const customCalendar = options.createCalendar?.(requestedCalendar === "locale" ? resolution.calendarId : requestedCalendar);
+  if (customCalendar) {
+    return createInternationalizedSchedulerCalendarAdapter(requestedCalendar === "locale" ? resolution.calendarId : requestedCalendar, customCalendar);
+  }
+  if (resolution.calendarId === "gregory") {
+    return gregorianCalendarAdapter;
+  }
+  if (!isSupportedInternationalCalendarId(resolution.calendarId)) {
+    return gregorianCalendarAdapter;
+  }
+  return createInternationalizedSchedulerCalendarAdapter(resolution.calendarId, createBuiltInInternationalCalendar(resolution.calendarId));
+}
+
+export { addCalendarDaysToDate, differenceInCalendarDays, getSchedulerCalendarAdapter, gregorianCalendarAdapter, isCalendarAdapterCorrectView, moveDateToCalendarDay, resolveSchedulerCalendarId, resolveSchedulerCalendarModeForView, schedulerInternationalCalendarIds };