@vicacha-devs/strapi-plugin-events 0.0.0-stage → 1.0.0

package/dist/shared/index.js

@@ -0,0 +1,753 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const shared = require("@vicacha-devs/strapi-plugin-calendar/shared");
+const DANGEROUS_OBJECT_KEYS = /* @__PURE__ */ new Set([
+  "__proto__",
+  "constructor",
+  "prototype"
+]);
+function isSafeObjectKey(key) {
+  return typeof key === "string" && key.length > 0 && !DANGEROUS_OBJECT_KEYS.has(key);
+}
+function sanitizePlainRecord(raw, maxDepth = 4) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw) || maxDepth < 0) {
+    return null;
+  }
+  const clean = {};
+  for (const [k, v] of Object.entries(raw)) {
+    if (!isSafeObjectKey(k)) continue;
+    if (v && typeof v === "object" && !Array.isArray(v)) {
+      if (maxDepth === 0) continue;
+      clean[k] = sanitizePlainRecord(v, maxDepth - 1);
+    } else if (Array.isArray(v)) {
+      clean[k] = maxDepth === 0 ? [] : v.map(
+        (item) => item && typeof item === "object" && !Array.isArray(item) ? sanitizePlainRecord(item, maxDepth - 1) : item
+      );
+    } else {
+      clean[k] = v;
+    }
+  }
+  return clean;
+}
+const ALLOWED_ACTION_VARIANTS = /* @__PURE__ */ new Set([
+  "primary",
+  "secondary",
+  "outline"
+]);
+const HTTP_PROTOCOLS = /* @__PURE__ */ new Set(["https:", "http:"]);
+const ACTION_PROTOCOLS = /* @__PURE__ */ new Set(["https:", "http:", "mailto:"]);
+function isSafeRelativeUrl(trimmed) {
+  return trimmed.startsWith("/") && !trimmed.startsWith("//") && !trimmed.includes("\\");
+}
+function isAllowedAbsoluteUrl(trimmed, allowMailto) {
+  try {
+    const parsed = new URL(trimmed);
+    const proto = parsed.protocol.toLowerCase();
+    return allowMailto ? ACTION_PROTOCOLS.has(proto) : HTTP_PROTOCOLS.has(proto);
+  } catch {
+    return false;
+  }
+}
+function sanitizeEventUrl(rawUrl, options) {
+  if (typeof rawUrl !== "string") return null;
+  const trimmed = rawUrl.trim();
+  if (!trimmed || trimmed.length > 2048 || /[\u0000-\u001F\u007F]/.test(trimmed)) {
+    return null;
+  }
+  const allowMailto = options?.allowMailto ?? true;
+  if (isSafeRelativeUrl(trimmed) || isAllowedAbsoluteUrl(trimmed, allowMailto)) {
+    return trimmed;
+  }
+  return null;
+}
+function parseJsonIfNeeded(raw) {
+  if (typeof raw !== "string") return raw;
+  const trimmed = raw.trim();
+  const isJsonLike = trimmed.startsWith("{") && trimmed.endsWith("}") || trimmed.startsWith("[") && trimmed.endsWith("]");
+  if (!isJsonLike) return raw;
+  try {
+    return JSON.parse(trimmed);
+  } catch {
+    return raw;
+  }
+}
+function getTrimmedString(val, maxLen) {
+  if (typeof val !== "string") return void 0;
+  const trimmed = val.trim();
+  if (!trimmed) return void 0;
+  return maxLen ? trimmed.slice(0, maxLen) : trimmed;
+}
+function getPositiveInteger(val) {
+  if (typeof val !== "number" || !Number.isFinite(val) || val <= 0) {
+    return void 0;
+  }
+  return Math.round(val);
+}
+function unwrapPosterRecord(obj) {
+  if (obj.data && typeof obj.data === "object" && !Array.isArray(obj.data)) {
+    return unwrapPosterRecord(obj.data);
+  }
+  if (obj.attributes && typeof obj.attributes === "object" && !Array.isArray(obj.attributes)) {
+    return unwrapPosterRecord(obj.attributes);
+  }
+  return obj;
+}
+function resolvePosterAltText(obj, fallbackAlt) {
+  return getTrimmedString(obj.alt) || getTrimmedString(obj.alternativeText) || getTrimmedString(obj.caption) || fallbackAlt || void 0;
+}
+function normalizeEventPoster(rawPoster, fallbackAlt) {
+  if (!rawPoster) return void 0;
+  if (typeof rawPoster === "string") {
+    const safeUrl2 = sanitizeEventUrl(rawPoster, { allowMailto: false });
+    return safeUrl2 ? { url: safeUrl2, alt: fallbackAlt || void 0 } : void 0;
+  }
+  if (Array.isArray(rawPoster)) {
+    return rawPoster.length > 0 ? normalizeEventPoster(rawPoster[0], fallbackAlt) : void 0;
+  }
+  if (typeof rawPoster !== "object") return void 0;
+  const obj = unwrapPosterRecord(rawPoster);
+  const safeUrl = sanitizeEventUrl(obj.url, { allowMailto: false });
+  if (!safeUrl) return void 0;
+  return {
+    url: safeUrl,
+    alt: resolvePosterAltText(obj, fallbackAlt),
+    mime: getTrimmedString(obj.mime),
+    width: getPositiveInteger(obj.width),
+    height: getPositiveInteger(obj.height)
+  };
+}
+function resolveActionVariant(rawVariant, index) {
+  const candidate = getTrimmedString(rawVariant);
+  if (candidate && ALLOWED_ACTION_VARIANTS.has(candidate)) {
+    return candidate;
+  }
+  return index === 0 ? "primary" : "outline";
+}
+function normalizeSingleActionLink(item, index) {
+  if (!item || typeof item !== "object") return null;
+  const rec = item;
+  const label = getTrimmedString(rec.label, 120);
+  const safeUrl = sanitizeEventUrl(rec.url);
+  if (!label || !safeUrl) return null;
+  const external = typeof rec.external === "boolean" ? rec.external : /^https?:\/\//i.test(safeUrl);
+  const icon = getTrimmedString(rec.icon, 60);
+  return {
+    label,
+    url: safeUrl,
+    variant: resolveActionVariant(rec.variant, index),
+    external,
+    ...icon ? { icon } : {}
+  };
+}
+function normalizeEventActionLinks(rawLinks) {
+  const parsed = parseJsonIfNeeded(rawLinks);
+  if (!Array.isArray(parsed) || parsed.length === 0) {
+    return void 0;
+  }
+  const normalized = parsed.map((item, idx) => normalizeSingleActionLink(item, idx)).filter((link) => link !== null);
+  return normalized.length > 0 ? normalized : void 0;
+}
+function isValidCalendarDateKey(dateStr) {
+  if (!/^\d{4}-\d{2}-\d{2}$/.test(dateStr)) {
+    return false;
+  }
+  const parsed = /* @__PURE__ */ new Date(`${dateStr}T00:00:00.000Z`);
+  if (Number.isNaN(parsed.getTime())) {
+    return false;
+  }
+  return parsed.toISOString().slice(0, 10) === dateStr;
+}
+function toDateKey(dateInput) {
+  const d = typeof dateInput === "string" ? new Date(dateInput) : dateInput;
+  if (Number.isNaN(d.getTime())) {
+    return "";
+  }
+  return d.toISOString().slice(0, 10);
+}
+function normalizeRRuleString(raw) {
+  if (!raw || typeof raw !== "string") {
+    return "";
+  }
+  return raw.replace(/[\u0000-\u001F\u007F]+/g, "").trim().replace(/^RRULE:/i, "").trim();
+}
+function sanitizeOccurrenceOverrides(rawOverrides) {
+  const clean = {};
+  if (!rawOverrides || typeof rawOverrides !== "object" || Array.isArray(rawOverrides)) {
+    return clean;
+  }
+  for (const [key, ov] of Object.entries(rawOverrides)) {
+    if (!isSafeObjectKey(key) || !isValidCalendarDateKey(key)) continue;
+    if (!ov || typeof ov !== "object" || Array.isArray(ov)) continue;
+    let validStart;
+    let startMs = null;
+    if (ov.startDate !== void 0 && ov.startDate !== "") {
+      if (typeof ov.startDate !== "string") continue;
+      const parsedStart = new Date(ov.startDate).getTime();
+      if (Number.isNaN(parsedStart)) continue;
+      validStart = ov.startDate;
+      startMs = parsedStart;
+    }
+    let validEnd;
+    if (ov.endDate !== void 0 && ov.endDate !== "") {
+      if (typeof ov.endDate !== "string") continue;
+      const parsedEnd = new Date(ov.endDate).getTime();
+      if (Number.isNaN(parsedEnd)) continue;
+      const minStartMs = startMs ?? (/* @__PURE__ */ new Date(`${key}T00:00:00.000Z`)).getTime();
+      if (parsedEnd < minStartMs) continue;
+      validEnd = ov.endDate;
+    }
+    clean[key] = {
+      ...ov,
+      originalDate: typeof ov.originalDate === "string" && isValidCalendarDateKey(ov.originalDate) ? ov.originalDate : key,
+      startDate: validStart,
+      endDate: validEnd
+    };
+  }
+  return clean;
+}
+function sanitizeRRuleFieldValue(rec, defaultTimezone = "UTC") {
+  const rrule = normalizeRRuleString(rec?.rrule);
+  const timezone = typeof rec?.timezone === "string" && rec.timezone.trim() ? rec.timezone.trim() : defaultTimezone;
+  const exdates = Array.isArray(rec?.exdates) ? rec.exdates.filter(
+    (d) => typeof d === "string" && isValidCalendarDateKey(d)
+  ) : [];
+  const overrides = sanitizeOccurrenceOverrides(rec?.overrides);
+  return {
+    ...rec,
+    rrule,
+    timezone,
+    allDay: Boolean(rec?.allDay),
+    exdates,
+    overrides
+  };
+}
+function parseRRuleFieldValue(raw, defaultTimezone = "UTC") {
+  const parsed = shared.parseRRuleFieldValue(raw, defaultTimezone);
+  return sanitizeRRuleFieldValue(parsed, defaultTimezone);
+}
+function buildRRule(parsed) {
+  return shared.buildRRule({
+    freq: parsed.freq ?? "NONE",
+    interval: parsed.interval ?? 1,
+    byDay: parsed.byDay ?? [],
+    byMonthDay: parsed.byMonthDay,
+    count: parsed.count,
+    until: parsed.until
+  });
+}
+const FREQ_UNITS = {
+  DAILY: { singular: "day", plural: "days" },
+  WEEKLY: { singular: "week", plural: "weeks" },
+  MONTHLY: { singular: "month", plural: "months" },
+  YEARLY: { singular: "year", plural: "years" }
+};
+function formatIntervalUnit(freq, interval) {
+  const unit = Object.hasOwn(FREQ_UNITS, freq) ? FREQ_UNITS[freq] : FREQ_UNITS.YEARLY;
+  return interval === 1 ? unit.singular : `${interval} ${unit.plural}`;
+}
+function describeRRule(rruleString) {
+  const parsed = shared.parseRRule(normalizeRRuleString(rruleString));
+  if (parsed.freq === "NONE") {
+    return "Does not repeat";
+  }
+  let summary = `Every ${formatIntervalUnit(parsed.freq, parsed.interval)}`;
+  if (parsed.freq === "WEEKLY" && parsed.byDay.length > 0) {
+    summary += ` on ${parsed.byDay.join(", ")}`;
+  } else if (parsed.freq === "MONTHLY" && parsed.byMonthDay) {
+    summary += ` on day ${parsed.byMonthDay}`;
+  }
+  if (parsed.until) {
+    summary += ` until ${parsed.until}`;
+  } else if (parsed.count) {
+    summary += ` (${parsed.count} occurrences)`;
+  }
+  return summary;
+}
+function expandRuleSlots(options) {
+  const baseStartMs = new Date(options.baseStartDate).getTime();
+  if (Number.isNaN(baseStartMs)) {
+    return [];
+  }
+  let safeBaseEnd = null;
+  if (typeof options.baseEndDate === "string" && options.baseEndDate) {
+    const baseEndMs = new Date(options.baseEndDate).getTime();
+    if (!Number.isNaN(baseEndMs) && baseEndMs >= baseStartMs) {
+      safeBaseEnd = options.baseEndDate;
+    }
+  }
+  const windowStartIso = typeof options.windowStart === "string" ? options.windowStart : options.windowStart.toISOString();
+  const windowEndIso = typeof options.windowEnd === "string" ? options.windowEnd : options.windowEnd.toISOString();
+  if (Number.isNaN(new Date(windowStartIso).getTime()) || Number.isNaN(new Date(windowEndIso).getTime())) {
+    return [];
+  }
+  return shared.expandRuleSlots({
+    baseStartDate: options.baseStartDate,
+    baseEndDate: safeBaseEnd,
+    recurrence: sanitizeRRuleFieldValue(
+      options.recurrence,
+      options.recurrence?.timezone || "UTC"
+    ),
+    windowStart: windowStartIso,
+    windowEnd: windowEndIso,
+    maxOccurrences: options.maxInstances ?? 366
+  });
+}
+const utf8Encoder = new TextEncoder();
+function toIcsTimestamp(isoString, allDay = false) {
+  const d = new Date(isoString);
+  if (Number.isNaN(d.getTime())) {
+    return "";
+  }
+  const iso = d.toISOString();
+  if (allDay) {
+    return iso.slice(0, 10).replace(/-/g, "");
+  }
+  return iso.replace(/[-:]/g, "").replace(/\.\d{3}Z$/, "Z");
+}
+function resolveExclusiveAllDayEndStamp(startDate, endDate, dtStartStamp) {
+  const rawEndStamp = toIcsTimestamp(endDate, true);
+  if (rawEndStamp && rawEndStamp > dtStartStamp) {
+    return rawEndStamp;
+  }
+  const startObj = new Date(startDate);
+  if (Number.isNaN(startObj.getTime())) {
+    return rawEndStamp;
+  }
+  const nextDay = new Date(
+    Date.UTC(
+      startObj.getUTCFullYear(),
+      startObj.getUTCMonth(),
+      startObj.getUTCDate() + 1
+    )
+  );
+  return nextDay.toISOString().slice(0, 10).replace(/-/g, "");
+}
+function escapeIcsText(value) {
+  if (!value) return "";
+  return String(value).replace(/\\/g, "\\\\").replace(/\r\n|\r|\n/g, "\\n").replace(/;/g, "\\;").replace(/,/g, "\\,");
+}
+function foldIcsLine(line) {
+  if (utf8Encoder.encode(line).byteLength <= 75) {
+    return line;
+  }
+  const chunks = [];
+  let currentChunk = "";
+  let currentBytes = 0;
+  let maxBytes = 75;
+  for (const codePoint of line) {
+    const byteLen = utf8Encoder.encode(codePoint).byteLength;
+    if (currentBytes + byteLen > maxBytes && currentChunk.length > 0) {
+      chunks.push(chunks.length === 0 ? currentChunk : ` ${currentChunk}`);
+      currentChunk = codePoint;
+      currentBytes = byteLen;
+      maxBytes = 74;
+    } else {
+      currentChunk += codePoint;
+      currentBytes += byteLen;
+    }
+  }
+  if (currentChunk.length > 0) {
+    chunks.push(chunks.length === 0 ? currentChunk : ` ${currentChunk}`);
+  }
+  return chunks.join("\r\n");
+}
+function buildCalendarLinks(params) {
+  const {
+    documentId,
+    title,
+    startDate,
+    endDate,
+    allDay = false,
+    summary = "",
+    location = "",
+    occurrenceDate
+  } = params;
+  const icsStart = toIcsTimestamp(startDate, allDay);
+  const icsEnd = allDay ? resolveExclusiveAllDayEndStamp(startDate, endDate, icsStart) : toIcsTimestamp(endDate, false);
+  const googleParams = new URLSearchParams({
+    action: "TEMPLATE",
+    text: title,
+    dates: `${icsStart}/${icsEnd}`,
+    details: summary,
+    location
+  });
+  const outlookParams = new URLSearchParams({
+    path: "/calendar/action/compose",
+    rru: "addevent",
+    subject: title,
+    startdt: startDate,
+    enddt: endDate,
+    body: summary,
+    location,
+    allday: allDay ? "true" : "false"
+  });
+  const yahooParams = new URLSearchParams({
+    v: "60",
+    title,
+    st: icsStart,
+    et: icsEnd,
+    desc: summary,
+    in_loc: location
+  });
+  const querySuffix = occurrenceDate ? `?occurrenceDate=${encodeURIComponent(occurrenceDate)}` : "";
+  return {
+    google: `https://calendar.google.com/calendar/render?${googleParams.toString()}`,
+    outlook: `https://outlook.live.com/calendar/0/deeplink/compose?${outlookParams.toString()}`,
+    yahoo: `https://calendar.yahoo.com/?${yahooParams.toString()}`,
+    icsPath: `/api/events/${encodeURIComponent(documentId)}/invite.ics${querySuffix}`
+  };
+}
+const ICS_STATUS_MAP = {
+  cancelled: "CANCELLED",
+  postponed: "TENTATIVE"
+};
+function resolveIcsStatus(status) {
+  return Object.hasOwn(ICS_STATUS_MAP, status) ? ICS_STATUS_MAP[status] : "CONFIRMED";
+}
+function appendVEventDateLines(lines, occ) {
+  const isAllDay = Boolean(occ.allDay);
+  const prefix = isAllDay ? ";VALUE=DATE" : "";
+  const startStamp = toIcsTimestamp(occ.startDate, isAllDay);
+  const endStamp = isAllDay ? resolveExclusiveAllDayEndStamp(occ.startDate, occ.endDate, startStamp) : toIcsTimestamp(occ.endDate, false);
+  lines.push(`DTSTART${prefix}:${startStamp}`);
+  lines.push(`DTEND${prefix}:${endStamp}`);
+}
+function appendVEventOptionalLines(lines, occ) {
+  if (occ.summary) {
+    lines.push(foldIcsLine(`DESCRIPTION:${escapeIcsText(occ.summary)}`));
+  }
+  if (occ.location) {
+    lines.push(foldIcsLine(`LOCATION:${escapeIcsText(occ.location)}`));
+  }
+  if (occ.virtualUrl) {
+    lines.push(foldIcsLine(`URL:${escapeIcsText(occ.virtualUrl)}`));
+  }
+  if (occ.isRecurring && occ.rrule) {
+    const normalized = normalizeRRuleString(occ.rrule).replace(/[\r\n]+/g, "");
+    if (normalized) {
+      lines.push(foldIcsLine(`RRULE:${normalized}`));
+    }
+  }
+}
+function generateIcsCalendar(occurrences, feedTitle = "Events Calendar") {
+  const nowStamp = toIcsTimestamp((/* @__PURE__ */ new Date()).toISOString(), false);
+  const lines = [
+    "BEGIN:VCALENDAR",
+    "VERSION:2.0",
+    "PRODID:-//Strapi v5//strapi-plugin-events//EN",
+    "CALSCALE:GREGORIAN",
+    "METHOD:PUBLISH",
+    foldIcsLine(`X-WR-CALNAME:${escapeIcsText(feedTitle)}`)
+  ];
+  for (const occ of occurrences) {
+    const uid = `${occ.documentId}-${occ.occurrenceDate}@strapi-plugin-events`;
+    lines.push("BEGIN:VEVENT");
+    lines.push(foldIcsLine(`UID:${escapeIcsText(uid)}`));
+    lines.push(`DTSTAMP:${nowStamp}`);
+    appendVEventDateLines(lines, occ);
+    lines.push(foldIcsLine(`SUMMARY:${escapeIcsText(occ.title)}`));
+    appendVEventOptionalLines(lines, occ);
+    lines.push(`STATUS:${resolveIcsStatus(occ.status)}`);
+    lines.push("END:VEVENT");
+  }
+  lines.push("END:VCALENDAR");
+  return `${lines.join("\r\n")}\r
+`;
+}
+function sanitizeCsvCell(raw) {
+  if (raw === null || raw === void 0) {
+    return '""';
+  }
+  let text = String(raw);
+  if (/^[\s\u0085\u2028\u2029]*[=+\-@|]|^[\t\r\n]/.test(text)) {
+    text = `'${text}`;
+  }
+  const escaped = text.replace(/"/g, '""');
+  return `"${escaped}"`;
+}
+function generateRegistrationsCsv(records) {
+  const headers = [
+    "Document ID",
+    "Event UID",
+    "Event Document ID",
+    "Event Title",
+    "Occurrence Date",
+    "Attendee Name",
+    "Attendee Email",
+    "Attendee Phone",
+    "Guests Count",
+    "Status",
+    "Checked In At",
+    "Locale",
+    "Notes",
+    "Created At"
+  ];
+  const rows = [headers.map(sanitizeCsvCell).join(",")];
+  for (const r of records) {
+    rows.push(
+      [
+        r.documentId,
+        r.eventUid,
+        r.eventDocumentId,
+        r.eventTitle ?? "",
+        r.occurrenceDate,
+        r.attendeeName,
+        r.attendeeEmail,
+        r.attendeePhone ?? "",
+        r.guestsCount,
+        r.status,
+        r.checkedInAt ?? "",
+        r.locale,
+        r.notes ?? "",
+        r.createdAt ?? ""
+      ].map(sanitizeCsvCell).join(",")
+    );
+  }
+  return `${rows.join("\r\n")}\r
+`;
+}
+const PLUGIN_ID = "events";
+const RRULE_CUSTOM_FIELD_UID = `plugin::${PLUGIN_ID}.rrule`;
+const EVENT_CONTENT_TYPE_UID = `plugin::${PLUGIN_ID}.event`;
+const REGISTRATION_CONTENT_TYPE_UID = `plugin::${PLUGIN_ID}.registration`;
+const ALLOWED_SPOTLIGHT_POSITIONS = /* @__PURE__ */ new Set([
+  "bottom-end",
+  "bottom-start"
+]);
+function resolveSpotlightPosition(rawPos) {
+  const candidate = getTrimmedString(rawPos);
+  return candidate && ALLOWED_SPOTLIGHT_POSITIONS.has(candidate) ? candidate : void 0;
+}
+function resolveFiniteRoundNumber(val) {
+  return typeof val === "number" && Number.isFinite(val) ? Math.round(val) : void 0;
+}
+function normalizeEventSpotlightConfig(rawConfig) {
+  const parsed = parseJsonIfNeeded(rawConfig);
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    return void 0;
+  }
+  const rec = parsed;
+  const config = {
+    enabled: Boolean(rec.enabled)
+  };
+  const badgeText = getTrimmedString(rec.badgeText, 80);
+  if (badgeText) config.badgeText = badgeText;
+  const priority = resolveFiniteRoundNumber(rec.priority);
+  if (priority !== void 0) config.priority = priority;
+  const position = resolveSpotlightPosition(rec.position);
+  if (position) config.position = position;
+  if (typeof rec.showCountdown === "boolean") {
+    config.showCountdown = rec.showCountdown;
+  }
+  const startAt = getTrimmedString(rec.startAt);
+  if (startAt) config.startAt = startAt;
+  const endAt = getTrimmedString(rec.endAt);
+  if (endAt) config.endAt = endAt;
+  return config;
+}
+function toBoundaryTimestamp(rawIsoOrDate, isEndBoundary) {
+  const trimmed = rawIsoOrDate.trim();
+  const isoString = /^\d{4}-\d{2}-\d{2}$/.test(trimmed) ? `${trimmed}${isEndBoundary ? "T23:59:59.999Z" : "T00:00:00.000Z"}` : trimmed;
+  const ts = new Date(isoString).getTime();
+  return Number.isNaN(ts) ? null : ts;
+}
+function toReferenceTimestamp(referenceDate) {
+  if (referenceDate instanceof Date) {
+    const ts2 = referenceDate.getTime();
+    return Number.isNaN(ts2) ? null : ts2;
+  }
+  const str = getTrimmedString(referenceDate);
+  const dt = str ? new Date(str) : /* @__PURE__ */ new Date();
+  const ts = dt.getTime();
+  return Number.isNaN(ts) ? null : ts;
+}
+function isEventSpotlightActiveOnDate(params) {
+  const { spotlightConfig, eventStartDate, eventEndDate, referenceDate } = params;
+  if (!spotlightConfig?.enabled) return false;
+  const refTs = toReferenceTimestamp(referenceDate);
+  if (refTs === null) return false;
+  const startTs = toBoundaryTimestamp(
+    spotlightConfig.startAt || eventStartDate,
+    false
+  );
+  const endTs = toBoundaryTimestamp(
+    spotlightConfig.endAt || eventEndDate || eventStartDate,
+    true
+  );
+  const afterStart = startTs === null || refTs >= startTs;
+  const beforeEnd = endTs === null || refTs <= endTs;
+  return afterStart && beforeEnd;
+}
+function deduplicateAndSortSpotlights(occurrences) {
+  const byDocKey = /* @__PURE__ */ new Map();
+  for (const occ of occurrences) {
+    if (!occ.spotlightConfig?.enabled || occ.status === "cancelled") {
+      continue;
+    }
+    const key = `${occ.sourceId}:${occ.documentId}`;
+    if (!byDocKey.has(key)) {
+      byDocKey.set(key, occ);
+    }
+  }
+  const unique = Array.from(byDocKey.values());
+  unique.sort((a, b) => {
+    const prioA = a.spotlightConfig?.priority ?? 0;
+    const prioB = b.spotlightConfig?.priority ?? 0;
+    if (prioB !== prioA) {
+      return prioB - prioA;
+    }
+    return new Date(a.startDate).getTime() - new Date(b.startDate).getTime();
+  });
+  return unique;
+}
+const DEFAULT_TIME_SLOTS = {
+  morning: { start: "09:00:00", end: "11:00:00" },
+  afternoon: { start: "14:00:00", end: "16:00:00" },
+  evening: { start: "18:00:00", end: "20:00:00" }
+};
+function buildSafeSlotMap(customSlots) {
+  const slotMap = { ...DEFAULT_TIME_SLOTS };
+  if (customSlots && typeof customSlots === "object") {
+    for (const [k, v] of Object.entries(customSlots)) {
+      if (isSafeObjectKey(k) && v && typeof v === "object") {
+        slotMap[k] = v;
+      }
+    }
+  }
+  return slotMap;
+}
+function resolveDateOnlySlotWindow(rawStart, rawSlot, source) {
+  if (!isSafeObjectKey(rawSlot)) return null;
+  const slotMap = buildSafeSlotMap(source.timeSlotMap);
+  const mapped = Object.hasOwn(slotMap, rawSlot) ? slotMap[rawSlot] : void 0;
+  if (mapped) {
+    return {
+      startDate: `${rawStart}T${mapped.start}.000Z`,
+      endDate: `${rawStart}T${mapped.end}.000Z`,
+      allDay: false
+    };
+  }
+  if (/^\d{2}:\d{2}(:\d{2})?$/.test(rawSlot)) {
+    const normalizedTime = rawSlot.length === 5 ? `${rawSlot}:00` : rawSlot;
+    return {
+      startDate: `${rawStart}T${normalizedTime}.000Z`,
+      endDate: null,
+      allDay: false
+    };
+  }
+  return null;
+}
+function resolveDateOnlyEnd(rawStart, rawEnd) {
+  if (typeof rawEnd === "string" && rawEnd) {
+    return /^\d{4}-\d{2}-\d{2}$/.test(rawEnd) ? `${rawEnd}T23:59:59.000Z` : rawEnd;
+  }
+  return `${rawStart}T23:59:59.000Z`;
+}
+function readOptionalDocField(doc, fieldName) {
+  return fieldName && isSafeObjectKey(fieldName) ? doc[fieldName] : null;
+}
+function resolveNonEmptyEnd(rawEnd) {
+  return typeof rawEnd === "string" && rawEnd ? rawEnd : null;
+}
+function resolveStartEndFromDocument(doc, source) {
+  const startField = source.fields.startDate;
+  const rawStart = isSafeObjectKey(startField) ? doc[startField] : void 0;
+  if (typeof rawStart !== "string" || !rawStart) {
+    return null;
+  }
+  const rawEnd = readOptionalDocField(doc, source.fields.endDate);
+  const rawSlot = readOptionalDocField(doc, source.fields.timeSlot);
+  if (/^\d{4}-\d{2}-\d{2}$/.test(rawStart)) {
+    const slotWindow = resolveDateOnlySlotWindow(rawStart, rawSlot, source);
+    if (slotWindow) return slotWindow;
+    return {
+      startDate: `${rawStart}T00:00:00.000Z`,
+      endDate: resolveDateOnlyEnd(rawStart, rawEnd),
+      allDay: source.defaultAllDay ?? true
+    };
+  }
+  const allDay = typeof doc.allDay === "boolean" ? doc.allDay : Boolean(source.defaultAllDay);
+  return {
+    startDate: rawStart,
+    endDate: resolveNonEmptyEnd(rawEnd),
+    allDay
+  };
+}
+const EVENT_STATUS_ALIAS_MAP = {
+  cancelled: "cancelled",
+  canceled: "cancelled",
+  postponed: "postponed",
+  pending: "postponed",
+  rescheduled: "rescheduled"
+};
+function mapEventStatus(rawStatus) {
+  if (typeof rawStatus !== "string") return "scheduled";
+  const lower = rawStatus.toLowerCase();
+  return Object.hasOwn(EVENT_STATUS_ALIAS_MAP, lower) ? EVENT_STATUS_ALIAS_MAP[lower] : "scheduled";
+}
+Object.defineProperty(exports, "SUPPORTED_INTL_CALENDARS", {
+  enumerable: true,
+  get: () => shared.SUPPORTED_INTL_CALENDARS
+});
+Object.defineProperty(exports, "applyDayOffset", {
+  enumerable: true,
+  get: () => shared.applyDayOffset
+});
+Object.defineProperty(exports, "extractCalendarParts", {
+  enumerable: true,
+  get: () => shared.extractCalendarParts
+});
+Object.defineProperty(exports, "formatDateInCalendarSystem", {
+  enumerable: true,
+  get: () => shared.formatDateInCalendarSystem
+});
+Object.defineProperty(exports, "getRegisteredCalendarFormatters", {
+  enumerable: true,
+  get: () => shared.getRegisteredCalendarFormatters
+});
+Object.defineProperty(exports, "parseRRule", {
+  enumerable: true,
+  get: () => shared.parseRRule
+});
+Object.defineProperty(exports, "registerCalendarSystemFormatter", {
+  enumerable: true,
+  get: () => shared.registerCalendarSystemFormatter
+});
+Object.defineProperty(exports, "resolveOccurrenceAlternateDates", {
+  enumerable: true,
+  get: () => shared.resolveOccurrenceAlternateDates
+});
+Object.defineProperty(exports, "unregisterCalendarSystemFormatter", {
+  enumerable: true,
+  get: () => shared.unregisterCalendarSystemFormatter
+});
+exports.EVENT_CONTENT_TYPE_UID = EVENT_CONTENT_TYPE_UID;
+exports.PLUGIN_ID = PLUGIN_ID;
+exports.REGISTRATION_CONTENT_TYPE_UID = REGISTRATION_CONTENT_TYPE_UID;
+exports.RRULE_CUSTOM_FIELD_UID = RRULE_CUSTOM_FIELD_UID;
+exports.buildCalendarLinks = buildCalendarLinks;
+exports.buildRRule = buildRRule;
+exports.deduplicateAndSortSpotlights = deduplicateAndSortSpotlights;
+exports.describeRRule = describeRRule;
+exports.escapeIcsText = escapeIcsText;
+exports.expandRuleSlots = expandRuleSlots;
+exports.foldIcsLine = foldIcsLine;
+exports.generateIcsCalendar = generateIcsCalendar;
+exports.generateRegistrationsCsv = generateRegistrationsCsv;
+exports.isEventSpotlightActiveOnDate = isEventSpotlightActiveOnDate;
+exports.isSafeObjectKey = isSafeObjectKey;
+exports.isValidCalendarDateKey = isValidCalendarDateKey;
+exports.mapEventStatus = mapEventStatus;
+exports.normalizeEventActionLinks = normalizeEventActionLinks;
+exports.normalizeEventPoster = normalizeEventPoster;
+exports.normalizeEventSpotlightConfig = normalizeEventSpotlightConfig;
+exports.normalizeRRuleString = normalizeRRuleString;
+exports.parseRRuleFieldValue = parseRRuleFieldValue;
+exports.resolveStartEndFromDocument = resolveStartEndFromDocument;
+exports.sanitizeCsvCell = sanitizeCsvCell;
+exports.sanitizeEventUrl = sanitizeEventUrl;
+exports.sanitizeOccurrenceOverrides = sanitizeOccurrenceOverrides;
+exports.sanitizePlainRecord = sanitizePlainRecord;
+exports.sanitizeRRuleFieldValue = sanitizeRRuleFieldValue;
+exports.toDateKey = toDateKey;
+exports.toIcsTimestamp = toIcsTimestamp;