@etus/ui 0.4.0-beta.2 → 0.4.0-beta.20

package/dist/chunk-P4WMDGAQ.js

@@ -0,0 +1,1062 @@
+import { Button } from './chunk-L4OQ6BJ5.js';
+import { cn } from './chunk-RVAYDRMA.js';
+import { ChevronLeft, ChevronRight, Clock, MapPin } from 'lucide-react';
+import * as React from 'react';
+import { cva } from 'class-variance-authority';
+import { jsx, Fragment, jsxs } from 'react/jsx-runtime';
+
+var eventCalendarVariants = cva(
+  "flex flex-col bg-background rounded-lg border border-border overflow-hidden",
+  {
+    variants: {
+      size: {
+        sm: "min-h-96",
+        md: "min-h-[var(--event-calendar-root-min-height-md)]",
+        lg: "min-h-[var(--event-calendar-root-min-height-lg)]",
+        full: "h-full min-h-[var(--event-calendar-root-min-height-full)]"
+      }
+    },
+    defaultVariants: {
+      size: "md"
+    }
+  }
+);
+var eventCalendarHeaderVariants = cva(
+  "flex items-center justify-between p-3 border-b border-border bg-muted/30",
+  {
+    variants: {
+      compact: {
+        true: "p-2",
+        false: "p-3"
+      }
+    },
+    defaultVariants: {
+      compact: false
+    }
+  }
+);
+var eventCalendarCellVariants = cva(
+  "relative min-h-20 border-r border-b border-border p-1 transition-colors",
+  {
+    variants: {
+      isToday: {
+        true: "bg-primary/5",
+        false: ""
+      },
+      isWeekend: {
+        true: "bg-muted/30",
+        false: ""
+      },
+      isOutsideMonth: {
+        true: "bg-muted/50 text-muted-foreground",
+        false: ""
+      },
+      isSelected: {
+        true: "ring-2 ring-primary ring-inset",
+        false: ""
+      },
+      isSelectable: {
+        true: "cursor-pointer hover:bg-accent/50",
+        false: ""
+      }
+    },
+    defaultVariants: {
+      isToday: false,
+      isWeekend: false,
+      isOutsideMonth: false,
+      isSelected: false,
+      isSelectable: true
+    }
+  }
+);
+var eventCalendarEventVariants = cva(
+  "group relative rounded px-1.5 py-0.5 text-xs font-medium truncate cursor-pointer transition-all",
+  {
+    variants: {
+      variant: {
+        default: "bg-primary/10 text-primary hover:bg-primary/20",
+        blue: "bg-[color:var(--chart-3)]/10 text-[color:var(--chart-3)] hover:bg-[color:var(--chart-3)]/20",
+        green: "bg-[color:var(--chart-2)]/10 text-[color:var(--chart-2)] hover:bg-[color:var(--chart-2)]/20",
+        red: "bg-destructive/10 text-destructive hover:bg-destructive/20",
+        yellow: "bg-[color:var(--chart-4)]/10 text-[color:var(--chart-4)] hover:bg-[color:var(--chart-4)]/20",
+        purple: "bg-[color:var(--chart-1)]/10 text-[color:var(--chart-1)] hover:bg-[color:var(--chart-1)]/20",
+        orange: "bg-[color:var(--chart-5)]/10 text-[color:var(--chart-5)] hover:bg-[color:var(--chart-5)]/20",
+        pink: "bg-[color:var(--chart-1)]/10 text-[color:var(--chart-1)] hover:bg-[color:var(--chart-1)]/20",
+        cyan: "bg-[color:var(--chart-2)]/10 text-[color:var(--chart-2)] hover:bg-[color:var(--chart-2)]/20"
+      },
+      isAllDay: {
+        true: "font-semibold",
+        false: ""
+      },
+      isDragging: {
+        true: "opacity-50 ring-2 ring-primary",
+        false: ""
+      }
+    },
+    defaultVariants: {
+      variant: "default",
+      isAllDay: false,
+      isDragging: false
+    }
+  }
+);
+var eventCalendarTimeSlotVariants = cva(
+  "relative border-b border-border transition-colors",
+  {
+    variants: {
+      isHour: {
+        true: "border-border",
+        false: "border-border/50"
+      },
+      isCurrentTime: {
+        true: "before:absolute before:left-0 before:right-0 before:h-0.5 before:bg-destructive before:z-10",
+        false: ""
+      },
+      isSelectable: {
+        true: "cursor-pointer hover:bg-accent/30",
+        false: ""
+      }
+    },
+    defaultVariants: {
+      isHour: false,
+      isCurrentTime: false,
+      isSelectable: true
+    }
+  }
+);
+var eventCalendarViewButtonVariants = cva(
+  "px-3 py-1.5 text-sm font-medium rounded-md transition-colors",
+  {
+    variants: {
+      isActive: {
+        true: "bg-primary text-primary-foreground",
+        false: "text-muted-foreground hover:text-foreground hover:bg-muted"
+      }
+    },
+    defaultVariants: {
+      isActive: false
+    }
+  }
+);
+var eventCalendarDayNumberVariants = cva(
+  "inline-flex items-center justify-center w-7 h-7 text-sm rounded-full transition-colors",
+  {
+    variants: {
+      isToday: {
+        true: "bg-primary text-primary-foreground font-semibold",
+        false: "text-foreground"
+      },
+      isOutsideMonth: {
+        true: "text-muted-foreground",
+        false: ""
+      }
+    },
+    defaultVariants: {
+      isToday: false,
+      isOutsideMonth: false
+    }
+  }
+);
+var eventCalendarAgendaItemVariants = cva(
+  "flex items-start gap-3 p-3 rounded-lg transition-colors",
+  {
+    variants: {
+      isClickable: {
+        true: "cursor-pointer hover:bg-muted/50",
+        false: ""
+      }
+    },
+    defaultVariants: {
+      isClickable: true
+    }
+  }
+);
+function getEventVariant(color) {
+  if (!color) return "default";
+  const colorMap = {
+    blue: "blue",
+    green: "green",
+    red: "red",
+    yellow: "yellow",
+    purple: "purple",
+    orange: "orange",
+    pink: "pink",
+    cyan: "cyan"
+  };
+  return colorMap[color.toLowerCase()] ?? "default";
+}
+function startOfMonth(date) {
+  return new Date(date.getFullYear(), date.getMonth(), 1);
+}
+function endOfMonth(date) {
+  return new Date(date.getFullYear(), date.getMonth() + 1, 0);
+}
+function startOfWeek(date, weekStartsOn = 0) {
+  const d = new Date(date);
+  const day = d.getDay();
+  const diff = (day < weekStartsOn ? 7 : 0) + day - weekStartsOn;
+  d.setDate(d.getDate() - diff);
+  d.setHours(0, 0, 0, 0);
+  return d;
+}
+function endOfWeek(date, weekStartsOn = 0) {
+  const d = startOfWeek(date, weekStartsOn);
+  d.setDate(d.getDate() + 6);
+  d.setHours(23, 59, 59, 999);
+  return d;
+}
+function addDays(date, days) {
+  const d = new Date(date);
+  d.setDate(d.getDate() + days);
+  return d;
+}
+function addMonths(date, months) {
+  const d = new Date(date);
+  d.setMonth(d.getMonth() + months);
+  return d;
+}
+function addWeeks(date, weeks) {
+  return addDays(date, weeks * 7);
+}
+function isSameDay(a, b) {
+  return a.getFullYear() === b.getFullYear() && a.getMonth() === b.getMonth() && a.getDate() === b.getDate();
+}
+function isSameMonth(a, b) {
+  return a.getFullYear() === b.getFullYear() && a.getMonth() === b.getMonth();
+}
+function isToday(date) {
+  return isSameDay(date, /* @__PURE__ */ new Date());
+}
+function isWeekend(date) {
+  const day = date.getDay();
+  return day === 0 || day === 6;
+}
+function formatDate(date, options, locale = "en-US") {
+  return date.toLocaleDateString(locale, options);
+}
+function formatTime(date, locale = "en-US") {
+  return date.toLocaleTimeString(locale, { hour: "numeric", minute: "2-digit" });
+}
+function parseTime(timeStr) {
+  const [hours, minutes] = timeStr.split(":").map(Number);
+  return { hours: hours ?? 0, minutes: minutes ?? 0 };
+}
+function getEventsForDay(events, date) {
+  return events.filter((event) => {
+    const eventStart = new Date(event.start);
+    const eventEnd = new Date(event.end);
+    const dayStart = new Date(date);
+    dayStart.setHours(0, 0, 0, 0);
+    const dayEnd = new Date(date);
+    dayEnd.setHours(23, 59, 59, 999);
+    return eventStart <= dayEnd && eventEnd >= dayStart;
+  });
+}
+function getEventsForDateRange(events, start, end) {
+  return events.filter((event) => {
+    const eventStart = new Date(event.start);
+    const eventEnd = new Date(event.end);
+    return eventStart <= end && eventEnd >= start;
+  });
+}
+function EventCalendarEvent({
+  event,
+  isDragging = false,
+  onClick,
+  renderEvent
+}) {
+  if (renderEvent) {
+    return /* @__PURE__ */ jsx(Fragment, { children: renderEvent(event) });
+  }
+  const variant = getEventVariant(event.color);
+  return /* @__PURE__ */ jsxs(
+    "button",
+    {
+      className: cn(
+        eventCalendarEventVariants({
+          variant,
+          isAllDay: event.allDay,
+          isDragging
+        })
+      ),
+      "aria-label": `Event: ${event.title}`,
+      "data-slot": "event",
+      type: "button",
+      onClick: (e) => {
+        e.stopPropagation();
+        onClick?.(event);
+      },
+      children: [
+        !event.allDay && /* @__PURE__ */ jsx("span", { className: "mr-1 text-xs opacity-70", children: formatTime(new Date(event.start)) }),
+        /* @__PURE__ */ jsx("span", { children: event.title })
+      ]
+    }
+  );
+}
+function EventCalendarHeader({
+  date,
+  view,
+  onPrevious,
+  onNext,
+  onToday,
+  onViewChange,
+  locale = "en-US"
+}) {
+  const getHeaderTitle = () => {
+    switch (view) {
+      case "month":
+        return formatDate(date, { month: "long", year: "numeric" }, locale);
+      case "week": {
+        const weekStart = startOfWeek(date, 0);
+        const weekEnd = endOfWeek(date, 0);
+        if (weekStart.getMonth() === weekEnd.getMonth()) {
+          return `${formatDate(weekStart, { month: "long", day: "numeric" }, locale)} - ${String(weekEnd.getDate())}, ${String(weekEnd.getFullYear())}`;
+        }
+        return `${formatDate(weekStart, { month: "short", day: "numeric" }, locale)} - ${formatDate(weekEnd, { month: "short", day: "numeric", year: "numeric" }, locale)}`;
+      }
+      case "day":
+        return formatDate(
+          date,
+          { weekday: "long", month: "long", day: "numeric", year: "numeric" },
+          locale
+        );
+      case "agenda":
+        return formatDate(date, { month: "long", year: "numeric" }, locale);
+      default:
+        return "";
+    }
+  };
+  const views = ["month", "week", "day", "agenda"];
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      className: cn(eventCalendarHeaderVariants()),
+      "data-slot": "calendar-header",
+      children: [
+        /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-2", children: [
+          /* @__PURE__ */ jsx(
+            Button,
+            {
+              "aria-label": "Previous",
+              size: "sm",
+              variant: "outline",
+              onClick: onPrevious,
+              children: /* @__PURE__ */ jsx(ChevronLeft, { className: "h-4 w-4" })
+            }
+          ),
+          /* @__PURE__ */ jsx(
+            Button,
+            {
+              "aria-label": "Next",
+              size: "sm",
+              variant: "outline",
+              onClick: onNext,
+              children: /* @__PURE__ */ jsx(ChevronRight, { className: "h-4 w-4" })
+            }
+          ),
+          /* @__PURE__ */ jsx(Button, { size: "sm", variant: "outline", onClick: onToday, children: "Today" }),
+          /* @__PURE__ */ jsx("h2", { className: "ml-2 text-lg font-semibold", children: getHeaderTitle() })
+        ] }),
+        /* @__PURE__ */ jsx("div", { className: "flex items-center gap-1 rounded-lg bg-muted p-1", children: views.map((v) => /* @__PURE__ */ jsx(
+          "button",
+          {
+            "aria-pressed": view === v,
+            className: cn(eventCalendarViewButtonVariants({ isActive: view === v })),
+            type: "button",
+            onClick: () => {
+              onViewChange(v);
+            },
+            children: v.charAt(0).toUpperCase() + v.slice(1)
+          },
+          v
+        )) })
+      ]
+    }
+  );
+}
+function EventCalendarMonth({
+  date,
+  events,
+  weekStartsOn,
+  selectable,
+  onDayClick,
+  onEventClick,
+  onSlotSelect,
+  renderEvent,
+  locale = "en-US"
+}) {
+  const monthStart = startOfMonth(date);
+  const monthEnd = endOfMonth(date);
+  const calendarStart = startOfWeek(monthStart, weekStartsOn);
+  const calendarEnd = endOfWeek(monthEnd, weekStartsOn);
+  const weekDays = [];
+  let dayPointer = calendarStart;
+  for (let i = 0; i < 7; i++) {
+    weekDays.push(formatDate(dayPointer, { weekday: "short" }, locale));
+    dayPointer = addDays(dayPointer, 1);
+  }
+  const weeks = [];
+  let currentDay = calendarStart;
+  while (currentDay <= calendarEnd) {
+    const week = [];
+    for (let i = 0; i < 7; i++) {
+      week.push(new Date(currentDay));
+      currentDay = addDays(currentDay, 1);
+    }
+    weeks.push(week);
+  }
+  const handleDayClick = (day) => {
+    onDayClick?.(day);
+    if (selectable && onSlotSelect) {
+      const start = new Date(day);
+      start.setHours(0, 0, 0, 0);
+      const end = new Date(day);
+      end.setHours(23, 59, 59, 999);
+      onSlotSelect({ start, end, allDay: true });
+    }
+  };
+  return /* @__PURE__ */ jsxs("div", { className: "flex flex-1 flex-col", "data-slot": "calendar-month", role: "grid", children: [
+    /* @__PURE__ */ jsx(
+      "div",
+      {
+        className: "grid grid-cols-7 border-b border-border bg-muted/50",
+        role: "row",
+        children: weekDays.map((day) => /* @__PURE__ */ jsx(
+          "div",
+          {
+            className: "py-2 text-center text-xs font-medium text-muted-foreground",
+            role: "columnheader",
+            children: day
+          },
+          day
+        ))
+      }
+    ),
+    /* @__PURE__ */ jsx("div", { className: "flex flex-1 flex-col", children: weeks.map((week) => /* @__PURE__ */ jsx(
+      "div",
+      {
+        className: "grid flex-1 grid-cols-7",
+        role: "row",
+        children: week.map((day) => {
+          const dayEvents = getEventsForDay(events, day);
+          const isCurrentMonth = isSameMonth(day, date);
+          const isTodayDate = isToday(day);
+          const isWeekendDay = isWeekend(day);
+          return /* @__PURE__ */ jsxs(
+            "div",
+            {
+              "aria-label": formatDate(day, {
+                weekday: "long",
+                month: "long",
+                day: "numeric"
+              }),
+              className: cn(
+                eventCalendarCellVariants({
+                  isToday: isTodayDate,
+                  isWeekend: isWeekendDay && !isTodayDate,
+                  isOutsideMonth: !isCurrentMonth,
+                  isSelectable: selectable
+                }),
+                day.getDay() === (weekStartsOn === 0 ? 6 : 0) && "border-r-0"
+              ),
+              "aria-current": isTodayDate ? "date" : void 0,
+              role: "gridcell",
+              tabIndex: selectable ? 0 : void 0,
+              onClick: () => {
+                handleDayClick(day);
+              },
+              onKeyDown: (e) => {
+                if (e.key === "Enter" || e.key === " ") {
+                  e.preventDefault();
+                  handleDayClick(day);
+                }
+              },
+              children: [
+                /* @__PURE__ */ jsx("div", { className: "mb-1 flex justify-end", children: /* @__PURE__ */ jsx(
+                  "span",
+                  {
+                    className: cn(
+                      eventCalendarDayNumberVariants({
+                        isToday: isTodayDate,
+                        isOutsideMonth: !isCurrentMonth
+                      })
+                    ),
+                    children: day.getDate()
+                  }
+                ) }),
+                /* @__PURE__ */ jsxs("div", { className: "flex flex-col gap-0.5", children: [
+                  dayEvents.slice(0, 3).map((event) => /* @__PURE__ */ jsx(
+                    EventCalendarEvent,
+                    {
+                      event,
+                      renderEvent,
+                      onClick: onEventClick
+                    },
+                    event.id
+                  )),
+                  dayEvents.length > 3 && /* @__PURE__ */ jsxs("span", { className: "px-1 text-xs text-muted-foreground", children: [
+                    "+",
+                    dayEvents.length - 3,
+                    " more"
+                  ] })
+                ] })
+              ]
+            },
+            day.toISOString()
+          );
+        })
+      },
+      week[0]?.toISOString()
+    )) })
+  ] });
+}
+function EventCalendarWeek({
+  date,
+  events,
+  weekStartsOn,
+  selectable,
+  minTime,
+  maxTime,
+  onEventClick,
+  onSlotSelect,
+  renderEvent,
+  locale = "en-US"
+}) {
+  const weekStart = startOfWeek(date, weekStartsOn);
+  const { hours: startHour } = parseTime(minTime);
+  const { hours: endHour } = parseTime(maxTime);
+  const hours = Array.from({ length: endHour - startHour }, (_, i) => startHour + i);
+  const weekDays = Array.from(
+    { length: 7 },
+    (_, i) => addDays(weekStart, i)
+  );
+  const handleSlotClick = (day, hour) => {
+    if (!selectable || !onSlotSelect) return;
+    const start = new Date(day);
+    start.setHours(hour, 0, 0, 0);
+    const end = new Date(day);
+    end.setHours(hour + 1, 0, 0, 0);
+    onSlotSelect({ start, end });
+  };
+  const getEventsForHour = (day, hour) => {
+    const hourStart = new Date(day);
+    hourStart.setHours(hour, 0, 0, 0);
+    const hourEnd = new Date(day);
+    hourEnd.setHours(hour + 1, 0, 0, 0);
+    return events.filter((event) => {
+      if (event.allDay) return false;
+      const eventStart = new Date(event.start);
+      const eventEnd = new Date(event.end);
+      return isSameDay(eventStart, day) && eventStart.getHours() <= hour && eventEnd.getHours() > hour;
+    });
+  };
+  const getAllDayEvents = (day) => {
+    return events.filter((event) => {
+      if (!event.allDay) return false;
+      const eventStart = new Date(event.start);
+      const eventEnd = new Date(event.end);
+      const dayStart = new Date(day);
+      dayStart.setHours(0, 0, 0, 0);
+      const dayEnd = new Date(day);
+      dayEnd.setHours(23, 59, 59, 999);
+      return eventStart <= dayEnd && eventEnd >= dayStart;
+    });
+  };
+  return /* @__PURE__ */ jsxs("div", { className: "flex flex-1 flex-col overflow-hidden", "data-slot": "calendar-week", children: [
+    /* @__PURE__ */ jsxs("div", { className: "grid grid-cols-[60px_repeat(7,1fr)] border-b border-border bg-muted/50", children: [
+      /* @__PURE__ */ jsx("div", { className: "border-r border-border" }),
+      weekDays.map((day, dayIndex) => /* @__PURE__ */ jsxs(
+        "div",
+        {
+          className: cn(
+            "flex flex-col items-center py-2 text-center",
+            dayIndex < 6 && "border-r border-border"
+          ),
+          children: [
+            /* @__PURE__ */ jsx("span", { className: "text-xs text-muted-foreground", children: formatDate(day, { weekday: "short" }, locale) }),
+            /* @__PURE__ */ jsx(
+              "span",
+              {
+                className: cn(
+                  eventCalendarDayNumberVariants({ isToday: isToday(day) })
+                ),
+                children: day.getDate()
+              }
+            )
+          ]
+        },
+        day.toISOString()
+      ))
+    ] }),
+    /* @__PURE__ */ jsxs("div", { className: "grid grid-cols-[60px_repeat(7,1fr)] border-b border-border", children: [
+      /* @__PURE__ */ jsx("div", { className: "flex items-center justify-center border-r border-border text-xs text-muted-foreground", children: "All day" }),
+      weekDays.map((day, dayIndex) => {
+        const allDayEvts = getAllDayEvents(day);
+        return /* @__PURE__ */ jsx(
+          "div",
+          {
+            className: cn(
+              "min-h-8 p-0.5",
+              dayIndex < 6 && "border-r border-border"
+            ),
+            children: allDayEvts.map((event) => /* @__PURE__ */ jsx(
+              EventCalendarEvent,
+              {
+                event,
+                renderEvent,
+                onClick: onEventClick
+              },
+              event.id
+            ))
+          },
+          day.toISOString()
+        );
+      })
+    ] }),
+    /* @__PURE__ */ jsx("div", { className: "flex-1 overflow-auto", children: /* @__PURE__ */ jsx("div", { className: "grid grid-cols-[60px_repeat(7,1fr)]", children: hours.map((hour) => /* @__PURE__ */ jsxs(React.Fragment, { children: [
+      /* @__PURE__ */ jsx("div", { className: "flex h-12 items-start justify-end border-r border-b border-border pr-2 text-xs text-muted-foreground", children: formatTime(new Date(2e3, 0, 1, hour, 0)) }),
+      weekDays.map((day, dayIndex) => {
+        const hourEvents = getEventsForHour(day, hour);
+        const now = /* @__PURE__ */ new Date();
+        const isCurrentHour = isToday(day) && now.getHours() === hour;
+        return /* @__PURE__ */ jsx(
+          "div",
+          {
+            className: cn(
+              eventCalendarTimeSlotVariants({
+                isHour: true,
+                isCurrentTime: isCurrentHour,
+                isSelectable: selectable
+              }),
+              "h-12",
+              dayIndex < 6 && "border-r"
+            ),
+            "aria-label": `${formatDate(day, { weekday: "long" })} at ${String(hour)}:00`,
+            role: "gridcell",
+            tabIndex: selectable ? 0 : void 0,
+            onClick: () => {
+              handleSlotClick(day, hour);
+            },
+            onKeyDown: (e) => {
+              if (e.key === "Enter" || e.key === " ") {
+                e.preventDefault();
+                handleSlotClick(day, hour);
+              }
+            },
+            children: hourEvents.map((event) => /* @__PURE__ */ jsx(
+              EventCalendarEvent,
+              {
+                event,
+                renderEvent,
+                onClick: onEventClick
+              },
+              event.id
+            ))
+          },
+          day.toISOString()
+        );
+      })
+    ] }, hour)) }) })
+  ] });
+}
+function EventCalendarDay({
+  date,
+  events,
+  selectable,
+  minTime,
+  maxTime,
+  onEventClick,
+  onSlotSelect,
+  renderEvent,
+  locale = "en-US"
+}) {
+  const { hours: startHour } = parseTime(minTime);
+  const { hours: endHour } = parseTime(maxTime);
+  const hours = Array.from({ length: endHour - startHour }, (_, i) => startHour + i);
+  const handleSlotClick = (hour) => {
+    if (!selectable || !onSlotSelect) return;
+    const start = new Date(date);
+    start.setHours(hour, 0, 0, 0);
+    const end = new Date(date);
+    end.setHours(hour + 1, 0, 0, 0);
+    onSlotSelect({ start, end });
+  };
+  const getEventsForHour = (hour) => {
+    return events.filter((event) => {
+      if (event.allDay) return false;
+      const eventStart = new Date(event.start);
+      const eventEnd = new Date(event.end);
+      return isSameDay(eventStart, date) && eventStart.getHours() <= hour && eventEnd.getHours() > hour;
+    });
+  };
+  const allDayEvents = events.filter((e) => e.allDay && isSameDay(new Date(e.start), date));
+  return /* @__PURE__ */ jsxs("div", { className: "flex flex-1 flex-col overflow-hidden", "data-slot": "calendar-day", children: [
+    /* @__PURE__ */ jsxs("div", { className: "border-b border-border bg-muted/50 p-3 text-center", children: [
+      /* @__PURE__ */ jsx("span", { className: "text-sm text-muted-foreground", children: formatDate(date, { weekday: "long" }, locale) }),
+      /* @__PURE__ */ jsx(
+        "span",
+        {
+          className: cn(
+            "ml-2",
+            eventCalendarDayNumberVariants({ isToday: isToday(date) })
+          ),
+          children: date.getDate()
+        }
+      )
+    ] }),
+    allDayEvents.length > 0 && /* @__PURE__ */ jsxs("div", { className: "border-b border-border p-2", children: [
+      /* @__PURE__ */ jsx("div", { className: "mb-1 text-xs text-muted-foreground", children: "All day" }),
+      /* @__PURE__ */ jsx("div", { className: "flex flex-wrap gap-1", children: allDayEvents.map((event) => /* @__PURE__ */ jsx(
+        EventCalendarEvent,
+        {
+          event,
+          renderEvent,
+          onClick: onEventClick
+        },
+        event.id
+      )) })
+    ] }),
+    /* @__PURE__ */ jsx("div", { className: "flex-1 overflow-auto", children: /* @__PURE__ */ jsx("div", { className: "grid grid-cols-[60px_1fr]", children: hours.map((hour) => {
+      const hourEvents = getEventsForHour(hour);
+      const now = /* @__PURE__ */ new Date();
+      const isCurrentHour = isToday(date) && now.getHours() === hour;
+      return /* @__PURE__ */ jsxs(React.Fragment, { children: [
+        /* @__PURE__ */ jsx("div", { className: "flex h-16 items-start justify-end border-r border-b border-border pr-2 text-xs text-muted-foreground", children: formatTime(new Date(2e3, 0, 1, hour, 0)) }),
+        /* @__PURE__ */ jsx(
+          "div",
+          {
+            className: cn(
+              eventCalendarTimeSlotVariants({
+                isHour: true,
+                isCurrentTime: isCurrentHour,
+                isSelectable: selectable
+              }),
+              "h-16 p-1"
+            ),
+            "aria-label": `${String(hour)}:00`,
+            role: "gridcell",
+            tabIndex: selectable ? 0 : void 0,
+            onClick: () => {
+              handleSlotClick(hour);
+            },
+            onKeyDown: (e) => {
+              if (e.key === "Enter" || e.key === " ") {
+                e.preventDefault();
+                handleSlotClick(hour);
+              }
+            },
+            children: hourEvents.map((event) => /* @__PURE__ */ jsx(
+              EventCalendarEvent,
+              {
+                event,
+                renderEvent,
+                onClick: onEventClick
+              },
+              event.id
+            ))
+          }
+        )
+      ] }, hour);
+    }) }) })
+  ] });
+}
+function EventCalendarAgenda({
+  date,
+  events,
+  daysToShow = 30,
+  onEventClick,
+  renderEvent,
+  locale = "en-US"
+}) {
+  const startDate = new Date(date);
+  startDate.setHours(0, 0, 0, 0);
+  const endDate = addDays(startDate, daysToShow);
+  const filteredEvents = getEventsForDateRange(events, startDate, endDate).sort(
+    (a, b) => new Date(a.start).getTime() - new Date(b.start).getTime()
+  );
+  const eventsByDate = filteredEvents.reduce(
+    (acc, event) => {
+      const dateKey = new Date(event.start).toDateString();
+      acc[dateKey] ??= [];
+      acc[dateKey].push(event);
+      return acc;
+    },
+    {}
+  );
+  if (Object.keys(eventsByDate).length === 0) {
+    return /* @__PURE__ */ jsx(
+      "div",
+      {
+        className: "flex flex-1 items-center justify-center text-muted-foreground",
+        "data-slot": "calendar-agenda",
+        children: "No upcoming events"
+      }
+    );
+  }
+  return /* @__PURE__ */ jsx("div", { className: "flex-1 overflow-auto p-4", "data-slot": "calendar-agenda", children: Object.entries(eventsByDate).map(([dateKey, dayEvents]) => {
+    const eventDate = new Date(dateKey);
+    const isTodayDate = isToday(eventDate);
+    return /* @__PURE__ */ jsxs("div", { className: "mb-6", children: [
+      /* @__PURE__ */ jsxs("div", { className: "mb-2 flex items-center gap-2", children: [
+        /* @__PURE__ */ jsx(
+          "span",
+          {
+            className: cn(
+              eventCalendarDayNumberVariants({ isToday: isTodayDate })
+            ),
+            children: eventDate.getDate()
+          }
+        ),
+        /* @__PURE__ */ jsxs("div", { children: [
+          /* @__PURE__ */ jsx("div", { className: "text-sm font-medium", children: formatDate(eventDate, { weekday: "long" }, locale) }),
+          /* @__PURE__ */ jsx("div", { className: "text-xs text-muted-foreground", children: formatDate(eventDate, { month: "long", year: "numeric" }, locale) })
+        ] })
+      ] }),
+      /* @__PURE__ */ jsx("div", { className: "space-y-2 border-l-2 border-border pl-4", children: dayEvents.map((event) => {
+        if (renderEvent) {
+          return /* @__PURE__ */ jsx(
+            "div",
+            {
+              className: cn(
+                eventCalendarAgendaItemVariants({
+                  isClickable: !!onEventClick
+                })
+              ),
+              role: "button",
+              tabIndex: onEventClick ? 0 : void 0,
+              onClick: () => onEventClick?.(event),
+              onKeyDown: (e) => {
+                if (e.key === "Enter" || e.key === " ") {
+                  e.preventDefault();
+                  onEventClick?.(event);
+                }
+              },
+              children: renderEvent(event)
+            },
+            event.id
+          );
+        }
+        const variant = getEventVariant(event.color);
+        return /* @__PURE__ */ jsxs(
+          "div",
+          {
+            className: cn(
+              eventCalendarAgendaItemVariants({
+                isClickable: !!onEventClick
+              })
+            ),
+            role: "button",
+            tabIndex: onEventClick ? 0 : void 0,
+            onClick: () => onEventClick?.(event),
+            onKeyDown: (e) => {
+              if (e.key === "Enter" || e.key === " ") {
+                e.preventDefault();
+                onEventClick?.(event);
+              }
+            },
+            children: [
+              /* @__PURE__ */ jsx(
+                "div",
+                {
+                  className: cn(
+                    "mt-1 h-3 w-3 flex-shrink-0 rounded-full",
+                    variant === "blue" && "bg-blue-500",
+                    variant === "green" && "bg-green-500",
+                    variant === "red" && "bg-red-500",
+                    variant === "yellow" && "bg-yellow-500",
+                    variant === "purple" && "bg-purple-500",
+                    variant === "orange" && "bg-orange-500",
+                    variant === "pink" && "bg-pink-500",
+                    variant === "cyan" && "bg-cyan-500",
+                    variant === "default" && "bg-primary"
+                  )
+                }
+              ),
+              /* @__PURE__ */ jsxs("div", { className: "min-w-0 flex-1", children: [
+                /* @__PURE__ */ jsx("div", { className: "font-medium", children: event.title }),
+                /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-3 text-sm text-muted-foreground", children: [
+                  /* @__PURE__ */ jsxs("span", { className: "flex items-center gap-1", children: [
+                    /* @__PURE__ */ jsx(Clock, { className: "h-3 w-3" }),
+                    event.allDay ? "All day" : `${formatTime(new Date(event.start))} - ${formatTime(new Date(event.end))}`
+                  ] }),
+                  event.location && /* @__PURE__ */ jsxs("span", { className: "flex items-center gap-1", children: [
+                    /* @__PURE__ */ jsx(MapPin, { className: "h-3 w-3" }),
+                    event.location
+                  ] })
+                ] }),
+                event.description && /* @__PURE__ */ jsx("div", { className: "mt-1 text-sm text-muted-foreground line-clamp-2", children: event.description })
+              ] })
+            ]
+          },
+          event.id
+        );
+      }) })
+    ] }, dateKey);
+  }) });
+}
+function EventCalendar({
+  events = [],
+  view: controlledView,
+  date: controlledDate,
+  onDateChange,
+  onViewChange,
+  onEventClick,
+  onEventCreate,
+  onEventUpdate: _onEventUpdate,
+  onEventDelete: _onEventDelete,
+  editable: _editable = true,
+  selectable = true,
+  weekStartsOn = 0,
+  minTime = "00:00",
+  maxTime = "24:00",
+  locale = "en-US",
+  renderEvent,
+  loading = false,
+  className,
+  ...props
+}) {
+  const [internalDate, setInternalDate] = React.useState(() => /* @__PURE__ */ new Date());
+  const [internalView, setInternalView] = React.useState("month");
+  const currentDate = controlledDate ?? internalDate;
+  const currentView = controlledView ?? internalView;
+  const handleDateChange = (newDate) => {
+    if (onDateChange) {
+      onDateChange(newDate);
+    } else {
+      setInternalDate(newDate);
+    }
+  };
+  const handleViewChange = (newView) => {
+    if (onViewChange) {
+      onViewChange(newView);
+    } else {
+      setInternalView(newView);
+    }
+  };
+  const handlePrevious = () => {
+    switch (currentView) {
+      case "month":
+        handleDateChange(addMonths(currentDate, -1));
+        break;
+      case "week":
+        handleDateChange(addWeeks(currentDate, -1));
+        break;
+      case "day":
+        handleDateChange(addDays(currentDate, -1));
+        break;
+      case "agenda":
+        handleDateChange(addMonths(currentDate, -1));
+        break;
+    }
+  };
+  const handleNext = () => {
+    switch (currentView) {
+      case "month":
+        handleDateChange(addMonths(currentDate, 1));
+        break;
+      case "week":
+        handleDateChange(addWeeks(currentDate, 1));
+        break;
+      case "day":
+        handleDateChange(addDays(currentDate, 1));
+        break;
+      case "agenda":
+        handleDateChange(addMonths(currentDate, 1));
+        break;
+    }
+  };
+  const handleToday = () => {
+    handleDateChange(/* @__PURE__ */ new Date());
+  };
+  const handleSlotSelect = (slot) => {
+    onEventCreate?.(slot);
+  };
+  const handleDayClick = (day) => {
+    handleDateChange(day);
+    if (currentView === "month") {
+      handleViewChange("day");
+    }
+  };
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      className: cn(eventCalendarVariants(), className),
+      "data-loading": loading || void 0,
+      "data-slot": "event-calendar",
+      ...props,
+      children: [
+        /* @__PURE__ */ jsx(
+          EventCalendarHeader,
+          {
+            date: currentDate,
+            locale,
+            view: currentView,
+            onNext: handleNext,
+            onPrevious: handlePrevious,
+            onToday: handleToday,
+            onViewChange: handleViewChange
+          }
+        ),
+        loading ? /* @__PURE__ */ jsx("div", { className: "flex flex-1 items-center justify-center", children: /* @__PURE__ */ jsx("div", { className: "h-8 w-8 animate-spin rounded-full border-4 border-primary border-t-transparent" }) }) : /* @__PURE__ */ jsxs(Fragment, { children: [
+          currentView === "month" && /* @__PURE__ */ jsx(
+            EventCalendarMonth,
+            {
+              date: currentDate,
+              events,
+              locale,
+              renderEvent,
+              selectable,
+              weekStartsOn,
+              onDayClick: handleDayClick,
+              onEventClick,
+              onSlotSelect: handleSlotSelect
+            }
+          ),
+          currentView === "week" && /* @__PURE__ */ jsx(
+            EventCalendarWeek,
+            {
+              date: currentDate,
+              events,
+              locale,
+              maxTime,
+              minTime,
+              renderEvent,
+              selectable,
+              weekStartsOn,
+              onEventClick,
+              onSlotSelect: handleSlotSelect
+            }
+          ),
+          currentView === "day" && /* @__PURE__ */ jsx(
+            EventCalendarDay,
+            {
+              date: currentDate,
+              events,
+              locale,
+              maxTime,
+              minTime,
+              renderEvent,
+              selectable,
+              onEventClick,
+              onSlotSelect: handleSlotSelect
+            }
+          ),
+          currentView === "agenda" && /* @__PURE__ */ jsx(
+            EventCalendarAgenda,
+            {
+              date: currentDate,
+              events,
+              locale,
+              renderEvent,
+              onEventClick
+            }
+          )
+        ] })
+      ]
+    }
+  );
+}
+
+export { EventCalendar, EventCalendarAgenda, EventCalendarDay, EventCalendarEvent, EventCalendarHeader, EventCalendarMonth, EventCalendarWeek, eventCalendarAgendaItemVariants, eventCalendarCellVariants, eventCalendarDayNumberVariants, eventCalendarEventVariants, eventCalendarHeaderVariants, eventCalendarTimeSlotVariants, eventCalendarVariants, eventCalendarViewButtonVariants, getEventVariant };
+//# sourceMappingURL=chunk-P4WMDGAQ.js.map
+//# sourceMappingURL=chunk-P4WMDGAQ.js.map