@primeui/scheduler-core 0.0.1-alpha.1

package/dist/chunk-TNKJPFGI.mjs

@@ -0,0 +1,569 @@
+import { resolveSchedulerCalendarModeForView, getSchedulerCalendarAdapter } from './chunk-DYW6WUHE.mjs';
+
+// src/utils/display-format.ts
+var DEFAULT_TIME_FORMAT_OPTIONS = {
+  format: "auto",
+  showAMPM: true,
+  showMinutes: "always",
+  showSeconds: false,
+  rangeDisplay: "full",
+  use24HourSlots: false
+};
+var DEFAULT_DATE_DISPLAY_OPTIONS = {
+  weekdayFormat: "short",
+  monthFormat: "long",
+  dayFormat: "numeric",
+  showYear: "different",
+  relativeTime: false
+};
+var DEFAULT_DISPLAY_OPTIONS = {
+  time: DEFAULT_TIME_FORMAT_OPTIONS,
+  date: DEFAULT_DATE_DISPLAY_OPTIONS
+};
+var DATE_TIME_FORMATTER_CACHE_LIMIT = 512;
+var dateTimeFormatterCache = /* @__PURE__ */ new Map();
+var localeHour12Cache = /* @__PURE__ */ new Map();
+function normalizeTimeFormatOptions(options) {
+  if (!options) {
+    return { ...DEFAULT_TIME_FORMAT_OPTIONS };
+  }
+  return {
+    ...DEFAULT_TIME_FORMAT_OPTIONS,
+    ...options
+  };
+}
+function normalizeDateDisplayOptions(options) {
+  if (!options) {
+    return { ...DEFAULT_DATE_DISPLAY_OPTIONS };
+  }
+  return {
+    ...DEFAULT_DATE_DISPLAY_OPTIONS,
+    ...options
+  };
+}
+function normalizeDisplayOptions(options) {
+  if (!options) {
+    return { ...DEFAULT_DISPLAY_OPTIONS };
+  }
+  return {
+    time: normalizeTimeFormatOptions(options.time),
+    date: normalizeDateDisplayOptions(options.date)
+  };
+}
+function is12HourLocale(locale) {
+  const cached = localeHour12Cache.get(locale);
+  if (typeof cached === "boolean") {
+    return cached;
+  }
+  let result = false;
+  try {
+    const resolved = new Intl.DateTimeFormat(locale, { hour: "numeric" }).resolvedOptions();
+    if (typeof resolved.hour12 === "boolean") {
+      result = resolved.hour12;
+      localeHour12Cache.set(locale, result);
+      return result;
+    }
+    if (resolved.hourCycle) {
+      result = resolved.hourCycle === "h11" || resolved.hourCycle === "h12";
+      localeHour12Cache.set(locale, result);
+      return result;
+    }
+  } catch {
+  }
+  const testDate = new Date(Date.UTC(2e3, 0, 1, 13, 0, 0));
+  try {
+    const parts = new Intl.DateTimeFormat(locale, {
+      hour: "numeric",
+      minute: "2-digit"
+    }).formatToParts(testDate);
+    result = parts.some((part) => part.type === "dayPeriod");
+    localeHour12Cache.set(locale, result);
+    return result;
+  } catch {
+    const formatted = testDate.toLocaleTimeString(locale, { hour: "numeric", minute: "2-digit" });
+    result = /(^|\s)[AP]\.?M\.?($|\s)/i.test(formatted);
+    localeHour12Cache.set(locale, result);
+    return result;
+  }
+}
+function getEffectiveTimeFormat(format, locale) {
+  if (format === "auto") {
+    return is12HourLocale(locale) ? "12h" : "24h";
+  }
+  return format;
+}
+function getDateTimeFormatter(locale, options) {
+  const normalizedOptions = Object.keys(options).sort().map((key2) => `${key2}:${String(options[key2])}`).join("|");
+  const key = `${locale}__${normalizedOptions}`;
+  const cached = dateTimeFormatterCache.get(key);
+  if (cached) {
+    return cached;
+  }
+  const formatter = new Intl.DateTimeFormat(locale, options);
+  dateTimeFormatterCache.set(key, formatter);
+  if (dateTimeFormatterCache.size > DATE_TIME_FORMATTER_CACHE_LIMIT) {
+    const oldestKey = dateTimeFormatterCache.keys().next().value;
+    if (oldestKey) {
+      dateTimeFormatterCache.delete(oldestKey);
+    }
+  }
+  return formatter;
+}
+function isSupportedCalendar(locale, calendar) {
+  try {
+    const resolved = new Intl.DateTimeFormat(locale, { calendar }).resolvedOptions();
+    return resolved.calendar === calendar;
+  } catch {
+    return false;
+  }
+}
+function isSupportedNumberingSystem(locale, numberingSystem) {
+  try {
+    const resolved = new Intl.DateTimeFormat(locale, { numberingSystem }).resolvedOptions();
+    return resolved.numberingSystem === numberingSystem;
+  } catch {
+    return false;
+  }
+}
+function resolveSchedulerCalendarDisplayConfig(input = {}) {
+  const locale = input.locale || "en";
+  const requestedCalendar = resolveSchedulerCalendarModeForView(input.calendar ?? "gregory", input.view);
+  const calendar = requestedCalendar === "locale" ? "locale" : isSupportedCalendar(locale, requestedCalendar) ? requestedCalendar : "gregory";
+  const requestedNumberingSystem = input.numberingSystem;
+  const numberingSystem = requestedNumberingSystem && requestedNumberingSystem !== "locale" && isSupportedNumberingSystem(locale, requestedNumberingSystem) ? requestedNumberingSystem : void 0;
+  return {
+    locale,
+    calendar,
+    numberingSystem,
+    timeZone: input.timeZone
+  };
+}
+function createCalendarIntlOptions(config, options = {}) {
+  const intlOptions = { ...options };
+  if (config.calendar !== "locale") {
+    intlOptions.calendar = config.calendar;
+  }
+  if (config.numberingSystem) {
+    intlOptions.numberingSystem = config.numberingSystem;
+  }
+  if (config.timeZone && !intlOptions.timeZone) {
+    intlOptions.timeZone = config.timeZone;
+  }
+  return intlOptions;
+}
+function createNumberFormatter(config) {
+  const options = {};
+  if (config.numberingSystem) {
+    options.numberingSystem = config.numberingSystem;
+  }
+  return new Intl.NumberFormat(config.locale, options);
+}
+function formatDayPart(formatter, date) {
+  const dayPart = formatter.formatToParts(date).find((part) => part.type === "day");
+  return dayPart?.value ?? formatter.format(date);
+}
+function formatWeekdayDayParts(formatter, date) {
+  const parts = formatter.formatToParts(date).filter((part) => part.type === "day" || part.type === "weekday").map((part) => part.value);
+  return parts.length ? parts.join(" ") : formatter.format(date);
+}
+function createSchedulerDateFormatter(input = {}) {
+  const config = resolveSchedulerCalendarDisplayConfig(input);
+  return {
+    config,
+    format(date, options = {}) {
+      return getDateTimeFormatter(config.locale, createCalendarIntlOptions(config, options)).format(date);
+    },
+    formatDayNumber(date, format = "numeric") {
+      return formatDayPart(getDateTimeFormatter(config.locale, createCalendarIntlOptions(config, { day: format })), date);
+    },
+    formatWeekdayDayNumber(date, weekday = "short", day = "numeric") {
+      return formatWeekdayDayParts(getDateTimeFormatter(config.locale, createCalendarIntlOptions(config, { weekday, day })), date);
+    },
+    formatWeekday(date, width = "short") {
+      return getDateTimeFormatter(config.locale, createCalendarIntlOptions(config, { weekday: width })).format(date);
+    },
+    formatMonth(date, format = "long") {
+      return getDateTimeFormatter(config.locale, createCalendarIntlOptions(config, { month: format })).format(date);
+    },
+    formatMonthTitle(date, options = {}) {
+      return getDateTimeFormatter(config.locale, createCalendarIntlOptions(config, { month: "long", year: "numeric", ...options })).format(date);
+    },
+    formatYear(date) {
+      return getDateTimeFormatter(config.locale, createCalendarIntlOptions(config, { year: "numeric" })).format(date);
+    },
+    formatNumber(value) {
+      return createNumberFormatter(config).format(value);
+    }
+  };
+}
+function normalizeFormattedTime(value) {
+  return value.replace(/\u200e|\u200f/g, "").replace(/\s+/g, " ").trim();
+}
+function formatPartsWithoutDayPeriod(parts) {
+  const withoutDayPeriod = parts.filter((part) => part.type !== "dayPeriod");
+  const merged = withoutDayPeriod.map((part) => part.value).join("");
+  return normalizeFormattedTime(merged);
+}
+function getDisplayMinutes(date, timeZone) {
+  if (!timeZone) {
+    return date.getMinutes();
+  }
+  const minuteFormatter = getDateTimeFormatter("en-US", {
+    minute: "numeric",
+    timeZone
+  });
+  const parts = minuteFormatter.formatToParts(date);
+  const minutePart = parts.find((part) => part.type === "minute")?.value;
+  const parsed = Number(minutePart);
+  if (Number.isFinite(parsed)) {
+    return parsed;
+  }
+  return date.getMinutes();
+}
+function shouldIncludeMinutes(date, options, timeZone) {
+  if (options.showMinutes === "always") {
+    return true;
+  }
+  return getDisplayMinutes(date, timeZone) !== 0;
+}
+function resolveHour12(options, locale, force24HourSlots = false) {
+  if (force24HourSlots) {
+    return false;
+  }
+  const effectiveFormat = getEffectiveTimeFormat(options.format, locale);
+  return effectiveFormat === "12h";
+}
+function createTimeIntlOptions(hour12, includeMinutes, showSeconds, timeZone) {
+  const intlOptions = {
+    hour: "numeric",
+    hour12
+  };
+  if (timeZone) {
+    intlOptions.timeZone = timeZone;
+  }
+  if (includeMinutes) {
+    intlOptions.minute = "2-digit";
+  }
+  if (showSeconds) {
+    intlOptions.second = "2-digit";
+  }
+  return intlOptions;
+}
+function formatTimeWithFormatter(date, formatter, hour12, showAMPM) {
+  if (hour12 && !showAMPM) {
+    return formatPartsWithoutDayPeriod(formatter.formatToParts(date));
+  }
+  return normalizeFormattedTime(formatter.format(date));
+}
+function formatTimeRangeFull(start, end, locale, options, timeZone) {
+  const startTime = formatTime(start, locale, options, timeZone);
+  const endTime = formatTime(end, locale, options, timeZone);
+  return `${startTime} - ${endTime}`;
+}
+function formatTimeRangeCompact(start, end, locale, options, timeZone) {
+  const hour12 = resolveHour12(options, locale);
+  const includeMinutes = options.showMinutes === "always" || options.showMinutes === "non-zero" && (getDisplayMinutes(start, timeZone) !== 0 || getDisplayMinutes(end, timeZone) !== 0);
+  const intlOptions = createTimeIntlOptions(hour12, includeMinutes, options.showSeconds, timeZone);
+  const formatter = getDateTimeFormatter(locale, intlOptions);
+  const startTime = formatTimeWithFormatter(start, formatter, hour12, options.showAMPM);
+  const endTime = formatTimeWithFormatter(end, formatter, hour12, options.showAMPM);
+  if (!hour12 || !options.showAMPM) {
+    return `${startTime}-${endTime}`;
+  }
+  const startParts = formatter.formatToParts(start);
+  const endParts = formatter.formatToParts(end);
+  const startPeriod = startParts.find((part) => part.type === "dayPeriod")?.value;
+  const endPeriod = endParts.find((part) => part.type === "dayPeriod")?.value;
+  if (!startPeriod || !endPeriod || startPeriod !== endPeriod) {
+    return `${startTime}-${endTime}`;
+  }
+  const startWithoutPeriod = formatPartsWithoutDayPeriod(startParts);
+  const endWithPeriod = normalizeFormattedTime(formatter.format(end));
+  return `${startWithoutPeriod}-${endWithPeriod}`;
+}
+function formatTimeRangeLocale(start, end, locale, options, timeZone) {
+  const hour12 = resolveHour12(options, locale);
+  const includeMinutes = options.showMinutes === "always" || options.showMinutes === "non-zero" && (getDisplayMinutes(start, timeZone) !== 0 || getDisplayMinutes(end, timeZone) !== 0);
+  const intlOptions = createTimeIntlOptions(hour12, includeMinutes, options.showSeconds, timeZone);
+  const formatter = getDateTimeFormatter(locale, intlOptions);
+  if (typeof formatter.formatRange !== "function") {
+    return formatTimeRangeFull(start, end, locale, options, timeZone);
+  }
+  if (hour12 && !options.showAMPM && typeof formatter.formatRangeToParts === "function") {
+    const rangeParts = formatter.formatRangeToParts(start, end);
+    return formatPartsWithoutDayPeriod(rangeParts);
+  }
+  if (hour12 && !options.showAMPM) {
+    return formatTimeRangeFull(start, end, locale, options, timeZone);
+  }
+  return normalizeFormattedTime(formatter.formatRange(start, end));
+}
+function __getDateTimeFormatterCacheSize() {
+  return dateTimeFormatterCache.size;
+}
+function __clearDateTimeFormatterCache() {
+  dateTimeFormatterCache.clear();
+  localeHour12Cache.clear();
+}
+function formatTime(date, locale, options, timeZone) {
+  const opts = normalizeTimeFormatOptions(options);
+  const hour12 = resolveHour12(opts, locale);
+  const includeMinutes = shouldIncludeMinutes(date, opts, timeZone);
+  const intlOptions = createTimeIntlOptions(hour12, includeMinutes, opts.showSeconds, timeZone);
+  const formatter = getDateTimeFormatter(locale, intlOptions);
+  return formatTimeWithFormatter(date, formatter, hour12, opts.showAMPM);
+}
+function formatTimeRange(start, end, locale, options, timeZone) {
+  const opts = normalizeTimeFormatOptions(options);
+  switch (opts.rangeDisplay) {
+    case "compact":
+      return formatTimeRangeCompact(start, end, locale, opts, timeZone);
+    case "locale":
+      return formatTimeRangeLocale(start, end, locale, opts, timeZone);
+    case "full":
+    default:
+      return formatTimeRangeFull(start, end, locale, opts, timeZone);
+  }
+}
+function formatSlotTime(date, locale, options, timeZone) {
+  const opts = normalizeTimeFormatOptions(options);
+  const hour12 = resolveHour12(opts, locale, opts.use24HourSlots);
+  const includeMinutes = shouldIncludeMinutes(date, opts, timeZone);
+  const intlOptions = createTimeIntlOptions(hour12, includeMinutes, opts.showSeconds, timeZone);
+  const formatter = getDateTimeFormatter(locale, intlOptions);
+  return formatTimeWithFormatter(date, formatter, hour12, opts.showAMPM);
+}
+function getComparisonParts(date, timeZone) {
+  if (!timeZone) {
+    return {
+      year: date.getFullYear(),
+      month: date.getMonth(),
+      day: date.getDate()
+    };
+  }
+  const parts = getDateTimeFormatter("en-US", {
+    year: "numeric",
+    month: "numeric",
+    day: "numeric",
+    timeZone
+  }).formatToParts(date);
+  const getValue = (type) => {
+    const value = parts.find((part) => part.type === type)?.value;
+    const parsed = value ? Number(value) : NaN;
+    return Number.isFinite(parsed) ? parsed : 0;
+  };
+  return {
+    year: getValue("year"),
+    month: getValue("month") - 1,
+    day: getValue("day")
+  };
+}
+function isSameYear(date, reference, timeZone) {
+  return getComparisonParts(date, timeZone).year === getComparisonParts(reference, timeZone).year;
+}
+function isSameCalendarDay(date, reference, timeZone) {
+  const left = getComparisonParts(date, timeZone);
+  const right = getComparisonParts(reference, timeZone);
+  return left.year === right.year && left.month === right.month && left.day === right.day;
+}
+function isToday(date, timeZone) {
+  const today = /* @__PURE__ */ new Date();
+  return isSameCalendarDay(date, today, timeZone);
+}
+function isTomorrow(date, timeZone) {
+  const tomorrow = /* @__PURE__ */ new Date();
+  tomorrow.setDate(tomorrow.getDate() + 1);
+  return isSameCalendarDay(date, tomorrow, timeZone);
+}
+function isYesterday(date, timeZone) {
+  const yesterday = /* @__PURE__ */ new Date();
+  yesterday.setDate(yesterday.getDate() - 1);
+  return isSameCalendarDay(date, yesterday, timeZone);
+}
+function getRelativeDay(date, locale, timeZone) {
+  if (isToday(date, timeZone)) {
+    return getRelativeTimeLabel("today", locale);
+  }
+  if (isTomorrow(date, timeZone)) {
+    return getRelativeTimeLabel("tomorrow", locale);
+  }
+  if (isYesterday(date, timeZone)) {
+    return getRelativeTimeLabel("yesterday", locale);
+  }
+  return null;
+}
+function getRelativeTimeLabel(key, locale) {
+  const labels = {
+    en: { today: "Today", tomorrow: "Tomorrow", yesterday: "Yesterday" },
+    es: { today: "Hoy", tomorrow: "Ma\xF1ana", yesterday: "Ayer" },
+    fr: { today: "Aujourd'hui", tomorrow: "Demain", yesterday: "Hier" },
+    de: { today: "Heute", tomorrow: "Morgen", yesterday: "Gestern" },
+    it: { today: "Oggi", tomorrow: "Domani", yesterday: "Ieri" },
+    pt: { today: "Hoje", tomorrow: "Amanh\xE3", yesterday: "Ontem" },
+    ja: { today: "\u4ECA\u65E5", tomorrow: "\u660E\u65E5", yesterday: "\u6628\u65E5" },
+    zh: { today: "\u4ECA\u5929", tomorrow: "\u660E\u5929", yesterday: "\u6628\u5929" },
+    ko: { today: "\uC624\uB298", tomorrow: "\uB0B4\uC77C", yesterday: "\uC5B4\uC81C" },
+    ru: { today: "\u0421\u0435\u0433\u043E\u0434\u043D\u044F", tomorrow: "\u0417\u0430\u0432\u0442\u0440\u0430", yesterday: "\u0412\u0447\u0435\u0440\u0430" },
+    ar: { today: "\u0627\u0644\u064A\u0648\u0645", tomorrow: "\u063A\u062F\u0627\u064B", yesterday: "\u0623\u0645\u0633" },
+    tr: { today: "Bug\xFCn", tomorrow: "Yar\u0131n", yesterday: "D\xFCn" }
+  };
+  const langCode = locale.split("-")[0].toLowerCase();
+  return labels[langCode]?.[key] ?? labels.en[key];
+}
+function getSchedulerDisplayFormatter(locale, timeZone, displayConfig) {
+  return createSchedulerDateFormatter({
+    ...displayConfig,
+    locale,
+    timeZone
+  });
+}
+function formatDate(date, locale, options, timeZone, displayConfig) {
+  const opts = normalizeDateDisplayOptions(options);
+  const formatter = getSchedulerDisplayFormatter(locale, timeZone, displayConfig);
+  if (opts.relativeTime) {
+    const relativeDay = getRelativeDay(date, locale, timeZone);
+    if (relativeDay) {
+      return relativeDay;
+    }
+  }
+  const formatOptions = {
+    day: opts.dayFormat,
+    month: opts.monthFormat
+  };
+  if (timeZone) {
+    formatOptions.timeZone = timeZone;
+  }
+  if (opts.weekdayFormat) {
+    formatOptions.weekday = opts.weekdayFormat;
+  }
+  const now = /* @__PURE__ */ new Date();
+  if (opts.showYear === "always" || opts.showYear === "different" && !isSameYear(date, now, timeZone)) {
+    formatOptions.year = "numeric";
+  }
+  return formatter.format(date, formatOptions);
+}
+function formatWeekday(date, locale, format = "short", timeZone, displayConfig) {
+  return getSchedulerDisplayFormatter(locale, timeZone, displayConfig).formatWeekday(date, format);
+}
+function formatMonth(date, locale, format = "long", timeZone, displayConfig) {
+  return getSchedulerDisplayFormatter(locale, timeZone, displayConfig).formatMonth(date, format);
+}
+function formatDayOfMonth(date, locale, format = "numeric", timeZone, displayConfig) {
+  return getSchedulerDisplayFormatter(locale, timeZone, displayConfig).formatDayNumber(date, format);
+}
+function formatMonthYear(date, locale, options, timeZone, displayConfig) {
+  const opts = normalizeDateDisplayOptions(options);
+  const formatter = getSchedulerDisplayFormatter(locale, timeZone, displayConfig);
+  return formatter.format(date, {
+    month: opts.monthFormat,
+    year: "numeric"
+  });
+}
+function formatDateRange(start, end, locale, options, timeZone, displayConfig) {
+  const opts = normalizeDateDisplayOptions(options);
+  const formatter = getSchedulerDisplayFormatter(locale, timeZone, displayConfig);
+  const startParts = getComparisonParts(start, timeZone);
+  const endParts = getComparisonParts(end, timeZone);
+  const sameMonth = startParts.month === endParts.month && startParts.year === endParts.year;
+  const sameYear = startParts.year === endParts.year;
+  if (sameMonth) {
+    const startDay = formatDayOfMonth(start, locale, opts.dayFormat, timeZone, displayConfig);
+    const endFormatted2 = formatDate(end, locale, { ...opts, weekdayFormat: void 0 }, timeZone, displayConfig);
+    return `${startDay} - ${endFormatted2}`;
+  }
+  if (sameYear) {
+    const startFormatted2 = formatter.format(start, {
+      day: opts.dayFormat,
+      month: opts.monthFormat
+    });
+    const endFormatted2 = formatDate(end, locale, { ...opts, weekdayFormat: void 0 }, timeZone, displayConfig);
+    return `${startFormatted2} - ${endFormatted2}`;
+  }
+  const startFormatted = formatDate(start, locale, { ...opts, showYear: "always", weekdayFormat: void 0 }, timeZone, displayConfig);
+  const endFormatted = formatDate(end, locale, { ...opts, showYear: "always", weekdayFormat: void 0 }, timeZone, displayConfig);
+  return `${startFormatted} - ${endFormatted}`;
+}
+function formatEventDateTime(event, locale, displayOptions, timeZone, displayConfig) {
+  const opts = normalizeDisplayOptions(displayOptions);
+  const start = typeof event.start === "string" ? new Date(event.start) : event.start;
+  const end = event.end ? typeof event.end === "string" ? new Date(event.end) : event.end : start;
+  if (event.allDay) {
+    const sameDay2 = isSameCalendarDay(start, end, timeZone);
+    if (sameDay2) {
+      return formatDate(start, locale, opts.date, timeZone, displayConfig);
+    }
+    return formatDateRange(start, end, locale, opts.date, timeZone, displayConfig);
+  }
+  const sameDay = isSameCalendarDay(start, end, timeZone);
+  if (sameDay) {
+    const dateStr = formatDate(start, locale, opts.date, timeZone, displayConfig);
+    const timeRange = formatTimeRange(start, end, locale, opts.time, timeZone);
+    return `${dateStr}, ${timeRange}`;
+  }
+  const startStr = `${formatDate(start, locale, opts.date, timeZone, displayConfig)}, ${formatTime(start, locale, opts.time, timeZone)}`;
+  const endStr = `${formatDate(end, locale, opts.date, timeZone, displayConfig)}, ${formatTime(end, locale, opts.time, timeZone)}`;
+  return `${startStr} - ${endStr}`;
+}
+function getHeaderCalendarAdapter(locale, view, displayConfig) {
+  const calendar = resolveSchedulerCalendarModeForView(displayConfig?.calendar ?? "gregory", view);
+  return getSchedulerCalendarAdapter(calendar, { locale });
+}
+function toHeaderDate(adapter, date) {
+  return adapter.toDate(date);
+}
+function formatHeaderTitle(date, view, locale, options, context, timeZone, displayConfig) {
+  const opts = normalizeDateDisplayOptions(options);
+  const viewDisplayConfig = { ...displayConfig, view };
+  const formatter = getSchedulerDisplayFormatter(locale, timeZone, viewDisplayConfig);
+  switch (view) {
+    case "month":
+    case "resourceMonth":
+    case "dateMonth":
+    case "timelineMonth":
+    case "resourceTimelineMonth":
+      return formatMonthYear(date, locale, opts, timeZone, viewDisplayConfig);
+    case "week":
+    case "resourceWeek":
+    case "dateWeek":
+    case "timelineWeek":
+    case "resourceTimelineWeek": {
+      const fdow = context?.firstDayOfWeek ?? 0;
+      const adapter = getHeaderCalendarAdapter(locale, view, viewDisplayConfig);
+      const weekStart = adapter.startOfWeek(adapter.fromDate(date), fdow);
+      const weekEnd = adapter.add(weekStart, { days: 6 });
+      const activeDays = context?.daysOfWeek?.filter((day) => Number.isInteger(day) && day >= 0 && day <= 6);
+      if (!activeDays || activeDays.length === 0 || activeDays.length === 7) {
+        return formatDateRange(toHeaderDate(adapter, weekStart), toHeaderDate(adapter, weekEnd), locale, { ...opts, weekdayFormat: void 0 }, timeZone, viewDisplayConfig);
+      }
+      let firstVisible = null;
+      let lastVisible = null;
+      for (let i = 0; i < 7; i++) {
+        const calendarDate = adapter.add(weekStart, { days: i });
+        const d = toHeaderDate(adapter, calendarDate);
+        if (activeDays.includes(adapter.getDayOfWeek(calendarDate))) {
+          if (!firstVisible) firstVisible = d;
+          lastVisible = d;
+        }
+      }
+      if (!firstVisible || !lastVisible) {
+        return formatMonthYear(date, locale, opts, timeZone, viewDisplayConfig);
+      }
+      return formatDateRange(firstVisible, lastVisible, locale, { ...opts, weekdayFormat: void 0 }, timeZone, viewDisplayConfig);
+    }
+    case "day":
+    case "resourceDay":
+    case "dateDay":
+    case "timelineDay":
+    case "resourceTimelineDay":
+      return formatDate(date, locale, { ...opts, showYear: "always" }, timeZone, viewDisplayConfig);
+    case "year":
+    case "timelineYear":
+      return formatter.formatYear(date);
+    case "agenda":
+      return formatMonthYear(date, locale, opts, timeZone, viewDisplayConfig);
+    default:
+      return formatDate(date, locale, opts, timeZone, viewDisplayConfig);
+  }
+}
+
+export { DEFAULT_DATE_DISPLAY_OPTIONS, DEFAULT_DISPLAY_OPTIONS, DEFAULT_TIME_FORMAT_OPTIONS, __clearDateTimeFormatterCache, __getDateTimeFormatterCacheSize, createSchedulerDateFormatter, formatDate, formatDateRange, formatDayOfMonth, formatEventDateTime, formatHeaderTitle, formatMonth, formatMonthYear, formatSlotTime, formatTime, formatTimeRange, formatWeekday, getRelativeDay, normalizeDateDisplayOptions, normalizeDisplayOptions, normalizeTimeFormatOptions, resolveSchedulerCalendarDisplayConfig };

package/dist/chunk-UMAMDBU4.mjs

@@ -0,0 +1 @@
+