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

package/dist/shared/index.js

@@ -0,0 +1,752 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const shared = require("@vicacha-devs/strapi-plugin-calendar/shared");
+const PLUGIN_ID = "bookings";
+function formatSecondaryCalendars(date, systems, locale = "en") {
+  const result = {};
+  if (!(date instanceof Date) || Number.isNaN(date.getTime())) {
+    return result;
+  }
+  const dateStr = date.toISOString().slice(0, 10);
+  for (const sys of systems) {
+    if (!sys || !sys.enabled || !sys.id) continue;
+    const formatted = shared.formatDateInCalendarSystem(dateStr, sys, locale, {
+      compact: false
+    });
+    const compact = shared.formatDateInCalendarSystem(dateStr, sys, locale, {
+      compact: true
+    });
+    const parts = shared.extractCalendarParts(
+      date,
+      sys.intlCalendar,
+      sys.dayOffset ?? 0
+    );
+    if (formatted) {
+      result[sys.id] = {
+        calendarId: sys.id,
+        label: sys.label || sys.id,
+        formatted,
+        compact: compact || formatted,
+        intlCalendar: sys.intlCalendar,
+        year: parts?.year,
+        month: parts?.month,
+        day: parts?.day,
+        isOverridden: false
+      };
+    }
+  }
+  return result;
+}
+const DEFAULT_WEEKLY_SCHEDULE = {
+  mode: "interval",
+  days: {
+    "1": [{ start: "09:00", end: "17:00", label: "09:00-17:00" }],
+    "2": [{ start: "09:00", end: "17:00", label: "09:00-17:00" }],
+    "3": [{ start: "09:00", end: "17:00", label: "09:00-17:00" }],
+    "4": [{ start: "09:00", end: "17:00", label: "09:00-17:00" }],
+    "5": [{ start: "09:00", end: "17:00", label: "09:00-17:00" }]
+  }
+};
+const WEEKDAY_TO_KEY = {
+  Sun: "0",
+  Mon: "1",
+  Tue: "2",
+  Wed: "3",
+  Thu: "4",
+  Fri: "5",
+  Sat: "6"
+};
+const formatterCache = /* @__PURE__ */ new Map();
+function getZonedFormatter(timeZone) {
+  const cached = formatterCache.get(timeZone);
+  if (cached) return cached;
+  const dtf = new Intl.DateTimeFormat("en-US", {
+    timeZone,
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+    weekday: "short",
+    hour: "2-digit",
+    minute: "2-digit",
+    second: "2-digit",
+    hourCycle: "h23"
+  });
+  if (formatterCache.size > 128) {
+    formatterCache.clear();
+  }
+  formatterCache.set(timeZone, dtf);
+  return dtf;
+}
+function normalizeTimeZone(tz) {
+  const trimmed = typeof tz === "string" ? tz.trim() : "";
+  if (!trimmed) return "UTC";
+  try {
+    getZonedFormatter(trimmed);
+    return trimmed;
+  } catch {
+    return "UTC";
+  }
+}
+function pad2(n) {
+  return String(n).padStart(2, "0");
+}
+function extractZonedWallClock(epochMs, rawTimeZone) {
+  const timeZone = normalizeTimeZone(rawTimeZone);
+  const dtf = getZonedFormatter(timeZone);
+  const parts = dtf.formatToParts(new Date(epochMs));
+  let year = 1970;
+  let month = 1;
+  let day = 1;
+  let hours = 0;
+  let minutes = 0;
+  let seconds = 0;
+  let dayKey = "4";
+  for (const part of parts) {
+    if (part.type === "year") year = Number.parseInt(part.value, 10);
+    else if (part.type === "month") month = Number.parseInt(part.value, 10);
+    else if (part.type === "day") day = Number.parseInt(part.value, 10);
+    else if (part.type === "hour") {
+      const h = Number.parseInt(part.value, 10);
+      hours = h === 24 ? 0 : h;
+    } else if (part.type === "minute") {
+      minutes = Number.parseInt(part.value, 10);
+    } else if (part.type === "second") {
+      seconds = Number.parseInt(part.value, 10);
+    } else if (part.type === "weekday") {
+      dayKey = WEEKDAY_TO_KEY[part.value] ?? "0";
+    }
+  }
+  const dateStr = `${String(year).padStart(4, "0")}-${pad2(month)}-${pad2(day)}`;
+  const ms = (epochMs % 1e3 + 1e3) % 1e3;
+  return {
+    year,
+    month,
+    day,
+    dateStr,
+    dayKey,
+    hours,
+    minutes,
+    seconds,
+    ms,
+    minutesOfDay: hours * 60 + minutes
+  };
+}
+function getTimeZoneOffsetMs(instantMs, timeZone) {
+  const parts = extractZonedWallClock(instantMs, timeZone);
+  const zonedAsUtcMs = Date.UTC(
+    parts.year,
+    parts.month - 1,
+    parts.day,
+    parts.hours,
+    parts.minutes,
+    parts.seconds,
+    0
+  );
+  const truncatedInstant = Math.floor(instantMs / 1e3) * 1e3;
+  return zonedAsUtcMs - truncatedInstant;
+}
+function parseIsoDateYmd(dateStr) {
+  const match = /^(\d{4})-(\d{2})-(\d{2})$/.exec(dateStr.trim());
+  if (!match) return null;
+  const year = Number.parseInt(match[1], 10);
+  const month = Number.parseInt(match[2], 10);
+  const day = Number.parseInt(match[3], 10);
+  if (month < 1 || month > 12 || day < 1 || day > 31) return null;
+  const check = new Date(Date.UTC(year, month - 1, day));
+  if (check.getUTCFullYear() !== year || check.getUTCMonth() !== month - 1 || check.getUTCDate() !== day) {
+    return null;
+  }
+  return { year, month, day };
+}
+function wallClockToUtcMs(dateStr, totalMinutes, rawTimeZone, strictGap = false) {
+  const ymd = parseIsoDateYmd(dateStr);
+  if (!ymd) return null;
+  const timeZone = normalizeTimeZone(rawTimeZone);
+  const extraDays = Math.floor(totalMinutes / 1440);
+  const remMins = (totalMinutes % 1440 + 1440) % 1440;
+  const targetUtcMidnight = Date.UTC(
+    ymd.year,
+    ymd.month - 1,
+    ymd.day + extraDays,
+    0,
+    0,
+    0,
+    0
+  );
+  const naiveUtcMs = targetUtcMidnight + remMins * 6e4;
+  const offset1 = getTimeZoneOffsetMs(naiveUtcMs, timeZone);
+  const guess1 = naiveUtcMs - offset1;
+  const offset2 = getTimeZoneOffsetMs(guess1, timeZone);
+  const guess2 = naiveUtcMs - offset2;
+  const targetDateObj = new Date(targetUtcMidnight);
+  const expectedDateStr = targetDateObj.toISOString().slice(0, 10);
+  const check2 = extractZonedWallClock(guess2, timeZone);
+  if (check2.dateStr === expectedDateStr && check2.minutesOfDay === remMins) {
+    return guess2;
+  }
+  const check1 = extractZonedWallClock(guess1, timeZone);
+  if (check1.dateStr === expectedDateStr && check1.minutesOfDay === remMins) {
+    return guess1;
+  }
+  return strictGap ? null : guess1;
+}
+function parsePeriodTimestampInZone(raw, endOfDay, rawTimeZone) {
+  const trimmed = raw.trim();
+  if (/^\d{4}-\d{2}-\d{2}$/.test(trimmed)) {
+    const ms = wallClockToUtcMs(
+      trimmed,
+      endOfDay ? 1440 : 0,
+      rawTimeZone,
+      false
+    );
+    if (ms === null) return Number.NaN;
+    return endOfDay ? ms - 1 : ms;
+  }
+  if (/^\d{4}-\d{2}-\d{2}/.test(trimmed)) {
+    if (!parseIsoDateYmd(trimmed.slice(0, 10))) {
+      return Number.NaN;
+    }
+  }
+  return Date.parse(trimmed);
+}
+function enumerateLocalDatesInRange(rangeStartMs, rangeEndMs, rawTimeZone, maxDays = 366) {
+  const timeZone = normalizeTimeZone(rawTimeZone);
+  const startWall = extractZonedWallClock(rangeStartMs, timeZone);
+  const endWall = extractZonedWallClock(rangeEndMs, timeZone);
+  const startUtcDay = Date.UTC(
+    startWall.year,
+    startWall.month - 1,
+    startWall.day
+  );
+  const endUtcDay = Date.UTC(endWall.year, endWall.month - 1, endWall.day);
+  const results = [];
+  for (let cursorUtc = startUtcDay, count = 0; cursorUtc <= endUtcDay && count < maxDays; cursorUtc += 864e5, count += 1) {
+    const d = new Date(cursorUtc);
+    results.push({
+      dateStr: d.toISOString().slice(0, 10),
+      dayKey: String(d.getUTCDay())
+    });
+  }
+  return results;
+}
+function parseTimeMinutes(hhmm) {
+  const match = /^(\d{1,2}):(\d{2})$/.exec(hhmm.trim());
+  if (!match) return 9 * 60;
+  const hours = Number.parseInt(match[1], 10);
+  const minutes = Number.parseInt(match[2], 10);
+  if (hours === 24 && minutes === 0) return 1440;
+  const clampedH = Math.min(23, Math.max(0, hours));
+  const clampedM = Math.min(59, Math.max(0, minutes));
+  return clampedH * 60 + clampedM;
+}
+function formatTimeMinutes(totalMinutes) {
+  const clamped = Math.max(0, Math.min(24 * 60, totalMinutes));
+  const hours = Math.floor(clamped / 60);
+  const mins = clamped % 60;
+  return `${String(hours).padStart(2, "0")}:${String(mins).padStart(2, "0")}`;
+}
+function extractMonthDay(dateOrMmDd) {
+  const trimmed = dateOrMmDd.trim();
+  const isoDay = trimmed.length >= 10 ? trimmed.slice(0, 10) : trimmed;
+  if (/^\d{4}-\d{2}-\d{2}$/.test(isoDay)) return isoDay.slice(5, 10);
+  if (/^\d{2}-\d{2}$/.test(isoDay)) return isoDay;
+  return "";
+}
+function matchesYearlessRange(dateStr, startStr, endStr) {
+  const [t, s, e] = [dateStr, startStr, endStr].map(extractMonthDay);
+  if (!t || !s || !e) return false;
+  return s <= e ? t >= s && t <= e : t >= s || t <= e;
+}
+function matchesDateOrYearlessRange(dateStr, startStr, endStr, yearless = false) {
+  if (!dateStr || !startStr || !endStr) return false;
+  if (yearless) return matchesYearlessRange(dateStr, startStr, endStr);
+  const [t, s, e] = [dateStr, startStr, endStr].map(
+    (d) => d.trim().slice(0, 10)
+  );
+  return t >= s && t <= e;
+}
+function matchesSingleDateOrYearless(dateStr, ruleDateStr, yearless = false) {
+  return matchesDateOrYearlessRange(
+    dateStr,
+    ruleDateStr,
+    ruleDateStr,
+    yearless
+  );
+}
+function isSlotBlackedOut(slotStartMs, slotEndMs, blackoutDates, rawTimeZone) {
+  const timeZone = normalizeTimeZone(rawTimeZone);
+  const slotDateStr = extractZonedWallClock(slotStartMs, timeZone).dateStr;
+  return blackoutDates.some((period) => {
+    if (!period?.start || !period?.end) return false;
+    if (period.yearless) {
+      return matchesDateOrYearlessRange(
+        slotDateStr,
+        period.start,
+        period.end,
+        true
+      );
+    }
+    const startMs = parsePeriodTimestampInZone(period.start, false, timeZone);
+    const endMs = parsePeriodTimestampInZone(period.end, true, timeZone);
+    return !Number.isNaN(startMs) && !Number.isNaN(endMs) && slotStartMs < endMs && slotEndMs > startMs;
+  });
+}
+function findMatchingHoliday(dateStr, globalHolidays = [], resourceHolidays = []) {
+  return [
+    ...Array.isArray(globalHolidays) ? globalHolidays : [],
+    ...Array.isArray(resourceHolidays) ? resourceHolidays : []
+  ].filter(
+    (r) => Boolean(r?.date) && matchesSingleDateOrYearless(dateStr, r.date, Boolean(r.yearless))
+  ).pop();
+}
+function findWinningSeasonalSchedule(dateStr, globalSeasonalSchedules = [], resourceSeasonals = []) {
+  return [
+    ...Array.isArray(globalSeasonalSchedules) ? globalSeasonalSchedules : [],
+    ...Array.isArray(resourceSeasonals) ? resourceSeasonals : []
+  ].filter(
+    (s) => s?.schedule && matchesDateOrYearlessRange(
+      dateStr,
+      s.startDate,
+      s.endDate,
+      Boolean(s.yearless)
+    )
+  ).sort((a, b) => (a.priority ?? 0) - (b.priority ?? 0)).pop();
+}
+function resolveDailyScheduleForDate(dateStr, dayKey, resource, globalSeasonalSchedules = [], globalHolidays = []) {
+  const baseSchedule = resource.weeklySchedule?.days ? resource.weeklySchedule : DEFAULT_WEEKLY_SCHEDULE;
+  const baseMode = baseSchedule.mode ?? "interval";
+  const baseDurationMins = Math.max(5, resource.slotDurationMinutes || 60);
+  const holiday = findMatchingHoliday(
+    dateStr,
+    globalHolidays,
+    resource.holidayRules
+  );
+  if (holiday) {
+    const hasCustom = Array.isArray(holiday.windows) && holiday.windows.length > 0;
+    const isClosed = (holiday.isClosed ?? !hasCustom) || !hasCustom;
+    return {
+      mode: isClosed ? baseMode : holiday.mode ?? baseMode,
+      durationMins: baseDurationMins,
+      windows: isClosed ? [] : holiday.windows ?? [],
+      scheduleLabel: holiday.name
+    };
+  }
+  const seasonal = findWinningSeasonalSchedule(
+    dateStr,
+    globalSeasonalSchedules,
+    resource.seasonalSchedules
+  );
+  if (seasonal) {
+    return {
+      mode: seasonal.schedule.mode ?? baseMode,
+      durationMins: Math.max(
+        5,
+        seasonal.slotDurationMinutes ?? baseDurationMins
+      ),
+      windows: seasonal.schedule.days?.[dayKey] ?? [],
+      scheduleLabel: seasonal.label
+    };
+  }
+  return {
+    mode: baseMode,
+    durationMins: baseDurationMins,
+    windows: baseSchedule.days?.[dayKey] ?? []
+  };
+}
+function isActiveBookingStatus(status) {
+  return status === "pending" || status === "confirmed";
+}
+function doesBookingOverlapSlot(booking, slotStartMs, slotEndMs, bufferBeforeMinutes = 0, bufferAfterMinutes = 0) {
+  if (!isActiveBookingStatus(booking.status)) return false;
+  const bStart = Date.parse(booking.startDate);
+  const bEnd = Date.parse(booking.endDate);
+  if (Number.isNaN(bStart) || Number.isNaN(bEnd)) return false;
+  return slotStartMs < bEnd + bufferAfterMinutes * 6e4 && slotEndMs > bStart - bufferBeforeMinutes * 6e4;
+}
+function selectAvailableHostsForSlot(resource, overlappingBookings, preferredLanguage) {
+  const rawHosts = Array.isArray(resource.assignedHosts) ? resource.assignedHosts : [];
+  const hosts = rawHosts.filter(
+    (h) => Boolean(h) && typeof h.id === "string" && h.id.trim().length > 0 && typeof h.name === "string" && h.name.trim().length > 0
+  );
+  if (hosts.length === 0) return [];
+  const busy = new Set(
+    overlappingBookings.map(
+      (b) => typeof b.assignedHost === "string" ? b.assignedHost.trim().toLowerCase() : ""
+    ).filter((v) => Boolean(v))
+  );
+  const freeHosts = hosts.filter(
+    (h) => !busy.has(h.id.trim().toLowerCase()) && !busy.has(h.name.trim().toLowerCase())
+  );
+  if (!preferredLanguage) return freeHosts;
+  const lang = preferredLanguage.trim().toLowerCase();
+  const matching = freeHosts.filter(
+    (h) => Array.isArray(h.languages) && h.languages.some(
+      (l) => typeof l === "string" && l.trim().toLowerCase() === lang
+    )
+  );
+  return matching.length > 0 ? matching : freeHosts;
+}
+function buildWindowCandidateBlocks(win, mode, durationMins, bufferBefore, bufferAfter, defaultCapacity) {
+  const winStartMins = parseTimeMinutes(win.start);
+  const winEndMins = parseTimeMinutes(win.end);
+  if (winEndMins <= winStartMins) return [];
+  const cap = win.capacity ?? defaultCapacity;
+  if (mode === "window") {
+    return [
+      {
+        startMins: winStartMins,
+        endMins: winEndMins,
+        label: win.label || `${win.start}-${win.end}`,
+        capacity: cap
+      }
+    ];
+  }
+  const blocks = [];
+  const stepMins = Math.max(5, durationMins + bufferBefore + bufferAfter);
+  for (let cursorMins = winStartMins; cursorMins + durationMins <= winEndMins; cursorMins += stepMins) {
+    const blockEndMins = cursorMins + durationMins;
+    const isExactMatch = Boolean(
+      win.label && winStartMins + durationMins === winEndMins
+    );
+    blocks.push({
+      startMins: cursorMins,
+      endMins: blockEndMins,
+      label: isExactMatch ? String(win.label) : `${formatTimeMinutes(cursorMins)}-${formatTimeMinutes(blockEndMins)}`,
+      capacity: cap
+    });
+  }
+  return blocks;
+}
+function evaluateCandidateBlockToSlot(block, slotStartMs, slotEndMs, dateStr, scheduleLabel, params, resourceBookings) {
+  const {
+    resource,
+    partySize = 1,
+    preferredLanguage,
+    secondaryCalendars = []
+  } = params;
+  const bufferBefore = Math.max(0, resource.bufferBeforeMinutes || 0);
+  const bufferAfter = Math.max(0, resource.bufferAfterMinutes || 0);
+  const overlapping = resourceBookings.filter(
+    (b) => doesBookingOverlapSlot(b, slotStartMs, slotEndMs, bufferBefore, bufferAfter)
+  );
+  const bookedCount = overlapping.reduce(
+    (sum, b) => sum + Math.max(1, Number(b.partySize) || 1),
+    0
+  );
+  const capacity = Math.max(1, block.capacity || resource.capacityPerSlot || 1);
+  const remainingCapacity = Math.max(0, capacity - bookedCount);
+  const maxParty = resource.maxPartySize > 0 ? Math.min(capacity, resource.maxPartySize) : capacity;
+  const validParty = typeof partySize === "number" && Number.isInteger(partySize) && partySize >= 1;
+  return {
+    slotId: `${resource.documentId}:${dateStr}:${block.label}`,
+    resourceDocumentId: resource.documentId,
+    resourceName: resource.name,
+    resourceSlug: resource.slug,
+    start: new Date(slotStartMs).toISOString(),
+    end: new Date(slotEndMs).toISOString(),
+    date: dateStr,
+    slotLabel: block.label,
+    scheduleLabel,
+    capacity,
+    bookedCount,
+    remainingCapacity,
+    isAvailable: validParty && remainingCapacity >= partySize && partySize <= maxParty,
+    availableHosts: selectAvailableHostsForSlot(
+      resource,
+      overlapping,
+      preferredLanguage
+    ),
+    secondaryDates: secondaryCalendars.length > 0 ? formatSecondaryCalendars(new Date(slotStartMs), secondaryCalendars) : void 0
+  };
+}
+function computeAvailableSlots(params) {
+  const {
+    resource,
+    from,
+    to,
+    existingBookings,
+    globalSeasonalSchedules = [],
+    globalHolidays = [],
+    referenceNow
+  } = params;
+  const timeZone = normalizeTimeZone(resource.timezone);
+  const rangeStartMs = parsePeriodTimestampInZone(from, false, timeZone);
+  const rangeEndMs = parsePeriodTimestampInZone(to, true, timeZone);
+  if (!resource.isActive || Number.isNaN(rangeStartMs) || Number.isNaN(rangeEndMs) || rangeEndMs < rangeStartMs) {
+    return [];
+  }
+  const bufferBefore = Math.max(0, resource.bufferBeforeMinutes || 0);
+  const bufferAfter = Math.max(0, resource.bufferAfterMinutes || 0);
+  const resourceBookings = existingBookings.filter(
+    (b) => b.resourceDocumentId === resource.documentId && isActiveBookingStatus(b.status)
+  );
+  const nowMs = referenceNow instanceof Date && !Number.isNaN(referenceNow.getTime()) ? referenceNow.getTime() : null;
+  const minAllowedMs = nowMs !== null ? nowMs + Math.max(0, resource.minLeadTimeHours || 0) * 36e5 : null;
+  const maxAllowedMs = nowMs !== null && resource.maxAdvanceDays > 0 ? nowMs + resource.maxAdvanceDays * 864e5 : null;
+  const blackoutDates = resource.blackoutDates ?? [];
+  const slots = [];
+  const localDates = enumerateLocalDatesInRange(
+    rangeStartMs,
+    rangeEndMs,
+    timeZone,
+    366
+  );
+  for (const { dateStr, dayKey } of localDates) {
+    const { mode, durationMins, windows, scheduleLabel } = resolveDailyScheduleForDate(
+      dateStr,
+      dayKey,
+      resource,
+      globalSeasonalSchedules,
+      globalHolidays
+    );
+    const dayBlocks = windows.flatMap(
+      (win) => buildWindowCandidateBlocks(
+        win,
+        mode,
+        durationMins,
+        bufferBefore,
+        bufferAfter,
+        resource.capacityPerSlot
+      )
+    );
+    for (const block of dayBlocks) {
+      const slotStartMs = wallClockToUtcMs(
+        dateStr,
+        block.startMins,
+        timeZone,
+        true
+      );
+      const slotEndMs = wallClockToUtcMs(
+        dateStr,
+        block.endMins,
+        timeZone,
+        false
+      );
+      if (slotStartMs === null || slotEndMs === null || slotEndMs <= slotStartMs) {
+        continue;
+      }
+      const permitted = slotEndMs > rangeStartMs && slotStartMs <= rangeEndMs && (minAllowedMs === null || slotStartMs >= minAllowedMs) && (maxAllowedMs === null || slotStartMs <= maxAllowedMs) && !isSlotBlackedOut(slotStartMs, slotEndMs, blackoutDates, timeZone);
+      if (permitted) {
+        slots.push(
+          evaluateCandidateBlockToSlot(
+            block,
+            slotStartMs,
+            slotEndMs,
+            dateStr,
+            scheduleLabel,
+            params,
+            resourceBookings
+          )
+        );
+      }
+    }
+  }
+  return slots;
+}
+function escapeICalText(text) {
+  return text.replace(/\\/g, "\\\\").replace(/;/g, "\\;").replace(/,/g, "\\,").replace(/\r\n|\r|\n/g, "\\n");
+}
+function formatICalDateUtc(isoDate) {
+  const date = new Date(isoDate);
+  if (Number.isNaN(date.getTime())) {
+    return "19700101T000000Z";
+  }
+  return date.toISOString().replace(/[-:]/g, "").replace(/\.\d{3}Z$/, "Z");
+}
+function computeFallbackOpaqueUid(seed) {
+  let h1 = 3735928559 ^ seed.length;
+  let h2 = 1103547991 ^ seed.length;
+  for (let i = 0; i < seed.length; i += 1) {
+    const ch = seed.charCodeAt(i);
+    h1 = Math.imul(h1 ^ ch, 2654435761);
+    h2 = Math.imul(h2 ^ ch, 1597334677);
+  }
+  h1 = Math.imul(h1 ^ h1 >>> 16, 2246822507) ^ Math.imul(h2 ^ h2 >>> 13, 3266489909);
+  h2 = Math.imul(h2 ^ h2 >>> 16, 2246822507) ^ Math.imul(h1 ^ h1 >>> 13, 3266489909);
+  const hex1 = (h1 >>> 0).toString(16).padStart(8, "0");
+  const hex2 = (h2 >>> 0).toString(16).padStart(8, "0");
+  return `opaque-${hex1}${hex2}`;
+}
+function foldICalLine(line) {
+  const encoder = new TextEncoder();
+  const maxOctets = 75;
+  if (encoder.encode(line).length <= maxOctets) {
+    return line;
+  }
+  const chunks = [];
+  let current = "";
+  for (const char of line) {
+    const candidate = current + char;
+    const limit = chunks.length === 0 ? maxOctets : maxOctets - 1;
+    if (encoder.encode(candidate).length > limit) {
+      chunks.push(current);
+      current = char;
+    } else {
+      current = candidate;
+    }
+  }
+  if (current.length > 0) {
+    chunks.push(current);
+  }
+  return chunks.join("\r\n ");
+}
+function buildBookingVEventLines(booking, nowStamp, options) {
+  const anonymize = Boolean(options?.anonymize);
+  const dtStart = formatICalDateUtc(booking.startDate);
+  const dtEnd = formatICalDateUtc(booking.endDate);
+  const statusMap = {
+    confirmed: "CONFIRMED",
+    completed: "CONFIRMED",
+    pending: "TENTATIVE",
+    cancelled: "CANCELLED",
+    no_show: "CANCELLED"
+  };
+  const uidLocal = anonymize ? options?.opaqueUids?.[booking.documentId] ?? computeFallbackOpaqueUid(`${booking.documentId}:${booking.startDate}`) : booking.bookingCode || booking.documentId;
+  const uid = `${uidLocal}@strapi-plugin-bookings`;
+  const summary = anonymize ? "Reserved" : booking.title || booking.customerName;
+  const descriptionParts = anonymize ? [
+    "Status: Busy",
+    ...booking.resourceName ? [`Resource: ${booking.resourceName}`] : []
+  ] : [
+    `Booking Code: ${booking.bookingCode}`,
+    `Customer: ${booking.customerName}`,
+    `Party Size: ${booking.partySize}`,
+    `Status: ${booking.status}`,
+    ...booking.resourceName ? [`Resource: ${booking.resourceName}`] : [],
+    ...booking.assignedHost ? [`Assigned Staff/Host: ${booking.assignedHost}`] : [],
+    ...booking.notes ? [`Notes: ${booking.notes}`] : []
+  ];
+  return [
+    "BEGIN:VEVENT",
+    foldICalLine(`UID:${escapeICalText(uid)}`),
+    `DTSTAMP:${nowStamp}`,
+    `DTSTART:${dtStart}`,
+    `DTEND:${dtEnd}`,
+    foldICalLine(`SUMMARY:${escapeICalText(summary)}`),
+    foldICalLine(`DESCRIPTION:${escapeICalText(descriptionParts.join("\n"))}`),
+    `STATUS:${statusMap[booking.status] || "TENTATIVE"}`,
+    "END:VEVENT"
+  ];
+}
+function generateBookingsICalFeed(bookings, calendarName = "Strapi Bookings & Reservations", options) {
+  const nowStamp = formatICalDateUtc((/* @__PURE__ */ new Date()).toISOString());
+  const lines = [
+    "BEGIN:VCALENDAR",
+    "VERSION:2.0",
+    "PRODID:-//Vicacha Devs//Strapi Plugin Bookings//EN",
+    "CALSCALE:GREGORIAN",
+    "METHOD:PUBLISH",
+    foldICalLine(`X-WR-CALNAME:${escapeICalText(calendarName)}`)
+  ];
+  for (const booking of bookings) {
+    lines.push(...buildBookingVEventLines(booking, nowStamp, options));
+  }
+  lines.push("END:VCALENDAR");
+  return `${lines.join("\r\n")}\r
+`;
+}
+function sanitizeCsvCell(value) {
+  if (value === null || value === void 0) {
+    return '""';
+  }
+  let str = String(value);
+  if (/^[\s\u0085\u2028\u2029]*[=+\-@|]|^[\t\r\n]/.test(str)) {
+    str = `'${str}`;
+  }
+  const escaped = str.replace(/"/g, '""');
+  return `"${escaped}"`;
+}
+function generateBookingsCsv(bookings) {
+  const headers = [
+    "Booking Code",
+    "Resource",
+    "Customer Name",
+    "Customer Email",
+    "Customer Phone",
+    "Organization",
+    "Start Date",
+    "End Date",
+    "Slot Label",
+    "Party Size",
+    "Status",
+    "Preferred Language",
+    "Assigned Host",
+    "Notes"
+  ];
+  const rows = bookings.map(
+    (b) => [
+      b.bookingCode,
+      b.resourceName ?? "",
+      b.customerName,
+      b.customerEmail,
+      b.customerPhone ?? "",
+      b.organization ?? "",
+      b.startDate,
+      b.endDate,
+      b.slotLabel ?? "",
+      b.partySize,
+      b.status,
+      b.preferredLanguage ?? "",
+      b.assignedHost ?? "",
+      b.notes ?? ""
+    ].map(sanitizeCsvCell).join(",")
+  );
+  return [headers.map(sanitizeCsvCell).join(","), ...rows].join("\r\n");
+}
+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, "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.DEFAULT_WEEKLY_SCHEDULE = DEFAULT_WEEKLY_SCHEDULE;
+exports.PLUGIN_ID = PLUGIN_ID;
+exports.computeAvailableSlots = computeAvailableSlots;
+exports.doesBookingOverlapSlot = doesBookingOverlapSlot;
+exports.enumerateLocalDatesInRange = enumerateLocalDatesInRange;
+exports.escapeICalText = escapeICalText;
+exports.extractMonthDay = extractMonthDay;
+exports.extractZonedWallClock = extractZonedWallClock;
+exports.foldICalLine = foldICalLine;
+exports.formatSecondaryCalendars = formatSecondaryCalendars;
+exports.formatTimeMinutes = formatTimeMinutes;
+exports.generateBookingsCsv = generateBookingsCsv;
+exports.generateBookingsICalFeed = generateBookingsICalFeed;
+exports.isActiveBookingStatus = isActiveBookingStatus;
+exports.isSlotBlackedOut = isSlotBlackedOut;
+exports.matchesDateOrYearlessRange = matchesDateOrYearlessRange;
+exports.matchesSingleDateOrYearless = matchesSingleDateOrYearless;
+exports.normalizeTimeZone = normalizeTimeZone;
+exports.parseIsoDateYmd = parseIsoDateYmd;
+exports.parsePeriodTimestampInZone = parsePeriodTimestampInZone;
+exports.parseTimeMinutes = parseTimeMinutes;
+exports.resolveDailyScheduleForDate = resolveDailyScheduleForDate;
+exports.sanitizeCsvCell = sanitizeCsvCell;
+exports.selectAvailableHostsForSlot = selectAvailableHostsForSlot;
+exports.wallClockToUtcMs = wallClockToUtcMs;