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

package/dist/admin/CalendarPage-Dq6YfSXF.js

@@ -0,0 +1,1015 @@
+import { jsx, jsxs, Fragment } from "react/jsx-runtime";
+import { Box, Flex, Badge, Typography, Field, DatePicker, Button, Checkbox, DateTimePicker, TextInput, SingleSelect, SingleSelectOption } from "@strapi/design-system";
+import { useFetchClient } from "@strapi/strapi/admin";
+import { useMemo, useRef, useCallback, useState, useEffect } from "react";
+import { useIntl } from "react-intl";
+import { f as formatCategoryLabel, d as describeRRule, a as formatLocalYmd, p as parseDateTimePickerValue, W as WEEKDAYS, b as buildOrderedRecurrencePresets, e as extractByDays, c as alignStartDateToWeekday, P as PLUGIN_ID, g as buildInitialDateWindow, r as resolveFullCalendarLocale, h as resolveCalendarDirection, m as matchLoadedSourceId, i as computeSourceCounts, j as filterVisibleOccurrences, k as collectAvailableCategories, l as resolveActiveSecondaryCalendars, F as FALLBACK_RECURRENCE_PRESETS, n as mapOccurrencesToFullCalendarEvents, o as buildSecondaryHeaderLabel, q as buildEnabledCalendarViews, C as CalendarToolbar, s as FullCalendarCanvas, t as buildQuickCreateRequestPayload, u as normalizeSelectedEndSlot, v as expandDateWindowToYear } from "./index-USqxqyAm.js";
+import { NavLink } from "react-router-dom";
+const OccurrenceDetailDrawer = ({
+  t,
+  occurrence,
+  rescheduleDate,
+  onRescheduleDateChange,
+  applyToSeries,
+  onApplyToSeriesChange,
+  onSaveReschedule,
+  onCancelOccurrence,
+  onClose
+}) => {
+  return /* @__PURE__ */ jsx(
+    Box,
+    {
+      padding: 4,
+      background: "neutral0",
+      hasRadius: true,
+      shadow: "tableShadow",
+      style: { borderLeft: `4px solid ${occurrence.color}` },
+      children: /* @__PURE__ */ jsxs(
+        Flex,
+        {
+          justifyContent: "space-between",
+          alignItems: "flex-start",
+          wrap: "wrap",
+          gap: 4,
+          children: [
+            /* @__PURE__ */ jsxs(Box, { style: { flex: 2, minWidth: 260 }, children: [
+              /* @__PURE__ */ jsxs(Flex, { gap: 2, alignItems: "center", wrap: "wrap", children: [
+                /* @__PURE__ */ jsx(Badge, { backgroundColor: "neutral150", textColor: "neutral800", children: occurrence.sourceLabel }),
+                occurrence.category && /* @__PURE__ */ jsx(Badge, { backgroundColor: "primary100", textColor: "primary700", children: formatCategoryLabel(occurrence.category) }),
+                occurrence.isRecurring && /* @__PURE__ */ jsx(Badge, { backgroundColor: "secondary100", textColor: "secondary700", children: describeRRule(occurrence.rrule) }),
+                occurrence.alternateDates && Object.values(occurrence.alternateDates).map((alt) => /* @__PURE__ */ jsxs(
+                  Badge,
+                  {
+                    backgroundColor: "warning100",
+                    textColor: "warning700",
+                    children: [
+                      alt.label,
+                      ": ",
+                      alt.formatted
+                    ]
+                  },
+                  alt.calendarId
+                ))
+              ] }),
+              /* @__PURE__ */ jsx(Box, { paddingTop: 2, children: /* @__PURE__ */ jsx(Typography, { variant: "delta", fontWeight: "bold", children: occurrence.title }) }),
+              /* @__PURE__ */ jsx(Box, { paddingTop: 1, children: /* @__PURE__ */ jsxs(Typography, { variant: "omega", textColor: "neutral600", children: [
+                occurrence.occurrenceDate,
+                occurrence.location ? ` • ${occurrence.location}` : ""
+              ] }) }),
+              occurrence.customFields && Object.keys(occurrence.customFields).length > 0 && /* @__PURE__ */ jsx(Box, { paddingTop: 2, children: /* @__PURE__ */ jsx(Flex, { gap: 2, wrap: "wrap", children: Object.entries(occurrence.customFields).map(
+                ([k, v]) => v !== null && v !== void 0 && String(v).trim() !== "" ? /* @__PURE__ */ jsxs(
+                  Badge,
+                  {
+                    backgroundColor: "neutral100",
+                    textColor: "neutral700",
+                    children: [
+                      k,
+                      ": ",
+                      String(v)
+                    ]
+                  },
+                  k
+                ) : null
+              ) }) })
+            ] }),
+            /* @__PURE__ */ jsxs(
+              Flex,
+              {
+                direction: "column",
+                alignItems: "flex-end",
+                gap: 2,
+                style: { flex: "1 1 320px", minWidth: 260 },
+                children: [
+                  /* @__PURE__ */ jsxs(
+                    Flex,
+                    {
+                      gap: 2,
+                      alignItems: "flex-end",
+                      wrap: "wrap",
+                      justifyContent: "flex-end",
+                      children: [
+                        /* @__PURE__ */ jsx(Box, { style: { minWidth: 180, maxWidth: 220 }, children: /* @__PURE__ */ jsxs(Field.Root, { children: [
+                          /* @__PURE__ */ jsx(Field.Label, { children: t("calendar.rescheduleTo", "Reschedule Date") }),
+                          /* @__PURE__ */ jsx(
+                            DatePicker,
+                            {
+                              size: "S",
+                              value: parseDateTimePickerValue(rescheduleDate),
+                              clearLabel: t("common.clear", "Clear"),
+                              onChange: (date) => onRescheduleDateChange(date ? formatLocalYmd(date) : ""),
+                              onClear: () => onRescheduleDateChange("")
+                            }
+                          )
+                        ] }) }),
+                        /* @__PURE__ */ jsx(Button, { size: "S", variant: "secondary", onClick: onSaveReschedule, children: t("calendar.rescheduleAction", "Reschedule") })
+                      ]
+                    }
+                  ),
+                  occurrence.isRecurring && /* @__PURE__ */ jsx(
+                    Checkbox,
+                    {
+                      checked: applyToSeries,
+                      onCheckedChange: (checked) => onApplyToSeriesChange(Boolean(checked)),
+                      children: t("calendar.applyToSeries", "Apply to entire recurring series")
+                    }
+                  ),
+                  /* @__PURE__ */ jsxs(Flex, { gap: 2, wrap: "wrap", justifyContent: "flex-end", paddingTop: 1, children: [
+                    /* @__PURE__ */ jsx(
+                      Button,
+                      {
+                        size: "S",
+                        variant: "tertiary",
+                        tag: NavLink,
+                        to: `/content-manager/collection-types/${occurrence.uid}/${occurrence.documentId}${occurrence.locale ? `?plugins[i18n][locale]=${encodeURIComponent(occurrence.locale)}` : ""}`,
+                        children: t("calendar.editInContentManager", "Open in Content Manager")
+                      }
+                    ),
+                    /* @__PURE__ */ jsx(
+                      Button,
+                      {
+                        size: "S",
+                        variant: "tertiary",
+                        tag: "a",
+                        href: occurrence.calendarLinks.icsPath,
+                        target: "_blank",
+                        rel: "noopener noreferrer",
+                        children: t("calendar.downloadIcs", ".ICS")
+                      }
+                    ),
+                    /* @__PURE__ */ jsx(
+                      Button,
+                      {
+                        size: "S",
+                        variant: "danger-light",
+                        onClick: onCancelOccurrence,
+                        children: t("calendar.cancelInstance", "Cancel Occurrence")
+                      }
+                    ),
+                    /* @__PURE__ */ jsx(Button, { size: "S", variant: "tertiary", onClick: onClose, children: t("common.close", "Close") })
+                  ] })
+                ]
+              }
+            )
+          ]
+        }
+      )
+    }
+  );
+};
+function resolveActiveQuickSource(enabledSources, selectedSourceId) {
+  if (enabledSources.length === 0) return void 0;
+  if (selectedSourceId) {
+    const exact = enabledSources.find(
+      (s) => s.id === selectedSourceId || s.uid === selectedSourceId
+    );
+    if (exact) return exact;
+  }
+  return enabledSources[0];
+}
+function sourceIncludesKeyword(source, keyword) {
+  if (!source) return false;
+  return source.id.toLowerCase().includes(keyword) || source.uid.toLowerCase().includes(keyword);
+}
+function computeToggledWeekdays(selectedWeekdays, code) {
+  if (selectedWeekdays.includes(code)) {
+    return selectedWeekdays.length > 1 ? selectedWeekdays.filter((d) => d !== code) : [code];
+  }
+  return WEEKDAYS.map((w) => w.code).filter(
+    (c) => c === code || selectedWeekdays.includes(c)
+  );
+}
+const QuickCreateHeader = ({
+  t,
+  isBookingSource,
+  isEventSource,
+  activeSource,
+  enabledSources,
+  onSelectedSourceIdChange
+}) => {
+  const headingText = isBookingSource ? t("calendar.quickCreateBookingTitle", "New Booking / Reservation") : isEventSource ? t("calendar.quickCreateEventTitle", "New Calendar Event") : t("calendar.quickCreateTitle", "Quick-Create Calendar Entry");
+  return /* @__PURE__ */ jsxs(
+    Flex,
+    {
+      justifyContent: "space-between",
+      alignItems: "center",
+      wrap: "wrap",
+      gap: 2,
+      children: [
+        /* @__PURE__ */ jsxs(Flex, { alignItems: "center", gap: 2, wrap: "wrap", children: [
+          /* @__PURE__ */ jsx(Typography, { variant: "delta", fontWeight: "bold", children: headingText }),
+          activeSource && /* @__PURE__ */ jsx(Badge, { backgroundColor: "neutral150", textColor: "neutral800", children: activeSource.label })
+        ] }),
+        enabledSources.length > 1 && onSelectedSourceIdChange && /* @__PURE__ */ jsxs(Flex, { gap: 1, wrap: "wrap", alignItems: "center", children: [
+          /* @__PURE__ */ jsx(Typography, { variant: "pi", textColor: "neutral600", children: t("calendar.targetSource", "Create in:") }),
+          enabledSources.map((src) => {
+            const isSelected = activeSource?.id === src.id;
+            return /* @__PURE__ */ jsxs(
+              Button,
+              {
+                size: "S",
+                variant: isSelected ? "default" : "tertiary",
+                onClick: () => onSelectedSourceIdChange(src.id),
+                children: [
+                  /* @__PURE__ */ jsx(
+                    "span",
+                    {
+                      style: {
+                        display: "inline-block",
+                        width: 8,
+                        height: 8,
+                        borderRadius: "50%",
+                        background: src.color,
+                        marginRight: 6
+                      }
+                    }
+                  ),
+                  src.label
+                ]
+              },
+              src.id
+            );
+          })
+        ] })
+      ]
+    }
+  );
+};
+const BookingVisitorFields = ({
+  t,
+  isBookingSource,
+  quickCustomerName,
+  onQuickCustomerNameChange,
+  quickCustomerEmail,
+  onQuickCustomerEmailChange,
+  quickPartySize,
+  onQuickPartySizeChange
+}) => {
+  if (!isBookingSource) return null;
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    onQuickCustomerNameChange && /* @__PURE__ */ jsxs(Field.Root, { children: [
+      /* @__PURE__ */ jsx(Field.Label, { children: t("calendar.field.customerName", "Visitor / Customer Name") }),
+      /* @__PURE__ */ jsx(
+        TextInput,
+        {
+          value: quickCustomerName,
+          onChange: (e) => onQuickCustomerNameChange(e.target.value),
+          placeholder: t(
+            "placeholder.customer_name",
+            "Defaults to reservation title if omitted"
+          )
+        }
+      )
+    ] }),
+    onQuickCustomerEmailChange && /* @__PURE__ */ jsxs(Field.Root, { children: [
+      /* @__PURE__ */ jsx(Field.Label, { children: t("calendar.field.customerEmail", "Visitor / Customer Email") }),
+      /* @__PURE__ */ jsx(
+        TextInput,
+        {
+          value: quickCustomerEmail,
+          onChange: (e) => onQuickCustomerEmailChange(e.target.value),
+          placeholder: t("placeholder.customer_email", "guest@example.com")
+        }
+      )
+    ] }),
+    onQuickPartySizeChange && /* @__PURE__ */ jsxs(Field.Root, { children: [
+      /* @__PURE__ */ jsx(Field.Label, { children: t("calendar.field.partySize", "Party Size (Guests)") }),
+      /* @__PURE__ */ jsx(
+        TextInput,
+        {
+          type: "number",
+          value: String(quickPartySize || 1),
+          onChange: (e) => onQuickPartySizeChange(
+            Math.max(1, Number.parseInt(e.target.value || "1", 10) || 1)
+          )
+        }
+      )
+    ] })
+  ] });
+};
+const QuickCreateRecurrenceSelect = ({
+  t,
+  supportsRecurrence,
+  quickRRule,
+  normalizedPresets,
+  hasCustomWeeklyOption,
+  customWeeklyLabel,
+  onRecurrenceSelect
+}) => {
+  if (!supportsRecurrence) return null;
+  return /* @__PURE__ */ jsxs(Field.Root, { children: [
+    /* @__PURE__ */ jsx(Field.Label, { children: t("calendar.field.recurrence", "Recurrence Preset") }),
+    /* @__PURE__ */ jsxs(
+      SingleSelect,
+      {
+        placeholder: t(
+          "placeholder.select_recurrence_preset",
+          "Select recurrence preset"
+        ),
+        value: quickRRule || "NONE",
+        onChange: onRecurrenceSelect,
+        children: [
+          /* @__PURE__ */ jsx(SingleSelectOption, { value: "NONE", children: t("calendar.singleEntry", "Single Entry") }),
+          normalizedPresets.map((preset) => /* @__PURE__ */ jsx(SingleSelectOption, { value: preset.rrule, children: preset.label }, preset.id)),
+          hasCustomWeeklyOption && /* @__PURE__ */ jsx(SingleSelectOption, { value: quickRRule, children: customWeeklyLabel })
+        ]
+      }
+    )
+  ] });
+};
+const QuickCreateDateFields = ({
+  t,
+  startDateValue,
+  endDateValue,
+  onStartDateChange,
+  onQuickEndChange
+}) => /* @__PURE__ */ jsxs(Fragment, { children: [
+  /* @__PURE__ */ jsxs(Field.Root, { required: true, children: [
+    /* @__PURE__ */ jsx(Field.Label, { children: t("calendar.field.startDate", "Start Date / Time") }),
+    /* @__PURE__ */ jsx(
+      DateTimePicker,
+      {
+        value: startDateValue,
+        step: 15,
+        clearLabel: t("common.clear", "Clear"),
+        onChange: (date) => onStartDateChange(date ? date.toISOString() : ""),
+        onClear: () => onStartDateChange("")
+      }
+    )
+  ] }),
+  onQuickEndChange && /* @__PURE__ */ jsxs(
+    Field.Root,
+    {
+      hint: t(
+        "placeholder.end_date_optional",
+        "Defaults to +1 hour if omitted"
+      ),
+      children: [
+        /* @__PURE__ */ jsx(Field.Label, { children: t("calendar.field.endDate", "End Date / Time (optional)") }),
+        /* @__PURE__ */ jsx(
+          DateTimePicker,
+          {
+            value: endDateValue,
+            step: 15,
+            clearLabel: t("common.clear", "Clear"),
+            onChange: (date) => onQuickEndChange(date ? date.toISOString() : ""),
+            onClear: () => onQuickEndChange("")
+          }
+        ),
+        /* @__PURE__ */ jsx(Field.Hint, {})
+      ]
+    }
+  )
+] });
+function resolveSubmitLabel(t, isBookingSource, isEventSource) {
+  if (isBookingSource) return t("calendar.createBooking", "Create Booking");
+  if (isEventSource) return t("calendar.createEvent", "Create Event");
+  return t("common.create", "Create Entry");
+}
+function resolveTitleAndLocationLabels(t, isBookingSource) {
+  return {
+    titleLabel: isBookingSource ? t("calendar.field.bookingTitle", "Reservation Title / Purpose") : t("calendar.field.title", "Title"),
+    titlePlaceholder: isBookingSource ? t(
+      "placeholder.booking_title",
+      "e.g., Guided Visit / Hall Reservation / Counseling"
+    ) : t(
+      "placeholder.e_g_product_launch_workshop_reservation",
+      "e.g., Product Launch / Workshop / Reservation"
+    ),
+    locationLabel: isBookingSource ? t("calendar.field.assignedHost", "Assigned Host / Resource") : t("calendar.field.location", "Location"),
+    locationPlaceholder: isBookingSource ? t("placeholder.assigned_host", "Main Hall / Host / Coordinator") : t("placeholder.room_101_online", "Room 101 / Online")
+  };
+}
+const QuickCreatePanel = (props) => {
+  const {
+    t,
+    sources = [],
+    selectedSourceId = "",
+    onSelectedSourceIdChange,
+    quickTitle,
+    onQuickTitleChange,
+    quickStart,
+    onQuickStartChange,
+    quickEnd = "",
+    onQuickEndChange,
+    quickLocation,
+    onQuickLocationChange,
+    quickRRule,
+    onQuickRRuleChange,
+    quickCustomerName = "",
+    onQuickCustomerNameChange,
+    quickCustomerEmail = "",
+    onQuickCustomerEmailChange,
+    quickPartySize = 1,
+    onQuickPartySizeChange,
+    recurrencePresets,
+    onCancel,
+    onSubmit
+  } = props;
+  const enabledSources = useMemo(
+    () => sources.filter((s) => s.enabled !== false),
+    [sources]
+  );
+  const activeSource = useMemo(
+    () => resolveActiveQuickSource(enabledSources, selectedSourceId),
+    [enabledSources, selectedSourceId]
+  );
+  const isBookingSource = useMemo(
+    () => sourceIncludesKeyword(activeSource, "booking"),
+    [activeSource]
+  );
+  const isEventSource = useMemo(
+    () => !activeSource || sourceIncludesKeyword(activeSource, "event"),
+    [activeSource]
+  );
+  const supportsRecurrence = useMemo(
+    () => !isBookingSource || Boolean(activeSource?.fields?.rrule),
+    [activeSource, isBookingSource]
+  );
+  const startDateValue = useMemo(
+    () => parseDateTimePickerValue(quickStart),
+    [quickStart]
+  );
+  const endDateValue = useMemo(
+    () => parseDateTimePickerValue(quickEnd),
+    [quickEnd]
+  );
+  const normalizedPresets = useMemo(
+    () => buildOrderedRecurrencePresets(recurrencePresets, startDateValue),
+    [recurrencePresets, startDateValue]
+  );
+  const isWeekly = supportsRecurrence && quickRRule.toUpperCase().includes("FREQ=WEEKLY");
+  const selectedWeekdays = useMemo(
+    () => extractByDays(quickRRule),
+    [quickRRule]
+  );
+  const hasCustomWeeklyOption = isWeekly && !normalizedPresets.some((p) => p.rrule === quickRRule);
+  const customWeeklyLabel = `${t("rrule.freq.weekly", "Weekly")} (${selectedWeekdays.join(", ")})`;
+  const alignSingleDayRRule = (days) => {
+    if (days.length === 1 && quickStart) {
+      const aligned = alignStartDateToWeekday(quickStart, days[0]);
+      if (aligned !== quickStart) onQuickStartChange(aligned);
+    }
+  };
+  const handleRecurrenceSelect = (val) => {
+    const strVal = String(val);
+    const nextRRule = strVal === "NONE" ? "" : strVal;
+    onQuickRRuleChange(nextRRule);
+    if (nextRRule.toUpperCase().includes("FREQ=WEEKLY")) {
+      alignSingleDayRRule(extractByDays(nextRRule));
+    }
+  };
+  const handleToggleWeekday = (code) => {
+    const nextDays = computeToggledWeekdays(selectedWeekdays, code);
+    onQuickRRuleChange(`FREQ=WEEKLY;INTERVAL=1;BYDAY=${nextDays.join(",")}`);
+    alignSingleDayRRule(nextDays);
+  };
+  const handleStartDateChange = (nextDateStr) => {
+    onQuickStartChange(nextDateStr);
+    if (!isWeekly || selectedWeekdays.length !== 1 || !nextDateStr) return;
+    const dt = parseDateTimePickerValue(nextDateStr);
+    const match = dt ? WEEKDAYS.find((w) => w.jsDay === dt.getDay()) : void 0;
+    if (match && match.code !== selectedWeekdays[0]) {
+      onQuickRRuleChange(`FREQ=WEEKLY;INTERVAL=1;BYDAY=${match.code}`);
+    }
+  };
+  const labels = resolveTitleAndLocationLabels(t, isBookingSource);
+  const submitLabel = resolveSubmitLabel(t, isBookingSource, isEventSource);
+  const canSubmit = Boolean(quickTitle.trim() && quickStart.trim());
+  const borderColor = activeSource?.color || "#0284C7";
+  return /* @__PURE__ */ jsx(
+    Box,
+    {
+      padding: 4,
+      background: "neutral0",
+      hasRadius: true,
+      shadow: "tableShadow",
+      style: { borderLeft: `4px solid ${borderColor}` },
+      children: /* @__PURE__ */ jsxs(Flex, { direction: "column", alignItems: "stretch", gap: 3, children: [
+        /* @__PURE__ */ jsx(
+          QuickCreateHeader,
+          {
+            t,
+            isBookingSource,
+            isEventSource,
+            activeSource,
+            enabledSources,
+            onSelectedSourceIdChange
+          }
+        ),
+        /* @__PURE__ */ jsxs(
+          "div",
+          {
+            style: {
+              display: "grid",
+              gridTemplateColumns: "repeat(2, minmax(0, 1fr))",
+              gap: 16
+            },
+            children: [
+              enabledSources.length > 1 && onSelectedSourceIdChange && /* @__PURE__ */ jsxs(Field.Root, { children: [
+                /* @__PURE__ */ jsx(Field.Label, { children: t("calendar.field.sourceType", "Entry Collection / Type") }),
+                /* @__PURE__ */ jsx(
+                  SingleSelect,
+                  {
+                    value: activeSource?.id || "",
+                    onChange: (val) => onSelectedSourceIdChange(String(val)),
+                    children: enabledSources.map((src) => /* @__PURE__ */ jsx(SingleSelectOption, { value: src.id, children: `${src.label} (${src.uid})` }, src.id))
+                  }
+                )
+              ] }),
+              /* @__PURE__ */ jsxs(Field.Root, { required: true, children: [
+                /* @__PURE__ */ jsx(Field.Label, { children: labels.titleLabel }),
+                /* @__PURE__ */ jsx(
+                  TextInput,
+                  {
+                    value: quickTitle,
+                    onChange: (e) => onQuickTitleChange(e.target.value),
+                    placeholder: labels.titlePlaceholder
+                  }
+                )
+              ] }),
+              /* @__PURE__ */ jsx(
+                QuickCreateDateFields,
+                {
+                  t,
+                  startDateValue,
+                  endDateValue,
+                  onStartDateChange: handleStartDateChange,
+                  onQuickEndChange
+                }
+              ),
+              /* @__PURE__ */ jsxs(Field.Root, { children: [
+                /* @__PURE__ */ jsx(Field.Label, { children: labels.locationLabel }),
+                /* @__PURE__ */ jsx(
+                  TextInput,
+                  {
+                    value: quickLocation,
+                    onChange: (e) => onQuickLocationChange(e.target.value),
+                    placeholder: labels.locationPlaceholder
+                  }
+                )
+              ] }),
+              /* @__PURE__ */ jsx(
+                BookingVisitorFields,
+                {
+                  t,
+                  isBookingSource,
+                  quickCustomerName,
+                  onQuickCustomerNameChange,
+                  quickCustomerEmail,
+                  onQuickCustomerEmailChange,
+                  quickPartySize,
+                  onQuickPartySizeChange
+                }
+              ),
+              /* @__PURE__ */ jsx(
+                QuickCreateRecurrenceSelect,
+                {
+                  t,
+                  supportsRecurrence,
+                  quickRRule,
+                  normalizedPresets,
+                  hasCustomWeeklyOption,
+                  customWeeklyLabel,
+                  onRecurrenceSelect: handleRecurrenceSelect
+                }
+              )
+            ]
+          }
+        ),
+        isWeekly && /* @__PURE__ */ jsx(Box, { padding: 3, background: "neutral100", hasRadius: true, children: /* @__PURE__ */ jsxs(Flex, { alignItems: "center", gap: 2, wrap: "wrap", children: [
+          /* @__PURE__ */ jsx(Typography, { variant: "pi", fontWeight: "bold", textColor: "neutral700", children: t(
+            "calendar.field.repeatWeekdays",
+            "Repeat on Day(s) of Week:"
+          ) }),
+          WEEKDAYS.map((day) => /* @__PURE__ */ jsx(
+            Button,
+            {
+              size: "S",
+              variant: selectedWeekdays.includes(day.code) ? "default" : "tertiary",
+              onClick: () => handleToggleWeekday(day.code),
+              children: t(`weekday.${day.code.toLowerCase()}`, day.label)
+            },
+            day.code
+          ))
+        ] }) }),
+        /* @__PURE__ */ jsxs(Flex, { gap: 2, justifyContent: "flex-end", children: [
+          /* @__PURE__ */ jsx(Button, { variant: "tertiary", onClick: onCancel, children: t("common.cancel", "Cancel") }),
+          /* @__PURE__ */ jsx(Button, { variant: "default", onClick: onSubmit, disabled: !canSubmit, children: submitLabel })
+        ] })
+      ] })
+    }
+  );
+};
+const getUrlParam = (key) => typeof window === "undefined" ? null : new URLSearchParams(window.location.search).get(key);
+const CalendarPage = () => {
+  const { formatMessage, locale } = useIntl();
+  const { get, post } = useFetchClient();
+  const calendarRef = useRef(null);
+  const quickCreateRef = useRef(null);
+  const initialViewSyncedRef = useRef(false);
+  const t = useCallback(
+    (id, defaultMessage) => formatMessage({ id: `${PLUGIN_ID}.${id}`, defaultMessage }),
+    [formatMessage]
+  );
+  const [viewMode, setViewMode] = useState("dayGridMonth");
+  const [anchorDate, setAnchorDate] = useState(() => /* @__PURE__ */ new Date());
+  const [dateWindow, setDateWindow] = useState(buildInitialDateWindow);
+  const [sourceFilter, setSourceFilter] = useState(
+    () => getUrlParam("source") || "all"
+  );
+  const [categoryFilter, setCategoryFilter] = useState("all");
+  const [localeOverride, setLocaleOverride] = useState("auto");
+  const [secondaryLangMode, setSecondaryLangMode] = useState("local");
+  const [occurrences, setOccurrences] = useState([]);
+  const [settings, setSettings] = useState(null);
+  const [loading, setLoading] = useState(false);
+  const [bannerMessage, setBannerMessage] = useState(null);
+  const [bannerError, setBannerError] = useState(false);
+  const [selectedOccurrence, setSelectedOccurrence] = useState(
+    null
+  );
+  const [rescheduleDate, setRescheduleDate] = useState("");
+  const [applyToSeries, setApplyToSeries] = useState(false);
+  const [showQuickCreate, setShowQuickCreate] = useState(false);
+  const [quickSourceId, setQuickSourceId] = useState("");
+  const [quickTitle, setQuickTitle] = useState("");
+  const [quickStart, setQuickStart] = useState("");
+  const [quickEnd, setQuickEnd] = useState("");
+  const [quickLocation, setQuickLocation] = useState("");
+  const [quickCategory] = useState("general");
+  const [quickRRule, setQuickRRule] = useState("");
+  const [quickCustomerName, setQuickCustomerName] = useState("");
+  const [quickCustomerEmail, setQuickCustomerEmail] = useState("");
+  const [quickPartySize, setQuickPartySize] = useState(1);
+  const effectiveLocale = resolveFullCalendarLocale(
+    locale,
+    settings?.defaultLocale,
+    localeOverride
+  );
+  const effectiveDirection = resolveCalendarDirection(
+    effectiveLocale,
+    settings?.direction
+  );
+  const fetchCalendarData = useCallback(async () => {
+    setLoading(true);
+    const loadErrorMsg = t(
+      "calendar.error.load",
+      "Could not load calendar occurrences."
+    );
+    try {
+      const params = new URLSearchParams({
+        from: dateWindow.from,
+        to: dateWindow.to,
+        locale: effectiveLocale
+      });
+      if (categoryFilter !== "all") params.set("category", categoryFilter);
+      const res = await get(
+        `/${PLUGIN_ID}/calendar?${params.toString()}`
+      );
+      const payload = res?.data?.data;
+      if (!payload) return;
+      const loadedOccs = Array.isArray(payload.occurrences) ? payload.occurrences : [];
+      setOccurrences(loadedOccs);
+      const targetDocId = getUrlParam("documentId");
+      const match = targetDocId ? loadedOccs.find((o) => o.documentId === targetDocId) : void 0;
+      if (match) {
+        setSelectedOccurrence((prev) => prev ?? match);
+        setRescheduleDate((prev) => prev || match.occurrenceDate);
+        calendarRef.current?.getApi()?.gotoDate(match.startDate);
+      }
+      if (payload.settings) {
+        setSettings(payload.settings);
+        if (!initialViewSyncedRef.current && payload.settings.defaultView) {
+          initialViewSyncedRef.current = true;
+          setViewMode(payload.settings.defaultView);
+          calendarRef.current?.getApi()?.changeView(payload.settings.defaultView);
+        }
+        if (payload.settings.secondaryCalendarLanguage) {
+          setSecondaryLangMode(payload.settings.secondaryCalendarLanguage);
+        }
+      }
+      setBannerMessage((prev) => prev === loadErrorMsg ? null : prev);
+    } catch {
+      setBannerError(true);
+      setBannerMessage(loadErrorMsg);
+    } finally {
+      setLoading(false);
+    }
+  }, [dateWindow.from, dateWindow.to, effectiveLocale, categoryFilter, get, t]);
+  useEffect(() => {
+    fetchCalendarData();
+  }, [fetchCalendarData]);
+  useEffect(() => {
+    const loadedSources = settings?.sources ?? [];
+    if (loadedSources.length === 0) return;
+    if (sourceFilter !== "all") {
+      const matchedId = matchLoadedSourceId(loadedSources, sourceFilter);
+      if (matchedId && matchedId !== sourceFilter) setSourceFilter(matchedId);
+      setQuickSourceId(matchedId ?? sourceFilter);
+      return;
+    }
+    setQuickSourceId((prev) => {
+      if (prev && loadedSources.some((s) => s.id === prev)) return prev;
+      const first = loadedSources.find((s) => s.enabled !== false) ?? loadedSources[0];
+      return first ? first.id : prev;
+    });
+  }, [settings?.sources, sourceFilter]);
+  const sourceCounts = computeSourceCounts(occurrences, settings?.sources);
+  const visibleOccurrences = filterVisibleOccurrences(
+    occurrences,
+    sourceFilter
+  );
+  const availableCategories = collectAvailableCategories(
+    settings?.sources,
+    sourceFilter,
+    visibleOccurrences
+  );
+  const activeSecondaryCalendars = resolveActiveSecondaryCalendars(
+    secondaryLangMode,
+    settings?.secondaryCalendars
+  );
+  const recurrencePresets = settings?.recurrencePresets?.length ? settings.recurrencePresets : FALLBACK_RECURRENCE_PRESETS;
+  const fullCalendarEvents = mapOccurrencesToFullCalendarEvents(
+    visibleOccurrences,
+    settings?.primaryColor
+  );
+  const changeFullCalendarView = (nextView) => {
+    setViewMode(nextView);
+    calendarRef.current?.getApi()?.changeView(nextView);
+  };
+  const navigateCalendar = (action) => {
+    const api = calendarRef.current?.getApi();
+    if (!api) return;
+    if (action === "prev") api.prev();
+    else if (action === "today") api.today();
+    else api.next();
+    setAnchorDate(api.getDate());
+  };
+  const handleDatesSet = (start, from, to) => {
+    setAnchorDate(start);
+    const nextWin = expandDateWindowToYear(start, from, to);
+    setDateWindow(
+      (prev) => prev.from === nextWin.from && prev.to === nextWin.to ? prev : nextWin
+    );
+  };
+  const scrollQuickCreateIntoView = () => {
+    if (typeof window === "undefined") return;
+    const opts = {
+      behavior: "smooth",
+      block: "nearest"
+    };
+    window.setTimeout(() => quickCreateRef.current?.scrollIntoView(opts), 40);
+  };
+  const handleSelectSlot = (startStr, endStr) => {
+    setQuickStart(startStr);
+    setQuickEnd(normalizeSelectedEndSlot(startStr, endStr));
+    const sources = settings?.sources ?? [];
+    if (sourceFilter !== "all") {
+      setQuickSourceId(sourceFilter);
+    } else if (!quickSourceId && sources.length) {
+      const first = sources.find((s) => s.enabled !== false) ?? sources[0];
+      if (first) setQuickSourceId(first.id);
+    }
+    setShowQuickCreate(true);
+    scrollQuickCreateIntoView();
+  };
+  const handleSelectOccurrence = (occ) => {
+    setSelectedOccurrence(occ);
+    setRescheduleDate(occ.occurrenceDate);
+    setApplyToSeries(false);
+  };
+  const postReschedule = (occ, newStartDate, newEndDate, series = false, cancelOccurrence = false) => post(`/${PLUGIN_ID}/calendar/reschedule`, {
+    sourceId: occ.sourceId,
+    uid: occ.uid,
+    documentId: occ.documentId,
+    locale: occ.locale,
+    occurrenceDate: occ.occurrenceDate,
+    newStartDate,
+    newEndDate,
+    applyToSeries: series,
+    cancelOccurrence
+  });
+  const handleEventDropOrResize = async (occ, newStartIso, newEndIso) => {
+    try {
+      await postReschedule(occ, newStartIso, newEndIso);
+      setBannerError(false);
+      setBannerMessage(
+        `${t("calendar.rescheduled", "Rescheduled")} "${occ.title}" → ${newStartIso.slice(0, 10)}`
+      );
+      await fetchCalendarData();
+    } catch {
+      setBannerError(true);
+      setBannerMessage(
+        t("calendar.error.reschedule", "Failed to reschedule occurrence.")
+      );
+    }
+  };
+  const handleQuickCreateSubmit = async () => {
+    if (!quickTitle.trim() || !quickStart) return;
+    try {
+      const payload = buildQuickCreateRequestPayload({
+        quickSourceId,
+        sourceFilter,
+        quickTitle,
+        quickStart,
+        quickEnd,
+        quickLocation,
+        quickCategory,
+        quickRRule,
+        quickCustomerName,
+        quickCustomerEmail,
+        quickPartySize
+      });
+      await post(`/${PLUGIN_ID}/calendar/quick-create`, payload);
+      setShowQuickCreate(false);
+      setQuickTitle("");
+      setQuickLocation("");
+      setQuickRRule("");
+      setQuickCustomerName("");
+      setQuickCustomerEmail("");
+      setQuickPartySize(1);
+      setBannerError(false);
+      setBannerMessage(
+        t("calendar.created", "Calendar entry created and published.")
+      );
+      await fetchCalendarData();
+    } catch {
+      setBannerError(true);
+      setBannerMessage(
+        t("calendar.error.create", "Could not create calendar entry.")
+      );
+    }
+  };
+  const handleRescheduleSelected = async (cancelOccurrence = false) => {
+    const occ = selectedOccurrence;
+    if (!occ) return;
+    try {
+      const newStartIso = rescheduleDate ? `${rescheduleDate}${occ.startDate.slice(10)}` : occ.startDate;
+      const diffMs = new Date(newStartIso).getTime() - new Date(occ.startDate).getTime();
+      const newEndIso = !Number.isNaN(diffMs) && occ.endDate ? new Date(new Date(occ.endDate).getTime() + diffMs).toISOString() : void 0;
+      await postReschedule(
+        occ,
+        newStartIso,
+        newEndIso,
+        applyToSeries,
+        cancelOccurrence
+      );
+      setSelectedOccurrence(null);
+      setBannerError(false);
+      setBannerMessage(
+        cancelOccurrence ? t("calendar.occurrenceCancelled", "Occurrence cancelled.") : t("calendar.rescheduled", "Schedule updated.")
+      );
+      await fetchCalendarData();
+    } catch {
+      setBannerError(true);
+      setBannerMessage(
+        t("calendar.error.reschedule", "Failed to update schedule.")
+      );
+    }
+  };
+  const monthLabel = new Intl.DateTimeFormat(effectiveLocale, {
+    month: "long",
+    year: "numeric",
+    timeZone: "UTC"
+  }).format(anchorDate);
+  const secondaryHeaderLabel = buildSecondaryHeaderLabel(
+    activeSecondaryCalendars,
+    anchorDate,
+    effectiveLocale,
+    secondaryLangMode
+  );
+  const todayKey = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  const enabledViews = buildEnabledCalendarViews(settings, effectiveLocale);
+  return /* @__PURE__ */ jsx(Box, { padding: 6, background: "neutral100", children: /* @__PURE__ */ jsxs(Flex, { direction: "column", alignItems: "stretch", gap: 5, children: [
+    /* @__PURE__ */ jsx(
+      CalendarToolbar,
+      {
+        t,
+        effectiveLocale,
+        effectiveDirection,
+        localeOverride,
+        onLocaleOverrideChange: setLocaleOverride,
+        secondaryLangMode,
+        onSecondaryLangModeChange: setSecondaryLangMode,
+        monthLabel,
+        secondaryHeaderLabel,
+        loading,
+        settings,
+        totalOccurrences: occurrences.length,
+        sourceCounts,
+        sourceFilter,
+        onSourceFilterChange: setSourceFilter,
+        categoryFilter,
+        onCategoryFilterChange: setCategoryFilter,
+        availableCategories,
+        viewMode,
+        enabledViews,
+        onViewChange: changeFullCalendarView,
+        onNavigate: navigateCalendar,
+        onOpenQuickCreate: (targetSourceId) => {
+          if (targetSourceId) setQuickSourceId(targetSourceId);
+          else if (sourceFilter !== "all") setQuickSourceId(sourceFilter);
+          setQuickStart((prev) => prev || todayKey);
+          setQuickEnd("");
+          setShowQuickCreate(true);
+          scrollQuickCreateIntoView();
+        }
+      }
+    ),
+    bannerMessage && /* @__PURE__ */ jsx(
+      Box,
+      {
+        padding: 3,
+        background: bannerError ? "danger100" : "primary100",
+        hasRadius: true,
+        style: {
+          border: `1px solid ${bannerError ? "#DC2626" : "#0284C7"}`
+        },
+        children: /* @__PURE__ */ jsxs(Flex, { justifyContent: "space-between", alignItems: "center", children: [
+          /* @__PURE__ */ jsx(
+            Typography,
+            {
+              variant: "omega",
+              fontWeight: "bold",
+              textColor: bannerError ? "danger700" : "primary700",
+              children: bannerMessage
+            }
+          ),
+          /* @__PURE__ */ jsx(
+            Button,
+            {
+              variant: "tertiary",
+              size: "S",
+              onClick: () => setBannerMessage(null),
+              children: "×"
+            }
+          )
+        ] })
+      }
+    ),
+    showQuickCreate && /* @__PURE__ */ jsx("div", { ref: quickCreateRef, children: /* @__PURE__ */ jsx(
+      QuickCreatePanel,
+      {
+        t,
+        sources: settings?.sources ?? [],
+        selectedSourceId: quickSourceId,
+        onSelectedSourceIdChange: setQuickSourceId,
+        quickTitle,
+        onQuickTitleChange: setQuickTitle,
+        quickStart,
+        onQuickStartChange: setQuickStart,
+        quickEnd,
+        onQuickEndChange: setQuickEnd,
+        quickLocation,
+        onQuickLocationChange: setQuickLocation,
+        quickRRule,
+        onQuickRRuleChange: setQuickRRule,
+        quickCustomerName,
+        onQuickCustomerNameChange: setQuickCustomerName,
+        quickCustomerEmail,
+        onQuickCustomerEmailChange: setQuickCustomerEmail,
+        quickPartySize,
+        onQuickPartySizeChange: setQuickPartySize,
+        recurrencePresets,
+        onCancel: () => setShowQuickCreate(false),
+        onSubmit: handleQuickCreateSubmit
+      }
+    ) }),
+    selectedOccurrence && /* @__PURE__ */ jsx(
+      OccurrenceDetailDrawer,
+      {
+        t,
+        occurrence: selectedOccurrence,
+        rescheduleDate,
+        onRescheduleDateChange: setRescheduleDate,
+        applyToSeries,
+        onApplyToSeriesChange: setApplyToSeries,
+        onSaveReschedule: () => handleRescheduleSelected(false),
+        onCancelOccurrence: () => handleRescheduleSelected(true),
+        onClose: () => setSelectedOccurrence(null)
+      }
+    ),
+    /* @__PURE__ */ jsx(
+      FullCalendarCanvas,
+      {
+        calendarRef,
+        locale: effectiveLocale,
+        direction: effectiveDirection,
+        theme: settings?.theme,
+        colorScheme: settings?.colorScheme,
+        themePalette: settings?.themePalette,
+        secondaryCalendarLanguage: secondaryLangMode,
+        settings,
+        events: fullCalendarEvents,
+        activeSecondaryCalendars,
+        onDatesSet: handleDatesSet,
+        onSelectSlot: handleSelectSlot,
+        onSelectOccurrence: handleSelectOccurrence,
+        onDropOrResizeOccurrence: handleEventDropOrResize
+      }
+    )
+  ] }) });
+};
+export {
+  CalendarPage
+};