@allhailai/tempusmachina-react 1.0.0

package/dist/index.js

@@ -0,0 +1,2902 @@
+import * as React16 from 'react';
+import React16__default, { createContext, useState, useCallback, useMemo, useEffect, useRef, useContext } from 'react';
+import { Temporal } from 'temporal-polyfill';
+import { Button as Button$1 } from '@base-ui/react/button';
+import { cva } from 'class-variance-authority';
+import { clsx } from 'clsx';
+import { twMerge } from 'tailwind-merge';
+import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
+import { Toggle as Toggle$1 } from '@base-ui/react/toggle';
+import { ToggleGroup as ToggleGroup$1 } from '@base-ui/react/toggle-group';
+import { getToday, createPluginRegistry, EventStore, getVisibleRange, viewTypeFromPreset, resolveLayoutSolver, navigateNext, navigatePrev, getViewTitle, formatEventTime, getWeekNumber, formatTime, isRtl, createEventSources, fetchEventSource, mergeEventSources } from '@allhailai/tempusmachina-core';
+import { draggable, monitorForElements, dropTargetForElements } from '@atlaskit/pragmatic-drag-and-drop/element/adapter';
+import { monitorForExternal, dropTargetForExternal } from '@atlaskit/pragmatic-drag-and-drop/external/adapter';
+
+// src/components/calendar.tsx
+function cn(...inputs) {
+  return twMerge(clsx(inputs));
+}
+var buttonVariants = cva(
+  "group/button inline-flex shrink-0 items-center justify-center rounded-lg border border-transparent bg-clip-padding text-sm font-medium whitespace-nowrap transition-all outline-none select-none focus-visible:border-ring focus-visible:ring-3 focus-visible:ring-ring/50 active:translate-y-px disabled:pointer-events-none disabled:opacity-50 aria-invalid:border-destructive aria-invalid:ring-3 aria-invalid:ring-destructive/20 dark:aria-invalid:border-destructive/50 dark:aria-invalid:ring-destructive/40 [&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*='size-'])]:size-4",
+  {
+    variants: {
+      variant: {
+        default: "bg-primary text-primary-foreground [a]:hover:bg-primary/80",
+        outline: "border-border bg-background hover:bg-muted hover:text-foreground aria-expanded:bg-muted aria-expanded:text-foreground dark:border-input dark:bg-input/30 dark:hover:bg-input/50",
+        secondary: "bg-secondary text-secondary-foreground hover:bg-secondary/80 aria-expanded:bg-secondary aria-expanded:text-secondary-foreground",
+        ghost: "hover:bg-muted hover:text-foreground aria-expanded:bg-muted aria-expanded:text-foreground dark:hover:bg-muted/50",
+        destructive: "bg-destructive/10 text-destructive hover:bg-destructive/20 focus-visible:border-destructive/40 focus-visible:ring-destructive/20 dark:bg-destructive/20 dark:hover:bg-destructive/30 dark:focus-visible:ring-destructive/40",
+        link: "text-primary underline-offset-4 hover:underline"
+      },
+      size: {
+        default: "h-8 gap-1.5 px-2.5 has-data-[icon=inline-end]:pr-2 has-data-[icon=inline-start]:pl-2",
+        xs: "h-6 gap-1 rounded-[min(var(--radius-md),10px)] px-2 text-xs in-data-[slot=button-group]:rounded-lg has-data-[icon=inline-end]:pr-1.5 has-data-[icon=inline-start]:pl-1.5 [&_svg:not([class*='size-'])]:size-3",
+        sm: "h-7 gap-1 rounded-[min(var(--radius-md),12px)] px-2.5 text-[0.8rem] in-data-[slot=button-group]:rounded-lg has-data-[icon=inline-end]:pr-1.5 has-data-[icon=inline-start]:pl-1.5 [&_svg:not([class*='size-'])]:size-3.5",
+        lg: "h-9 gap-1.5 px-2.5 has-data-[icon=inline-end]:pr-3 has-data-[icon=inline-start]:pl-3",
+        icon: "size-8",
+        "icon-xs": "size-6 rounded-[min(var(--radius-md),10px)] in-data-[slot=button-group]:rounded-lg [&_svg:not([class*='size-'])]:size-3",
+        "icon-sm": "size-7 rounded-[min(var(--radius-md),12px)] in-data-[slot=button-group]:rounded-lg",
+        "icon-lg": "size-9"
+      }
+    },
+    defaultVariants: {
+      variant: "default",
+      size: "default"
+    }
+  }
+);
+function Button({
+  className,
+  variant = "default",
+  size = "default",
+  ...props
+}) {
+  return /* @__PURE__ */ jsx(
+    Button$1,
+    {
+      "data-slot": "button",
+      className: cn(buttonVariants({ variant, size, className })),
+      ...props
+    }
+  );
+}
+var toggleVariants = cva(
+  "group/toggle inline-flex items-center justify-center gap-1 rounded-lg text-sm font-medium whitespace-nowrap transition-all outline-none hover:bg-muted hover:text-foreground focus-visible:border-ring focus-visible:ring-[3px] focus-visible:ring-ring/50 disabled:pointer-events-none disabled:opacity-50 aria-invalid:border-destructive aria-invalid:ring-destructive/20 aria-pressed:bg-muted data-[state=on]:bg-muted dark:aria-invalid:ring-destructive/40 [&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*='size-'])]:size-4",
+  {
+    variants: {
+      variant: {
+        default: "bg-transparent",
+        outline: "border border-input bg-transparent hover:bg-muted"
+      },
+      size: {
+        default: "h-8 min-w-8 px-2",
+        sm: "h-7 min-w-7 rounded-[min(var(--radius-md),12px)] px-1.5 text-[0.8rem]",
+        lg: "h-9 min-w-9 px-2.5"
+      }
+    },
+    defaultVariants: {
+      variant: "default",
+      size: "default"
+    }
+  }
+);
+function Toggle({
+  className,
+  variant = "default",
+  size = "default",
+  ...props
+}) {
+  return /* @__PURE__ */ jsx(
+    Toggle$1,
+    {
+      "data-slot": "toggle",
+      className: cn(toggleVariants({ variant, size, className })),
+      ...props
+    }
+  );
+}
+var ToggleGroupContext = React16.createContext({
+  size: "default",
+  variant: "default",
+  spacing: 0,
+  orientation: "horizontal"
+});
+function ToggleGroup({
+  className,
+  variant,
+  size,
+  spacing = 0,
+  orientation = "horizontal",
+  children,
+  ...props
+}) {
+  return /* @__PURE__ */ jsx(
+    ToggleGroup$1,
+    {
+      "data-slot": "toggle-group",
+      "data-variant": variant,
+      "data-size": size,
+      "data-spacing": spacing,
+      "data-orientation": orientation,
+      style: { "--gap": spacing },
+      className: cn(
+        "group/toggle-group flex w-fit flex-row items-center gap-[--spacing(var(--gap))] rounded-lg data-[size=sm]:rounded-[min(var(--radius-md),10px)] data-vertical:flex-col data-vertical:items-stretch",
+        className
+      ),
+      ...props,
+      children: /* @__PURE__ */ jsx(ToggleGroupContext.Provider, { value: { variant, size, spacing, orientation }, children })
+    }
+  );
+}
+function ToggleGroupItem({
+  className,
+  children,
+  variant = "default",
+  size = "default",
+  ...props
+}) {
+  const context = React16.useContext(ToggleGroupContext);
+  return /* @__PURE__ */ jsx(
+    Toggle$1,
+    {
+      "data-slot": "toggle-group-item",
+      "data-variant": context.variant || variant,
+      "data-size": context.size || size,
+      "data-spacing": context.spacing,
+      className: cn(
+        "shrink-0 group-data-[spacing=0]/toggle-group:rounded-none group-data-[spacing=0]/toggle-group:px-2 focus:z-10 focus-visible:z-10 group-data-horizontal/toggle-group:data-[spacing=0]:first:rounded-l-lg group-data-vertical/toggle-group:data-[spacing=0]:first:rounded-t-lg group-data-horizontal/toggle-group:data-[spacing=0]:last:rounded-r-lg group-data-vertical/toggle-group:data-[spacing=0]:last:rounded-b-lg group-data-horizontal/toggle-group:data-[spacing=0]:data-[variant=outline]:border-l-0 group-data-vertical/toggle-group:data-[spacing=0]:data-[variant=outline]:border-t-0 group-data-horizontal/toggle-group:data-[spacing=0]:data-[variant=outline]:first:border-l group-data-vertical/toggle-group:data-[spacing=0]:data-[variant=outline]:first:border-t",
+        toggleVariants({
+          variant: context.variant || variant,
+          size: context.size || size
+        }),
+        className
+      ),
+      ...props,
+      children
+    }
+  );
+}
+function useCalendar(options) {
+  const {
+    events: eventInputs,
+    plugins,
+    defaultDate,
+    date: controlledDate,
+    onDateChange,
+    defaultView = "dayGridMonth",
+    view: controlledView,
+    onViewChange,
+    timezone = "UTC",
+    locale = "en-US",
+    firstDayOfWeek = 0,
+    slotDuration,
+    slotMinTime,
+    slotMaxTime,
+    resources = [],
+    businessHours,
+    eventMaxStack = 3,
+    eventDefaults,
+    validRange,
+    titleFormat,
+    titleRangeSeparator,
+    onDatesSet,
+    onEventAdd,
+    onEventChange,
+    onEventRemove,
+    onEventsSet
+  } = options;
+  const [internalDate, setInternalDate] = useState(
+    () => defaultDate ?? getToday()
+  );
+  const currentDate = controlledDate ?? internalDate;
+  const setDate = useCallback(
+    (date) => {
+      if (controlledDate === void 0) setInternalDate(date);
+      onDateChange?.(date);
+    },
+    [controlledDate, onDateChange]
+  );
+  const [internalView, setInternalView] = useState(defaultView);
+  const currentView = controlledView ?? internalView;
+  const setView = useCallback(
+    (view) => {
+      if (controlledView === void 0) setInternalView(view);
+      onViewChange?.(view);
+    },
+    [controlledView, onViewChange]
+  );
+  const registry = useMemo(() => createPluginRegistry(plugins), [plugins]);
+  const [eventStore, setEventStore] = useState(
+    () => EventStore.from(eventInputs, timezone, eventDefaults)
+  );
+  useEffect(() => {
+    setEventStore(EventStore.from(eventInputs, timezone, eventDefaults));
+  }, [eventInputs, timezone, eventDefaults]);
+  const visibleRange = useMemo(
+    () => getVisibleRange(currentDate, currentView, firstDayOfWeek),
+    [currentDate, currentView, firstDayOfWeek]
+  );
+  const prevRangeRef = useRef(visibleRange);
+  useEffect(() => {
+    const prevRange = prevRangeRef.current;
+    if (!prevRange.start.equals(visibleRange.start) || !prevRange.end.equals(visibleRange.end)) {
+      onDatesSet?.({
+        start: visibleRange.start,
+        end: visibleRange.end,
+        view: currentView
+      });
+    }
+    prevRangeRef.current = visibleRange;
+  }, [visibleRange, currentView, onDatesSet]);
+  useEffect(() => {
+    onEventsSet?.(eventStore.getAll());
+  }, [eventStore, onEventsSet]);
+  const viewConfig = useMemo(() => {
+    const defaults = {
+      slotDuration: slotDuration ?? Temporal.Duration.from({ minutes: 30 }),
+      slotMinTime: slotMinTime ?? Temporal.PlainTime.from("00:00"),
+      slotMaxTime: slotMaxTime ?? Temporal.PlainTime.from("23:59:59")
+    };
+    return {
+      type: viewTypeFromPreset(currentView),
+      preset: currentView,
+      visibleRange,
+      slotDuration: defaults.slotDuration,
+      slotMinTime: defaults.slotMinTime,
+      slotMaxTime: defaults.slotMaxTime,
+      firstDayOfWeek,
+      hiddenDays: [],
+      businessHours,
+      eventMaxStack,
+      validRange
+    };
+  }, [
+    currentView,
+    visibleRange,
+    slotDuration,
+    slotMinTime,
+    slotMaxTime,
+    firstDayOfWeek,
+    businessHours,
+    eventMaxStack,
+    validRange
+  ]);
+  const viewLayout = useMemo(() => {
+    const viewType = viewTypeFromPreset(currentView);
+    const layoutSolver = resolveLayoutSolver(viewType, registry);
+    if (!layoutSolver) return null;
+    const eventsInRange = eventStore.getInRange(visibleRange, timezone);
+    const context = {
+      now: () => Temporal.Now.zonedDateTimeISO(timezone),
+      getEvents: () => eventsInRange,
+      getResources: () => resources,
+      getViewConfig: () => viewConfig
+    };
+    return layoutSolver(eventsInRange, viewConfig, context);
+  }, [currentView, eventStore, visibleRange, timezone, resources, viewConfig, registry]);
+  const next = useCallback(
+    () => setDate(navigateNext(currentDate, currentView, validRange)),
+    [currentDate, currentView, setDate, validRange]
+  );
+  const prev = useCallback(
+    () => setDate(navigatePrev(currentDate, currentView, validRange)),
+    [currentDate, currentView, setDate, validRange]
+  );
+  const todayAction = useCallback(() => setDate(getToday()), [setDate]);
+  const goToDate = useCallback((date) => setDate(date), [setDate]);
+  const changeView = useCallback((view) => setView(view), [setView]);
+  const addEvent = useCallback(
+    (event) => {
+      setEventStore((store) => {
+        const next2 = store.add(event, timezone, eventDefaults);
+        const added = next2.getById(event.id);
+        if (added) onEventAdd?.({ event: added });
+        return next2;
+      });
+    },
+    [timezone, eventDefaults, onEventAdd]
+  );
+  const updateEvent = useCallback(
+    (id, patch) => {
+      setEventStore((store) => {
+        const oldEvent = store.getById(id);
+        const next2 = store.update(id, patch, timezone, eventDefaults);
+        const updated = next2.getById(id);
+        if (oldEvent && updated) onEventChange?.({ event: updated, oldEvent });
+        return next2;
+      });
+    },
+    [timezone, eventDefaults, onEventChange]
+  );
+  const removeEvent = useCallback(
+    (id) => {
+      setEventStore((store) => {
+        const removed = store.getById(id);
+        const next2 = store.remove(id);
+        if (removed) onEventRemove?.({ event: removed });
+        return next2;
+      });
+    },
+    [onEventRemove]
+  );
+  const title = useMemo(
+    () => getViewTitle(currentDate, currentView, locale, titleFormat, titleRangeSeparator),
+    [currentDate, currentView, locale, titleFormat, titleRangeSeparator]
+  );
+  return {
+    currentDate,
+    currentView,
+    viewLayout,
+    visibleRange,
+    events: eventStore.getAll(),
+    next,
+    prev,
+    today: todayAction,
+    goToDate,
+    changeView,
+    title,
+    addEvent,
+    updateEvent,
+    removeEvent
+  };
+}
+var CALENDAR_EVENT_TYPE = "tempus-machina/event";
+function useDragEvent(options) {
+  const {
+    event,
+    editable = event.editable ?? true,
+    startEditable = event.startEditable ?? true,
+    dragMinDistance,
+    onDragStart,
+    onDragEnd
+  } = options;
+  const dragRef = useRef(null);
+  const dragHandleRef = useRef(null);
+  const [isDragging, setIsDragging] = useState(false);
+  useEffect(() => {
+    const el = dragRef.current;
+    if (!el) return;
+    if (editable === false || startEditable === false) return;
+    const cleanup = draggable({
+      element: el,
+      dragHandle: dragHandleRef.current ?? void 0,
+      getInitialData: () => ({
+        type: CALENDAR_EVENT_TYPE,
+        eventId: event.id,
+        eventTitle: event.title,
+        eventStart: event.start.toString(),
+        eventEnd: event.end.toString(),
+        isAllDay: event.isAllDay,
+        resourceIds: event.resourceIds
+      }),
+      onDragStart: () => {
+        setIsDragging(true);
+        onDragStart?.(event);
+      },
+      onDrop: () => {
+        setIsDragging(false);
+        onDragEnd?.(event);
+      }
+    });
+    return cleanup;
+  }, [event, editable, startEditable, onDragStart, onDragEnd]);
+  return { dragRef, dragHandleRef, isDragging };
+}
+
+// src/hooks/use-interaction.ts
+var IDLE_STATE = {
+  mode: "idle",
+  activeEvent: null,
+  ghostEvent: null,
+  previewStart: null,
+  previewEnd: null,
+  dropTargetDate: null,
+  dropTargetTime: null,
+  dropTargetResourceId: null
+};
+function useInteraction(options = {}) {
+  const {
+    events = [],
+    viewConfig,
+    timezone = "UTC",
+    dragRevertDuration = 300,
+    allDayMaintainDuration = true,
+    eventResourceEditable = true,
+    onEventDragStart,
+    onEventDragStop,
+    onEventDrop,
+    onEventResize
+  } = options;
+  const [state, setState] = useState(IDLE_STATE);
+  const eventsRef = useRef(events);
+  useEffect(() => {
+    eventsRef.current = events;
+  }, [events]);
+  useEffect(() => {
+    const cleanup = monitorForElements({
+      canMonitor: ({ source }) => source.data.type === CALENDAR_EVENT_TYPE,
+      onDragStart: ({ source }) => {
+        const eventId = source.data.eventId;
+        const activeEvent = eventsRef.current.find((e) => e.id === eventId) ?? null;
+        const resizeEdge = source.data.resizeEdge;
+        if (activeEvent) {
+          const ghostEvent = {
+            ...activeEvent,
+            id: `ghost-${activeEvent.id}`
+          };
+          setState({
+            mode: resizeEdge ? "resizing" : "dragging",
+            activeEvent,
+            ghostEvent,
+            previewStart: activeEvent.start,
+            previewEnd: activeEvent.end,
+            dropTargetDate: null,
+            dropTargetTime: null,
+            dropTargetResourceId: null
+          });
+          onEventDragStart?.({ event: activeEvent });
+        }
+      },
+      onDrag: ({ location }) => {
+        const dropTarget = location.current.dropTargets[0];
+        if (dropTarget) {
+          setState((prev) => ({
+            ...prev,
+            dropTargetDate: dropTarget.data.date ?? null,
+            dropTargetTime: dropTarget.data.time ?? null,
+            dropTargetResourceId: dropTarget.data.resourceId ?? null
+          }));
+        }
+      },
+      onDrop: ({ source, location }) => {
+        const eventId = source.data.eventId;
+        const activeEvent = eventsRef.current.find((e) => e.id === eventId);
+        const resizeEdge = source.data.resizeEdge;
+        if (activeEvent) {
+          onEventDragStop?.({ event: activeEvent });
+          const dropTarget = location.current.dropTargets[0];
+          if (dropTarget && dropTarget.data.date) {
+            const targetDate = Temporal.PlainDate.from(dropTarget.data.date);
+            const targetTime = dropTarget.data.time ? Temporal.PlainTime.from(dropTarget.data.time) : Temporal.PlainTime.from("00:00");
+            const targetResourceId = dropTarget.data.resourceId ?? void 0;
+            const isAllDay = !dropTarget.data.time;
+            const oldResourceId = activeEvent.resourceIds?.[0];
+            if (!eventResourceEditable && targetResourceId && targetResourceId !== oldResourceId) {
+              setState(IDLE_STATE);
+              return;
+            }
+            if (resizeEdge) {
+              let newStart = activeEvent.start;
+              let newEnd = activeEvent.end;
+              const targetZdt = targetDate.toZonedDateTime({
+                timeZone: timezone,
+                plainTime: targetTime
+              });
+              if (resizeEdge === "start") {
+                newStart = targetZdt;
+              } else {
+                newEnd = targetZdt;
+              }
+              onEventResize?.({
+                event: activeEvent,
+                newStart,
+                newEnd,
+                revert: () => {
+                  onEventResize?.({
+                    event: activeEvent,
+                    newStart: activeEvent.start,
+                    newEnd: activeEvent.end,
+                    revert: () => {
+                    }
+                  });
+                }
+              });
+            } else {
+              let newStart;
+              let newEnd;
+              if (isAllDay && allDayMaintainDuration) {
+                newStart = targetDate.toZonedDateTime({
+                  timeZone: timezone,
+                  plainTime: Temporal.PlainTime.from("00:00")
+                });
+                const duration = activeEvent.start.until(activeEvent.end);
+                newEnd = newStart.add(duration);
+              } else {
+                newStart = targetDate.toZonedDateTime({
+                  timeZone: timezone,
+                  plainTime: targetTime
+                });
+                const duration = activeEvent.start.until(activeEvent.end);
+                newEnd = newStart.add(duration);
+              }
+              onEventDrop?.({
+                event: activeEvent,
+                newStart,
+                newEnd,
+                newResourceId: targetResourceId,
+                oldResourceId,
+                revert: () => {
+                  onEventDrop?.({
+                    event: activeEvent,
+                    newStart: activeEvent.start,
+                    newEnd: activeEvent.end,
+                    newResourceId: oldResourceId,
+                    oldResourceId: targetResourceId,
+                    revert: () => {
+                    }
+                  });
+                }
+              });
+            }
+          }
+        }
+        setState(IDLE_STATE);
+      }
+    });
+    return cleanup;
+  }, [timezone, onEventDragStart, onEventDragStop, onEventDrop]);
+  const startDrag = useCallback((event, position) => {
+    const ghostEvent = { ...event, id: `ghost-${event.id}` };
+    setState({
+      mode: "dragging",
+      activeEvent: event,
+      ghostEvent,
+      previewStart: event.start,
+      previewEnd: event.end,
+      dropTargetDate: null,
+      dropTargetTime: null,
+      dropTargetResourceId: null
+    });
+  }, []);
+  const startResize = useCallback(
+    (event, edge, position) => {
+      setState({
+        mode: "resizing",
+        activeEvent: event,
+        ghostEvent: null,
+        previewStart: event.start,
+        previewEnd: event.end,
+        dropTargetDate: null,
+        dropTargetTime: null,
+        dropTargetResourceId: null
+      });
+    },
+    []
+  );
+  const startSelect = useCallback((position) => {
+    setState({
+      mode: "selecting",
+      activeEvent: null,
+      ghostEvent: null,
+      previewStart: null,
+      previewEnd: null,
+      dropTargetDate: null,
+      dropTargetTime: null,
+      dropTargetResourceId: null
+    });
+  }, []);
+  const updatePosition = useCallback((_position) => {
+  }, []);
+  const endInteraction = useCallback(() => {
+    const result = {
+      type: state.mode === "dragging" ? "move" : state.mode === "resizing" ? "resize" : "select",
+      event: state.activeEvent ?? void 0
+    };
+    setState(IDLE_STATE);
+    return result;
+  }, [state.mode, state.activeEvent]);
+  const cancel = useCallback(() => {
+    setState(IDLE_STATE);
+  }, []);
+  return {
+    state,
+    startDrag,
+    startResize,
+    startSelect,
+    updatePosition,
+    endInteraction,
+    cancel
+  };
+}
+var CalendarContext = createContext(null);
+function useCalendarContext() {
+  const context = useContext(CalendarContext);
+  if (!context) {
+    throw new Error(
+      "[tempus-machina] useCalendarContext must be used within a <Calendar> component."
+    );
+  }
+  return context;
+}
+var DEFAULT_BUTTON_TEXT = {
+  today: "Today",
+  dayGridMonth: "Month",
+  dayGridWeek: "Week",
+  dayGridDay: "Day",
+  timeGridWeek: "Week",
+  timeGridDay: "Day",
+  timelineDay: "Timeline",
+  multiMonthStack: "Year",
+  prev: "\u2039",
+  next: "\u203A",
+  prevYear: "\xAB",
+  nextYear: "\xBB"
+};
+var VIEW_PRESETS = [
+  "dayGridMonth",
+  "dayGridWeek",
+  "dayGridDay",
+  "timeGridWeek",
+  "timeGridDay",
+  "timelineDay",
+  "timelineWeek",
+  "timelineMonth",
+  "multiMonthStack",
+  "multiMonthGrid",
+  "resourceTimeGridDay",
+  "resourceTimeGridWeek"
+];
+function CalendarHeader({
+  className,
+  children,
+  toolbar,
+  buttonText,
+  customButtons,
+  sticky
+}) {
+  const { title, next, prev, today, currentView, changeView, slots, currentDate } = useCalendarContext();
+  const mergedText = {
+    ...DEFAULT_BUTTON_TEXT,
+    ...Object.fromEntries(
+      Object.entries(buttonText ?? {}).filter(
+        (entry) => entry[1] !== void 0
+      )
+    )
+  };
+  if (slots.headerContent) {
+    return /* @__PURE__ */ jsx(
+      "div",
+      {
+        className: cn(
+          "flex items-center justify-between px-4 py-3 border-b border-cal-border bg-cal-header-bg",
+          sticky && "sticky top-0 z-10",
+          className
+        ),
+        children: slots.headerContent({ title, currentView, currentDate })
+      }
+    );
+  }
+  if (children) {
+    return /* @__PURE__ */ jsx(
+      "div",
+      {
+        className: cn(
+          "flex items-center justify-between px-4 py-3 border-b border-cal-border bg-cal-header-bg",
+          sticky && "sticky top-0 z-10",
+          className
+        ),
+        children
+      }
+    );
+  }
+  if (toolbar) {
+    return /* @__PURE__ */ jsxs(
+      "div",
+      {
+        className: cn(
+          "flex items-center justify-between px-4 py-3 border-b border-cal-border bg-cal-header-bg",
+          sticky && "sticky top-0 z-10",
+          className
+        ),
+        children: [
+          /* @__PURE__ */ jsx(
+            ToolbarSection,
+            {
+              tokens: toolbar.left,
+              mergedText,
+              customButtons,
+              prev,
+              next,
+              today,
+              title,
+              currentView,
+              changeView
+            }
+          ),
+          /* @__PURE__ */ jsx(
+            ToolbarSection,
+            {
+              tokens: toolbar.center,
+              mergedText,
+              customButtons,
+              prev,
+              next,
+              today,
+              title,
+              currentView,
+              changeView
+            }
+          ),
+          /* @__PURE__ */ jsx(
+            ToolbarSection,
+            {
+              tokens: toolbar.right,
+              mergedText,
+              customButtons,
+              prev,
+              next,
+              today,
+              title,
+              currentView,
+              changeView
+            }
+          )
+        ]
+      }
+    );
+  }
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      className: cn(
+        "flex items-center justify-between px-4 py-3 border-b border-cal-border bg-cal-header-bg",
+        sticky && "sticky top-0 z-10",
+        className
+      ),
+      children: [
+        /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-2", children: [
+          /* @__PURE__ */ jsx(Button, { variant: "outline", size: "icon", onClick: prev, "aria-label": "Previous", children: /* @__PURE__ */ jsx("svg", { width: "16", height: "16", viewBox: "0 0 16 16", fill: "none", children: /* @__PURE__ */ jsx(
+            "path",
+            {
+              d: "M10 12L6 8L10 4",
+              stroke: "currentColor",
+              strokeWidth: "2",
+              strokeLinecap: "round",
+              strokeLinejoin: "round"
+            }
+          ) }) }),
+          /* @__PURE__ */ jsx(Button, { variant: "outline", size: "icon", onClick: next, "aria-label": "Next", children: /* @__PURE__ */ jsx("svg", { width: "16", height: "16", viewBox: "0 0 16 16", fill: "none", children: /* @__PURE__ */ jsx(
+            "path",
+            {
+              d: "M6 4L10 8L6 12",
+              stroke: "currentColor",
+              strokeWidth: "2",
+              strokeLinecap: "round",
+              strokeLinejoin: "round"
+            }
+          ) }) }),
+          /* @__PURE__ */ jsx(Button, { variant: "outline", size: "sm", onClick: today, children: "Today" })
+        ] }),
+        /* @__PURE__ */ jsx("h2", { className: "text-lg font-semibold text-cal-header-fg", children: title }),
+        /* @__PURE__ */ jsx(
+          ToggleGroup,
+          {
+            value: [currentView],
+            onValueChange: (newValue) => {
+              if (newValue.length > 0) {
+                changeView(newValue[0]);
+              }
+            },
+            variant: "outline",
+            children: ["dayGridMonth", "timeGridWeek", "timeGridDay"].map((view) => /* @__PURE__ */ jsx(ToggleGroupItem, { value: view, size: "sm", children: mergedText[view] ?? view }, view))
+          }
+        )
+      ]
+    }
+  );
+}
+function ToolbarSection({
+  tokens,
+  mergedText,
+  customButtons,
+  prev,
+  next,
+  today,
+  title,
+  currentView,
+  changeView
+}) {
+  if (!tokens) return /* @__PURE__ */ jsx("div", {});
+  const groups = tokens.split(" ").filter(Boolean);
+  return /* @__PURE__ */ jsx("div", { className: "flex items-center gap-2", children: groups.map((group, gIdx) => {
+    const items = group.split(",").filter(Boolean);
+    const viewItems = items.filter((t) => VIEW_PRESETS.includes(t));
+    const actionItems = items.filter((t) => !VIEW_PRESETS.includes(t));
+    if (viewItems.length > 0 && actionItems.length === 0) {
+      return /* @__PURE__ */ jsx(
+        ToggleGroup,
+        {
+          value: [currentView],
+          onValueChange: (v) => v.length > 0 && changeView(v[0]),
+          variant: "outline",
+          children: viewItems.map((view) => /* @__PURE__ */ jsx(ToggleGroupItem, { value: view, size: "sm", children: mergedText[view] ?? view }, view))
+        },
+        gIdx
+      );
+    }
+    return /* @__PURE__ */ jsx("div", { className: "flex items-center gap-1", children: items.map(
+      (token) => renderToken(token, mergedText, customButtons, {
+        prev,
+        next,
+        today,
+        title,
+        changeView,
+        currentView
+      })
+    ) }, gIdx);
+  }) });
+}
+function renderToken(token, text, customButtons, actions) {
+  switch (token) {
+    case "title":
+      return /* @__PURE__ */ jsx("h2", { className: "text-lg font-semibold text-cal-header-fg", children: actions?.title }, "title");
+    case "prev":
+      return /* @__PURE__ */ jsx(
+        Button,
+        {
+          variant: "outline",
+          size: "icon",
+          onClick: actions?.prev,
+          "aria-label": "Previous",
+          children: /* @__PURE__ */ jsx("svg", { width: "16", height: "16", viewBox: "0 0 16 16", fill: "none", children: /* @__PURE__ */ jsx(
+            "path",
+            {
+              d: "M10 12L6 8L10 4",
+              stroke: "currentColor",
+              strokeWidth: "2",
+              strokeLinecap: "round",
+              strokeLinejoin: "round"
+            }
+          ) })
+        },
+        "prev"
+      );
+    case "next":
+      return /* @__PURE__ */ jsx(Button, { variant: "outline", size: "icon", onClick: actions?.next, "aria-label": "Next", children: /* @__PURE__ */ jsx("svg", { width: "16", height: "16", viewBox: "0 0 16 16", fill: "none", children: /* @__PURE__ */ jsx(
+        "path",
+        {
+          d: "M6 4L10 8L6 12",
+          stroke: "currentColor",
+          strokeWidth: "2",
+          strokeLinecap: "round",
+          strokeLinejoin: "round"
+        }
+      ) }) }, "next");
+    case "today":
+      return /* @__PURE__ */ jsx(Button, { variant: "outline", size: "sm", onClick: actions?.today, children: text.today ?? "Today" }, "today");
+    default:
+      if (customButtons?.[token]) {
+        const btn = customButtons[token];
+        return /* @__PURE__ */ jsxs(Button, { variant: "outline", size: "sm", onClick: btn.click, children: [
+          btn.icon,
+          btn.text
+        ] }, token);
+      }
+      if (VIEW_PRESETS.includes(token)) {
+        return /* @__PURE__ */ jsx(
+          Button,
+          {
+            variant: actions?.currentView === token ? "default" : "outline",
+            size: "sm",
+            onClick: () => actions?.changeView(token),
+            children: text[token] ?? token
+          },
+          token
+        );
+      }
+      return null;
+  }
+}
+var eventCardVariants = cva(
+  [
+    "rounded-[var(--cal-event-border-radius)] px-2 py-1 text-xs font-medium",
+    "cursor-pointer select-none",
+    "transition-all duration-[var(--cal-transition-duration)]",
+    // Hover: subtle lift + glow
+    "hover:brightness-110 hover:shadow-md hover:-translate-y-px",
+    // Active: pressed feedback
+    "active:scale-[0.98] active:shadow-sm"
+  ].join(" "),
+  {
+    variants: {
+      variant: {
+        default: "bg-cal-event-default-bg text-cal-event-default-fg",
+        outline: "border border-current bg-transparent",
+        ghost: "border border-dashed border-current bg-transparent opacity-60"
+      },
+      size: {
+        sm: "text-[10px] px-1.5 py-0.5 leading-tight",
+        default: "text-xs px-2 py-1",
+        lg: "text-sm px-3 py-1.5"
+      },
+      state: {
+        idle: "",
+        dragging: "opacity-[var(--cal-drag-opacity)] shadow-lg scale-[1.02] z-50",
+        resizing: "opacity-90 z-50",
+        selected: "ring-2 ring-cal-event-selected-ring ring-offset-1",
+        focused: "ring-2 ring-cal-event-selected-ring ring-offset-1"
+      }
+    },
+    defaultVariants: {
+      variant: "default",
+      size: "default",
+      state: "idle"
+    }
+  }
+);
+var dayCellVariants = cva(
+  [
+    "min-h-24 p-1.5 border-b border-r border-cal-border",
+    "transition-colors duration-[var(--cal-transition-duration)]",
+    // Hover: subtle highlight
+    "hover:bg-cal-slot-bg-odd"
+  ].join(" "),
+  {
+    variants: {
+      variant: {
+        default: "bg-cal-slot-bg",
+        today: "bg-cal-today-bg hover:bg-cal-today-bg",
+        weekend: "bg-cal-weekend-bg",
+        otherMonth: "bg-cal-slot-bg opacity-50"
+      }
+    },
+    defaultVariants: {
+      variant: "default"
+    }
+  }
+);
+var timeSlotVariants = cva(
+  ["border-b border-cal-slot-border", "transition-colors duration-75"].join(" "),
+  {
+    variants: {
+      variant: {
+        default: "bg-cal-slot-bg",
+        odd: "bg-cal-slot-bg-odd",
+        business: "bg-cal-slot-business",
+        nonBusiness: "bg-cal-slot-non-business"
+      }
+    },
+    defaultVariants: {
+      variant: "default"
+    }
+  }
+);
+function resolveEventStyles(event) {
+  const bgColor = event.backgroundColor ?? event.color ?? void 0;
+  const borderClr = event.borderColor ?? event.color ?? void 0;
+  const textClr = event.textColor ?? void 0;
+  if (!bgColor && !borderClr && !textClr) return void 0;
+  return {
+    ...bgColor ? { backgroundColor: bgColor } : {},
+    ...borderClr ? { borderLeft: `3px solid ${borderClr}` } : {},
+    ...textClr ? { color: textClr } : { ...bgColor ? { color: "white" } : {} }
+  };
+}
+function EventCard({
+  positionedEvent,
+  compact = false,
+  eventTimeFormat,
+  displayEventTime = true,
+  displayEventEnd = false
+}) {
+  const {
+    slots,
+    onEventClick,
+    onEventMouseEnter,
+    onEventMouseLeave,
+    currentView,
+    locale,
+    editable
+  } = useCalendarContext();
+  const { event } = positionedEvent;
+  const { dragRef, isDragging } = useDragEvent({
+    event,
+    editable: editable && event.editable !== false
+  });
+  const handleClick = useCallback(
+    (e) => {
+      e.stopPropagation();
+      onEventClick?.(event);
+    },
+    [event, onEventClick]
+  );
+  const handleMouseEnter = useCallback(
+    (e) => {
+      onEventMouseEnter?.({ event, el: e.currentTarget });
+    },
+    [event, onEventMouseEnter]
+  );
+  const handleMouseLeave = useCallback(
+    (e) => {
+      onEventMouseLeave?.({ event, el: e.currentTarget });
+    },
+    [event, onEventMouseLeave]
+  );
+  if (event.display === "none") return null;
+  const state = isDragging ? "dragging" : positionedEvent.isDragging ? "dragging" : positionedEvent.isResizing ? "resizing" : positionedEvent.isSelected ? "selected" : positionedEvent.isFocused ? "focused" : "idle";
+  const timeText = event.isAllDay ? "All day" : displayEventTime ? formatEventTime(event.start, locale, eventTimeFormat) : "";
+  const endTimeText = displayEventEnd && !event.isAllDay ? formatEventTime(event.end, locale, eventTimeFormat) : "";
+  const fullTimeText = endTimeText ? `${timeText} \u2013 ${endTimeText}` : timeText;
+  const eventStyles = resolveEventStyles(event);
+  if (slots.eventContent) {
+    return /* @__PURE__ */ jsx(
+      "div",
+      {
+        ref: dragRef,
+        onClick: handleClick,
+        onMouseEnter: handleMouseEnter,
+        onMouseLeave: handleMouseLeave,
+        className: cn(eventCardVariants({ state }), event.className, "cursor-pointer"),
+        style: { ...eventStyles, ...isDragging ? { opacity: 0.5 } : {} },
+        children: slots.eventContent({
+          event,
+          view: currentView,
+          isStart: true,
+          isEnd: true,
+          isDragging,
+          timeText: fullTimeText
+        })
+      }
+    );
+  }
+  if (event.display === "list-item") {
+    const dotColor = event.backgroundColor ?? event.color ?? "var(--cal-event-default-bg)";
+    return /* @__PURE__ */ jsxs(
+      "div",
+      {
+        ref: dragRef,
+        onClick: handleClick,
+        onMouseEnter: handleMouseEnter,
+        onMouseLeave: handleMouseLeave,
+        className: cn(
+          "flex items-center gap-1 text-xs cursor-pointer truncate py-0.5 px-1",
+          event.className
+        ),
+        style: isDragging ? { opacity: 0.5 } : void 0,
+        children: [
+          /* @__PURE__ */ jsx(
+            "span",
+            {
+              className: "inline-block w-2 h-2 rounded-full shrink-0",
+              style: { backgroundColor: dotColor }
+            }
+          ),
+          displayEventTime && !event.isAllDay && /* @__PURE__ */ jsx("span", { className: "font-normal opacity-75", children: fullTimeText }),
+          /* @__PURE__ */ jsx("span", { className: "truncate", children: event.title })
+        ]
+      }
+    );
+  }
+  if (compact) {
+    return /* @__PURE__ */ jsxs(
+      "div",
+      {
+        ref: dragRef,
+        onClick: handleClick,
+        onMouseEnter: handleMouseEnter,
+        onMouseLeave: handleMouseLeave,
+        className: cn(
+          eventCardVariants({ size: "sm", state }),
+          event.className,
+          "truncate cursor-pointer"
+        ),
+        style: { ...eventStyles, ...isDragging ? { opacity: 0.5 } : {} },
+        title: event.title,
+        children: [
+          displayEventTime && !event.isAllDay && /* @__PURE__ */ jsx("span", { className: "font-normal opacity-75 mr-1", children: fullTimeText }),
+          event.title
+        ]
+      }
+    );
+  }
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      ref: dragRef,
+      onClick: handleClick,
+      onMouseEnter: handleMouseEnter,
+      onMouseLeave: handleMouseLeave,
+      className: cn(eventCardVariants({ state }), event.className, "cursor-pointer"),
+      style: { ...eventStyles, ...isDragging ? { opacity: 0.5 } : {} },
+      children: [
+        /* @__PURE__ */ jsx("div", { className: "font-semibold truncate", children: event.title }),
+        displayEventTime && !event.isAllDay && /* @__PURE__ */ jsx("div", { className: "text-[10px] opacity-75", children: fullTimeText })
+      ]
+    }
+  );
+}
+function MorePopover({
+  events,
+  count,
+  dateStr,
+  moreLinkClick = "popover",
+  onNavigateToDay,
+  allEvents,
+  className
+}) {
+  const [isOpen, setIsOpen] = useState(false);
+  const triggerRef = useRef(null);
+  const popoverRef = useRef(null);
+  useEffect(() => {
+    if (!isOpen) return;
+    const handleClick2 = (e) => {
+      if (popoverRef.current && !popoverRef.current.contains(e.target) && triggerRef.current && !triggerRef.current.contains(e.target)) {
+        setIsOpen(false);
+      }
+    };
+    document.addEventListener("mousedown", handleClick2);
+    return () => document.removeEventListener("mousedown", handleClick2);
+  }, [isOpen]);
+  useEffect(() => {
+    if (!isOpen) return;
+    const handleKey = (e) => {
+      if (e.key === "Escape") setIsOpen(false);
+    };
+    document.addEventListener("keydown", handleKey);
+    return () => document.removeEventListener("keydown", handleKey);
+  }, [isOpen]);
+  const handleClick = () => {
+    if (moreLinkClick === "day") {
+      onNavigateToDay?.(dateStr);
+      return;
+    }
+    if (typeof moreLinkClick === "function") {
+      moreLinkClick({
+        date: dateStr,
+        allEvents: allEvents ?? events,
+        hiddenEvents: events
+      });
+      return;
+    }
+    setIsOpen(!isOpen);
+  };
+  return /* @__PURE__ */ jsxs("div", { className: cn("relative", className), children: [
+    /* @__PURE__ */ jsxs(
+      "button",
+      {
+        ref: triggerRef,
+        onClick: handleClick,
+        className: "text-[10px] font-semibold text-cal-today-fg mt-0.5 cursor-pointer px-1.5 py-0.5 rounded-full hover:bg-cal-today-bg hover:underline focus:outline-none transition-colors",
+        "aria-expanded": isOpen,
+        "aria-haspopup": "true",
+        children: [
+          "+",
+          count,
+          " more"
+        ]
+      }
+    ),
+    isOpen && /* @__PURE__ */ jsxs(
+      "div",
+      {
+        ref: popoverRef,
+        className: cn(
+          "absolute z-50 top-full left-0 mt-1",
+          "w-48 max-h-64 overflow-y-auto",
+          "bg-cal-bg border border-cal-border rounded-lg shadow-lg",
+          "p-2 space-y-1"
+        ),
+        role: "dialog",
+        "aria-label": `Events for ${dateStr}`,
+        children: [
+          /* @__PURE__ */ jsx("div", { className: "text-xs font-semibold text-cal-fg-muted mb-1 px-1", children: dateStr }),
+          events.map((posEvent) => /* @__PURE__ */ jsx(EventCard, { positionedEvent: posEvent, compact: true }, posEvent.event.id))
+        ]
+      }
+    )
+  ] });
+}
+function DayCell({ cell, moreLinkClick, navLinkDayClick }) {
+  const { slots, onDateSelect, changeView, editable } = useCalendarContext();
+  const cellRef = useRef(null);
+  const [isDragOver, setIsDragOver] = useState(false);
+  const variant = cell.isToday ? "today" : !cell.isCurrentMonth ? "otherMonth" : cell.isWeekend ? "weekend" : "default";
+  useEffect(() => {
+    const el = cellRef.current;
+    if (!el || !editable) return;
+    const cleanup = dropTargetForElements({
+      element: el,
+      getData: () => ({
+        date: cell.date.toString(),
+        time: null,
+        // All-day drop for month view
+        resourceId: null
+      }),
+      canDrop: ({ source }) => source.data.type === CALENDAR_EVENT_TYPE,
+      onDragEnter: () => setIsDragOver(true),
+      onDragLeave: () => setIsDragOver(false),
+      onDrop: () => setIsDragOver(false)
+    });
+    return cleanup;
+  }, [editable, cell.date]);
+  const handleClick = () => {
+    if (onDateSelect) {
+      const start = cell.date.toPlainDateTime(Temporal.PlainTime.from("00:00"));
+      const end = cell.date.add({ days: 1 }).toPlainDateTime(Temporal.PlainTime.from("00:00"));
+      onDateSelect({ start, end });
+    }
+  };
+  const handleDayNumberClick = (e) => {
+    if (!navLinkDayClick) return;
+    e.stopPropagation();
+    if (typeof navLinkDayClick === "function") {
+      navLinkDayClick(cell.date);
+    } else {
+      changeView("timeGridDay");
+    }
+  };
+  if (slots.dayCellContent) {
+    return /* @__PURE__ */ jsx(
+      "div",
+      {
+        ref: cellRef,
+        className: cn(
+          dayCellVariants({ variant }),
+          isDragOver && "ring-2 ring-inset ring-cal-today-fg/50 bg-cal-today-bg/30"
+        ),
+        onClick: handleClick,
+        children: slots.dayCellContent({
+          date: cell.date,
+          isToday: cell.isToday,
+          isCurrentMonth: cell.isCurrentMonth,
+          isWeekend: cell.isWeekend,
+          dayNumberText: String(cell.date.day),
+          events: cell.events.map((e) => e.event)
+        })
+      }
+    );
+  }
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      ref: cellRef,
+      className: cn(
+        dayCellVariants({ variant }),
+        isDragOver && "ring-2 ring-inset ring-cal-today-fg/50 bg-cal-today-bg/30"
+      ),
+      onClick: handleClick,
+      children: [
+        /* @__PURE__ */ jsx(
+          "div",
+          {
+            className: cn(
+              "text-xs font-medium mb-1",
+              cell.isToday && "inline-flex items-center justify-center w-6 h-6 rounded-full bg-cal-today-fg text-white",
+              !cell.isCurrentMonth && "opacity-40",
+              navLinkDayClick && "cursor-pointer hover:text-cal-today-fg hover:underline"
+            ),
+            onClick: navLinkDayClick ? handleDayNumberClick : void 0,
+            role: navLinkDayClick ? "link" : void 0,
+            children: cell.date.day
+          }
+        ),
+        /* @__PURE__ */ jsx("div", { className: "space-y-0.5", children: cell.events.map((posEvent) => /* @__PURE__ */ jsx(EventCard, { positionedEvent: posEvent, compact: true }, posEvent.event.id)) }),
+        cell.moreCount > 0 && /* @__PURE__ */ jsx(
+          MorePopover,
+          {
+            events: cell.events,
+            count: cell.moreCount,
+            dateStr: cell.date.toString(),
+            moreLinkClick
+          }
+        )
+      ]
+    }
+  );
+}
+function DayGrid({
+  className,
+  fixedWeekCount = false,
+  showNonCurrentDates = true,
+  weekNumbers = false
+}) {
+  const { viewLayout, locale } = useCalendarContext();
+  if (!viewLayout?.weeks) return null;
+  let weeks = viewLayout.weeks;
+  if (fixedWeekCount && weeks.length < 6) {
+    weeks = [...weeks];
+    while (weeks.length < 6) {
+      const lastWeek = weeks[weeks.length - 1];
+      const lastDate = lastWeek[lastWeek.length - 1].date;
+      const newWeek = [];
+      for (let d = 1; d <= 7; d++) {
+        const date = lastDate.add({ days: d });
+        newWeek.push({
+          date,
+          dayOfWeek: date.dayOfWeek,
+          isToday: false,
+          isCurrentMonth: false,
+          isWeekend: date.dayOfWeek === 6 || date.dayOfWeek === 7,
+          isHidden: false,
+          events: [],
+          moreCount: 0
+        });
+      }
+      weeks.push(newWeek);
+    }
+  } else if (!fixedWeekCount && weeks.length > 5) {
+    const lastWeek = weeks[weeks.length - 1];
+    if (lastWeek.every((cell) => !cell.isCurrentMonth)) {
+      weeks = weeks.slice(0, -1);
+    }
+  }
+  const dayLabels = weeks[0]?.map((cell) => {
+    const jsDate = new Date(cell.date.toString());
+    return new Intl.DateTimeFormat(locale, { weekday: "short" }).format(jsDate);
+  }) ?? [];
+  return /* @__PURE__ */ jsxs("div", { className: cn("tm-day-grid-wrapper flex-1 flex flex-col overflow-hidden", className), children: [
+    /* @__PURE__ */ jsxs(
+      "div",
+      {
+        className: "border-b border-cal-border",
+        style: {
+          display: "grid",
+          gridTemplateColumns: weekNumbers ? `2rem repeat(7, 1fr)` : `repeat(7, 1fr)`
+        },
+        children: [
+          weekNumbers && /* @__PURE__ */ jsx("div", { className: "py-2 text-center text-xs font-medium text-cal-fg opacity-40", children: "Wk" }),
+          dayLabels.map((label, i) => /* @__PURE__ */ jsx("div", { className: "py-2 text-center text-xs font-medium text-cal-fg opacity-60", children: label }, i))
+        ]
+      }
+    ),
+    /* @__PURE__ */ jsx("div", { className: "flex-1 flex flex-col", children: weeks.map((week, weekIdx) => /* @__PURE__ */ jsxs(
+      "div",
+      {
+        className: "flex-1",
+        style: {
+          display: "grid",
+          gridTemplateColumns: weekNumbers ? `2rem repeat(7, 1fr)` : `repeat(7, 1fr)`,
+          minHeight: "5rem"
+        },
+        children: [
+          weekNumbers && week[0] && /* @__PURE__ */ jsx("div", { className: "flex items-start justify-center pt-1 text-[10px] text-cal-fg-muted border-r border-cal-border", children: getWeekNumber(week[0].date) }),
+          week.map((cell) => {
+            if (!showNonCurrentDates && !cell.isCurrentMonth) {
+              return /* @__PURE__ */ jsx(
+                "div",
+                {
+                  className: "min-h-[5rem] border-r border-b border-cal-border"
+                },
+                cell.date.toString()
+              );
+            }
+            return /* @__PURE__ */ jsx(DayCell, { cell }, cell.date.toString());
+          })
+        ]
+      },
+      weekIdx
+    )) })
+  ] });
+}
+function TimeSlot({ slot, date, resourceId }) {
+  const { slots, onDateSelect, selectable, editable } = useCalendarContext();
+  const slotRef = useRef(null);
+  const [isDragOver, setIsDragOver] = useState(false);
+  const variant = slot.isBusinessHour ? "business" : slot.index % 2 === 0 ? "default" : "odd";
+  useEffect(() => {
+    const el = slotRef.current;
+    if (!el || !editable || !date) return;
+    const cleanup = dropTargetForElements({
+      element: el,
+      getData: () => ({
+        date: date.toString(),
+        time: slot.time.toString(),
+        resourceId: resourceId ?? null
+      }),
+      canDrop: ({ source }) => source.data.type === CALENDAR_EVENT_TYPE,
+      onDragEnter: () => setIsDragOver(true),
+      onDragLeave: () => setIsDragOver(false),
+      onDrop: () => setIsDragOver(false)
+    });
+    return cleanup;
+  }, [editable, date, slot.time, resourceId]);
+  const handleClick = () => {
+    if (selectable && onDateSelect) {
+      onDateSelect({ start: slot.start, end: slot.end });
+    }
+  };
+  if (slots.slotContent) {
+    return /* @__PURE__ */ jsx(
+      "div",
+      {
+        ref: slotRef,
+        className: cn(timeSlotVariants({ variant }), isDragOver && "bg-cal-today-bg/50"),
+        style: { height: "var(--cal-slot-height)" },
+        onClick: handleClick,
+        children: slots.slotContent({
+          start: slot.start,
+          end: slot.end,
+          isBusinessHour: slot.isBusinessHour
+        })
+      }
+    );
+  }
+  return /* @__PURE__ */ jsx(
+    "div",
+    {
+      ref: slotRef,
+      className: cn(timeSlotVariants({ variant }), isDragOver && "bg-cal-today-bg/50"),
+      style: { height: "var(--cal-slot-height)" },
+      onClick: handleClick,
+      role: selectable ? "button" : void 0,
+      tabIndex: selectable ? 0 : void 0
+    }
+  );
+}
+function NowIndicator({ position }) {
+  const { slots } = useCalendarContext();
+  if (slots.nowIndicatorContent) {
+    return /* @__PURE__ */ jsx("div", { className: "tm-now-indicator", style: { top: `${position}%` }, children: slots.nowIndicatorContent() });
+  }
+  return /* @__PURE__ */ jsx("div", { className: "tm-now-indicator", style: { top: `${position}%` } });
+}
+function AllDayRow({ events, className }) {
+  if (events.length === 0) return null;
+  return /* @__PURE__ */ jsx("div", { className: cn("tm-all-day-row border-b border-cal-border px-2", className), children: events.map((posEvent) => /* @__PURE__ */ jsx(EventCard, { positionedEvent: posEvent, compact: true }, posEvent.event.id)) });
+}
+function TimeGrid({
+  className,
+  scrollTime = "06:00:00",
+  scrollTimeReset = true,
+  stickyHeaderDates = true,
+  slotLabelFormat,
+  stickyFooterScrollbar = false
+}) {
+  const { viewLayout, locale, currentView } = useCalendarContext();
+  const scrollContainerRef = useRef(null);
+  useEffect(() => {
+    const container = scrollContainerRef.current;
+    if (!container || !viewLayout?.timeSlots) return;
+    try {
+      const scrollTarget = Temporal.PlainTime.from(scrollTime);
+      const slots = viewLayout.timeSlots;
+      if (slots.length === 0) return;
+      const firstSlot = slots[0];
+      const totalMinutes = slots[slots.length - 1].time.hour * 60 + slots[slots.length - 1].time.minute - (firstSlot.time.hour * 60 + firstSlot.time.minute);
+      const targetMinutes = scrollTarget.hour * 60 + scrollTarget.minute - (firstSlot.time.hour * 60 + firstSlot.time.minute);
+      if (totalMinutes > 0) {
+        const scrollPercent = Math.max(0, Math.min(1, targetMinutes / totalMinutes));
+        container.scrollTop = scrollPercent * container.scrollHeight;
+      }
+    } catch {
+    }
+  }, [scrollTime, scrollTimeReset ? currentView : null, viewLayout?.timeSlots]);
+  if (!viewLayout?.columns) return null;
+  const columns = viewLayout.columns;
+  const timeSlots = viewLayout.timeSlots ?? [];
+  const allDayRow = viewLayout.allDayRow ?? [];
+  const nowPosition = viewLayout.nowPosition;
+  const gridCols = `var(--cal-time-axis-width, 4rem) repeat(${columns.length}, 1fr)`;
+  const formatSlotTime = (time) => {
+    if (slotLabelFormat) {
+      const jsDate = new Date(2e3, 0, 1, time.hour, time.minute);
+      return new Intl.DateTimeFormat(locale, slotLabelFormat).format(jsDate);
+    }
+    return formatTime(time, locale);
+  };
+  return /* @__PURE__ */ jsxs("div", { className: cn("flex-1 flex flex-col overflow-hidden", className), children: [
+    allDayRow.length > 0 && /* @__PURE__ */ jsx(AllDayRow, { events: allDayRow }),
+    /* @__PURE__ */ jsxs(
+      "div",
+      {
+        className: cn(
+          "border-b border-cal-border bg-cal-header-bg shrink-0",
+          stickyHeaderDates && "sticky top-0 z-10"
+        ),
+        style: {
+          display: "grid",
+          gridTemplateColumns: gridCols
+        },
+        children: [
+          /* @__PURE__ */ jsx("div", {}),
+          " ",
+          columns.map((col) => {
+            const jsDate = new Date(col.date.toString());
+            const dayName = new Intl.DateTimeFormat(locale, { weekday: "short" }).format(jsDate);
+            const dayNum = col.date.day;
+            const isToday = col.date.equals(Temporal.Now.plainDateISO());
+            return /* @__PURE__ */ jsxs("div", { className: "text-center py-2 border-l border-cal-border", children: [
+              /* @__PURE__ */ jsx("div", { className: "text-xs font-medium opacity-60", children: dayName }),
+              /* @__PURE__ */ jsx(
+                "div",
+                {
+                  className: cn(
+                    "text-lg font-semibold",
+                    isToday && "inline-flex items-center justify-center w-8 h-8 rounded-full bg-cal-today-fg text-white"
+                  ),
+                  children: dayNum
+                }
+              )
+            ] }, col.date.toString());
+          })
+        ]
+      }
+    ),
+    /* @__PURE__ */ jsx("div", { ref: scrollContainerRef, className: "flex-1 overflow-y-auto tm-scrollable", children: /* @__PURE__ */ jsxs(
+      "div",
+      {
+        style: {
+          display: "grid",
+          gridTemplateColumns: gridCols,
+          position: "relative"
+        },
+        children: [
+          /* @__PURE__ */ jsx("div", { children: timeSlots.map((slot) => /* @__PURE__ */ jsx(
+            "div",
+            {
+              className: "relative border-b border-cal-slot-border",
+              style: { height: "var(--cal-slot-height, 3rem)" },
+              children: slot.time.minute === 0 && /* @__PURE__ */ jsx("span", { className: "absolute -top-3 right-2 text-[10px] text-cal-fg opacity-50", children: formatSlotTime(slot.time) })
+            },
+            slot.index
+          )) }),
+          columns.map((col) => /* @__PURE__ */ jsxs("div", { className: "relative border-l border-cal-border", children: [
+            col.slots.map((slot) => /* @__PURE__ */ jsx(TimeSlot, { slot, date: col.date }, slot.index)),
+            col.events.map((posEvent) => /* @__PURE__ */ jsx(
+              "div",
+              {
+                className: "absolute overflow-hidden z-1",
+                style: {
+                  top: `${posEvent.top}%`,
+                  height: `${Math.max(posEvent.height, 2)}%`,
+                  left: `${posEvent.left}%`,
+                  width: `${posEvent.width}%`,
+                  minHeight: "1.25rem"
+                },
+                children: /* @__PURE__ */ jsx(EventCard, { positionedEvent: posEvent })
+              },
+              posEvent.event.id
+            )),
+            nowPosition !== void 0 && nowPosition >= 0 && col.date.equals(Temporal.Now.plainDateISO()) && /* @__PURE__ */ jsx(NowIndicator, { position: nowPosition })
+          ] }, col.date.toString()))
+        ]
+      }
+    ) }),
+    stickyFooterScrollbar && /* @__PURE__ */ jsx("div", { className: "sticky bottom-0 h-3 bg-cal-bg border-t border-cal-border overflow-x-auto shrink-0" })
+  ] });
+}
+function ResourceLane({ lane, slotCount }) {
+  const { slots } = useCalendarContext();
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      className: "grid border-b border-cal-border",
+      style: { gridTemplateColumns: `var(--cal-resource-header-width) repeat(${slotCount}, 1fr)` },
+      children: [
+        /* @__PURE__ */ jsx("div", { className: "p-2 border-r border-cal-border bg-cal-header-bg", children: slots.resourceLabelContent ? slots.resourceLabelContent({ resource: lane.resource }) : /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-2", children: [
+          lane.resource.color && /* @__PURE__ */ jsx(
+            "div",
+            {
+              className: "w-2 h-2 rounded-full flex-shrink-0",
+              style: { backgroundColor: lane.resource.color }
+            }
+          ),
+          /* @__PURE__ */ jsx("span", { className: "text-sm font-medium truncate", children: lane.resource.title })
+        ] }) }),
+        /* @__PURE__ */ jsx(
+          "div",
+          {
+            className: cn("relative col-span-full", `col-start-2`),
+            style: { gridColumn: `2 / -1`, minHeight: "var(--cal-slot-height)" },
+            children: lane.events.map((posEvent) => /* @__PURE__ */ jsx(
+              "div",
+              {
+                className: "tm-event",
+                style: {
+                  left: `${posEvent.left}%`,
+                  width: `${posEvent.width}%`,
+                  top: "2px",
+                  height: "calc(100% - 4px)"
+                },
+                children: /* @__PURE__ */ jsx(EventCard, { positionedEvent: posEvent, compact: true })
+              },
+              posEvent.event.id
+            ))
+          }
+        )
+      ]
+    }
+  );
+}
+function Timeline({ className }) {
+  const { viewLayout, locale } = useCalendarContext();
+  if (!viewLayout?.lanes) return null;
+  const lanes = viewLayout.lanes;
+  const timeSlots = viewLayout.timeSlots ?? [];
+  return /* @__PURE__ */ jsxs("div", { className: cn("flex-1 overflow-hidden tm-timeline", className), children: [
+    /* @__PURE__ */ jsx("div", { className: "tm-timeline__header border-b border-cal-border bg-cal-header-bg", children: /* @__PURE__ */ jsxs(
+      "div",
+      {
+        className: "grid",
+        style: {
+          gridTemplateColumns: `var(--cal-resource-header-width) repeat(${timeSlots.length}, 1fr)`
+        },
+        children: [
+          /* @__PURE__ */ jsx("div", { className: "p-2 text-xs font-medium text-cal-fg opacity-60", children: "Resources" }),
+          timeSlots.map((slot) => /* @__PURE__ */ jsx(
+            "div",
+            {
+              className: "p-1 text-[10px] text-center border-l border-cal-slot-border opacity-50",
+              children: slot.time.minute === 0 ? formatTime(slot.time, locale) : ""
+            },
+            slot.index
+          ))
+        ]
+      }
+    ) }),
+    /* @__PURE__ */ jsx("div", { className: "overflow-y-auto tm-scrollable", children: lanes.map((lane) => /* @__PURE__ */ jsx(ResourceLane, { lane, slotCount: timeSlots.length }, lane.resource.id)) })
+  ] });
+}
+function Agenda({ className }) {
+  const { viewLayout, locale, onEventClick } = useCalendarContext();
+  if (!viewLayout?.groups) return null;
+  const groups = viewLayout.groups;
+  if (groups.length === 0) {
+    return /* @__PURE__ */ jsx("div", { className: cn("flex-1 flex items-center justify-center text-sm opacity-50", className), children: "No events to display" });
+  }
+  return /* @__PURE__ */ jsx("div", { className: cn("flex-1 overflow-y-auto tm-scrollable", className), children: groups.map((group) => {
+    const jsDate = new Date(group.date.toString());
+    const dateLabel = new Intl.DateTimeFormat(locale, {
+      weekday: "long",
+      month: "long",
+      day: "numeric"
+    }).format(jsDate);
+    const isToday = group.date.equals(Temporal.Now.plainDateISO());
+    return /* @__PURE__ */ jsxs("div", { className: "border-b border-cal-border", children: [
+      /* @__PURE__ */ jsxs(
+        "div",
+        {
+          className: cn(
+            "px-4 py-2 text-sm font-semibold bg-cal-header-bg sticky top-0",
+            isToday && "text-cal-today-fg"
+          ),
+          children: [
+            dateLabel,
+            isToday && /* @__PURE__ */ jsx("span", { className: "ml-2 text-xs font-normal opacity-60", children: "(Today)" })
+          ]
+        }
+      ),
+      /* @__PURE__ */ jsx("div", { className: "divide-y divide-cal-border", children: group.events.map((event) => /* @__PURE__ */ jsxs(
+        "div",
+        {
+          className: "px-4 py-3 flex items-start gap-3 hover:bg-cal-slot-bg-odd cursor-pointer transition-colors",
+          onClick: () => onEventClick?.(event),
+          children: [
+            /* @__PURE__ */ jsx(
+              "div",
+              {
+                className: "w-1 h-full min-h-[2rem] rounded-full flex-shrink-0 mt-0.5",
+                style: { backgroundColor: event.color ?? "var(--cal-event-default-bg)" }
+              }
+            ),
+            /* @__PURE__ */ jsxs("div", { className: "flex-1 min-w-0", children: [
+              /* @__PURE__ */ jsx("div", { className: "font-medium text-sm truncate", children: event.title }),
+              /* @__PURE__ */ jsx("div", { className: "text-xs opacity-60 mt-0.5", children: event.isAllDay ? "All day" : `${formatEventTime(event.start, locale)} \u2013 ${formatEventTime(event.end, locale)}` }),
+              event.description && /* @__PURE__ */ jsx("div", { className: "text-xs opacity-50 mt-1 truncate", children: event.description })
+            ] })
+          ]
+        },
+        event.id
+      )) })
+    ] }, group.date.toString());
+  }) });
+}
+function MultiMonth({ className }) {
+  const { viewLayout, currentView, locale } = useCalendarContext();
+  if (!viewLayout) return null;
+  const months = viewLayout.months;
+  if (!months || months.length === 0) return null;
+  const isGrid = currentView === "multiMonthGrid";
+  return /* @__PURE__ */ jsx(
+    "div",
+    {
+      className: cn(
+        "tm-multi-month overflow-auto",
+        isGrid ? "grid grid-cols-2 gap-4 p-4" : "flex flex-col gap-6 p-4",
+        className
+      ),
+      children: months.map((monthLayout, idx) => /* @__PURE__ */ jsx(
+        MonthMini,
+        {
+          month: monthLayout.month,
+          weeks: monthLayout.weeks,
+          locale
+        },
+        monthLayout.month.toString()
+      ))
+    }
+  );
+}
+function MonthMini({
+  month,
+  weeks,
+  locale
+}) {
+  const monthName = month.toLocaleString(locale, { month: "long", year: "numeric" });
+  return /* @__PURE__ */ jsxs("div", { className: "tm-mini-month border border-cal-border rounded-lg overflow-hidden", children: [
+    /* @__PURE__ */ jsx("div", { className: "px-3 py-2 font-semibold text-sm bg-cal-header-bg text-cal-fg border-b border-cal-border", children: monthName }),
+    /* @__PURE__ */ jsx("div", { className: "grid grid-cols-7 text-center text-[10px] text-cal-fg-muted py-1 border-b border-cal-border", children: weeks[0]?.map((cell, i) => {
+      const dayName = cell.date.toLocaleString(locale, { weekday: "narrow" });
+      return /* @__PURE__ */ jsx("div", { className: "font-medium", children: dayName }, i);
+    }) ?? null }),
+    /* @__PURE__ */ jsx("div", { className: "grid grid-cols-7", children: weeks.flat().map((cell) => /* @__PURE__ */ jsx(DayCell, { cell }, cell.date.toString())) })
+  ] });
+}
+function ResourceTimeGrid({ className }) {
+  const { viewLayout } = useCalendarContext();
+  if (!viewLayout) return null;
+  const slots = viewLayout.slots;
+  const resourceLanes = viewLayout.resourceLanes;
+  if (!slots || !resourceLanes || resourceLanes.length === 0) return null;
+  return /* @__PURE__ */ jsxs("div", { className: cn("tm-resource-time-grid flex flex-1 overflow-auto", className), children: [
+    /* @__PURE__ */ jsxs("div", { className: "tm-time-gutter w-16 shrink-0 border-r border-cal-border", children: [
+      /* @__PURE__ */ jsx("div", { className: "h-10 border-b border-cal-border" }),
+      slots.map((slot, idx) => /* @__PURE__ */ jsx(
+        "div",
+        {
+          className: "h-10 text-[10px] text-cal-fg-muted text-right pr-2 border-b border-cal-slot-border",
+          children: slot.time.minute === 0 ? slot.time.toLocaleString("en-US", { hour: "numeric", minute: "2-digit" }) : ""
+        },
+        idx
+      ))
+    ] }),
+    resourceLanes.map((lane) => /* @__PURE__ */ jsx(ResourceColumn, { lane, slots }, lane.resource.id))
+  ] });
+}
+function ResourceColumn({ lane, slots }) {
+  return /* @__PURE__ */ jsxs("div", { className: "tm-resource-column flex-1 min-w-[120px] border-r border-cal-border last:border-r-0", children: [
+    /* @__PURE__ */ jsx("div", { className: "h-10 flex items-center justify-center text-xs font-semibold border-b border-cal-border bg-cal-header-bg truncate px-2", children: lane.resource.title }),
+    /* @__PURE__ */ jsxs("div", { className: "relative", children: [
+      slots.map((slot, idx) => /* @__PURE__ */ jsx(
+        "div",
+        {
+          className: cn(
+            timeSlotVariants({
+              variant: slot.isBusinessHour ? "business" : idx % 2 === 0 ? "default" : "odd"
+            }),
+            "h-10"
+          )
+        },
+        idx
+      )),
+      lane.events.map((positioned) => /* @__PURE__ */ jsx(
+        "div",
+        {
+          className: "absolute px-0.5",
+          style: {
+            top: `${positioned.top}%`,
+            height: `${positioned.height}%`,
+            left: `${positioned.left}%`,
+            width: `${positioned.width}%`
+          },
+          children: /* @__PURE__ */ jsx(EventCard, { positionedEvent: positioned })
+        },
+        positioned.event.id
+      ))
+    ] })
+  ] });
+}
+function Calendar({
+  className,
+  children,
+  slots = {},
+  direction,
+  height,
+  contentHeight,
+  aspectRatio,
+  onEventClick,
+  onEventDrop,
+  onDateSelect,
+  onEventResize,
+  onEventMouseEnter,
+  onEventMouseLeave,
+  onDateClick,
+  ...options
+}) {
+  const calendarState = useCalendar(options);
+  const resolvedDirection = direction ?? (options.locale && isRtl(options.locale) ? "rtl" : "ltr");
+  useInteraction({
+    events: calendarState.events,
+    timezone: options.timezone ?? "UTC",
+    onEventDrop: onEventDrop ? (info) => {
+      onEventDrop({
+        event: info.event,
+        newStart: info.newStart,
+        newEnd: info.newEnd,
+        newResourceId: info.newResourceId
+      });
+    } : void 0,
+    onEventResize: onEventResize ? (info) => {
+      onEventResize({
+        event: info.event,
+        newStart: info.newStart,
+        newEnd: info.newEnd
+      });
+    } : void 0
+  });
+  const contextValue = {
+    ...calendarState,
+    resources: options.resources ?? [],
+    timezone: options.timezone ?? "UTC",
+    locale: options.locale ?? "en-US",
+    firstDayOfWeek: options.firstDayOfWeek ?? 0,
+    editable: options.editable ?? true,
+    selectable: options.selectable ?? false,
+    selectedRange: null,
+    select: (_start, _end) => {
+    },
+    unselect: () => {
+    },
+    slots,
+    onEventClick,
+    onEventDrop,
+    onDateSelect,
+    onEventResize,
+    onEventMouseEnter,
+    onEventMouseLeave,
+    onDateClick
+  };
+  const containerStyle = {
+    ...height ? { height: typeof height === "number" ? `${height}px` : height } : {},
+    ...contentHeight ? { maxHeight: typeof contentHeight === "number" ? `${contentHeight}px` : contentHeight } : {},
+    ...aspectRatio ? { aspectRatio: String(aspectRatio) } : {}
+  };
+  return /* @__PURE__ */ jsx(CalendarContext.Provider, { value: contextValue, children: /* @__PURE__ */ jsx(
+    "div",
+    {
+      dir: resolvedDirection,
+      style: containerStyle,
+      className: cn(
+        "tm-calendar flex flex-col bg-cal-bg text-cal-fg border border-cal-border overflow-hidden",
+        className
+      ),
+      role: "application",
+      "aria-label": "Calendar",
+      children: children ?? /* @__PURE__ */ jsxs(Fragment, { children: [
+        /* @__PURE__ */ jsx(Calendar.Header, {}),
+        /* @__PURE__ */ jsx(Calendar.View, {})
+      ] })
+    }
+  ) });
+}
+function CalendarHeaderSlot({ className }) {
+  return /* @__PURE__ */ jsx(CalendarHeader, { className });
+}
+CalendarHeaderSlot.displayName = "Calendar.Header";
+function CalendarViewSlot({ className }) {
+  return /* @__PURE__ */ jsx(CalendarViewRenderer, { className });
+}
+CalendarViewSlot.displayName = "Calendar.View";
+Calendar.Header = CalendarHeaderSlot;
+Calendar.View = CalendarViewSlot;
+Calendar.NavPrev = CalendarNavPrev;
+Calendar.NavNext = CalendarNavNext;
+Calendar.NavToday = CalendarNavToday;
+Calendar.Title = CalendarTitle;
+Calendar.ViewSwitcher = CalendarViewSwitcher;
+function CalendarNavPrev({ className }) {
+  const { prev } = React16__default.useContext(CalendarContext);
+  return /* @__PURE__ */ jsx(
+    Button,
+    {
+      variant: "outline",
+      size: "icon",
+      onClick: prev,
+      className,
+      "aria-label": "Previous",
+      children: /* @__PURE__ */ jsx("svg", { width: "16", height: "16", viewBox: "0 0 16 16", fill: "none", children: /* @__PURE__ */ jsx(
+        "path",
+        {
+          d: "M10 12L6 8L10 4",
+          stroke: "currentColor",
+          strokeWidth: "2",
+          strokeLinecap: "round",
+          strokeLinejoin: "round"
+        }
+      ) })
+    }
+  );
+}
+CalendarNavPrev.displayName = "Calendar.NavPrev";
+function CalendarNavNext({ className }) {
+  const { next } = React16__default.useContext(CalendarContext);
+  return /* @__PURE__ */ jsx(Button, { variant: "outline", size: "icon", onClick: next, className, "aria-label": "Next", children: /* @__PURE__ */ jsx("svg", { width: "16", height: "16", viewBox: "0 0 16 16", fill: "none", children: /* @__PURE__ */ jsx(
+    "path",
+    {
+      d: "M6 4L10 8L6 12",
+      stroke: "currentColor",
+      strokeWidth: "2",
+      strokeLinecap: "round",
+      strokeLinejoin: "round"
+    }
+  ) }) });
+}
+CalendarNavNext.displayName = "Calendar.NavNext";
+function CalendarNavToday({ className }) {
+  const { today } = React16__default.useContext(CalendarContext);
+  return /* @__PURE__ */ jsx(Button, { variant: "outline", size: "sm", onClick: today, className, children: "Today" });
+}
+CalendarNavToday.displayName = "Calendar.NavToday";
+function CalendarTitle({ className }) {
+  const { title } = React16__default.useContext(CalendarContext);
+  return /* @__PURE__ */ jsx("h2", { className: cn("text-lg font-semibold text-cal-header-fg", className), children: title });
+}
+CalendarTitle.displayName = "Calendar.Title";
+function CalendarViewSwitcher({ views, className }) {
+  const { currentView, changeView } = React16__default.useContext(CalendarContext);
+  const defaultViews = views ?? ["dayGridMonth", "timeGridWeek", "timeGridDay"];
+  const viewLabels = {
+    dayGridMonth: "Month",
+    dayGridWeek: "Week",
+    dayGridDay: "Day",
+    timeGridWeek: "Week",
+    timeGridDay: "Day",
+    timelineDay: "Timeline",
+    timelineWeek: "Timeline",
+    timelineMonth: "Timeline",
+    agendaDay: "Agenda",
+    agendaWeek: "Agenda",
+    agendaMonth: "Agenda"
+  };
+  return /* @__PURE__ */ jsx(
+    ToggleGroup,
+    {
+      value: [currentView],
+      onValueChange: (newValue) => {
+        if (newValue.length > 0) {
+          changeView(newValue[0]);
+        }
+      },
+      variant: "outline",
+      className,
+      children: defaultViews.map((view) => /* @__PURE__ */ jsx(ToggleGroupItem, { value: view, size: "sm", children: viewLabels[view] ?? view }, view))
+    }
+  );
+}
+CalendarViewSwitcher.displayName = "Calendar.ViewSwitcher";
+function CalendarViewRenderer({ className }) {
+  const context = React16__default.useContext(CalendarContext);
+  if (!context) return null;
+  const { currentView, viewLayout } = context;
+  if (!viewLayout)
+    return /* @__PURE__ */ jsx("div", { className: cn("flex-1 flex items-center justify-center text-sm opacity-50", className), children: "No plugin registered for this view" });
+  const viewType = currentView.startsWith("dayGrid") ? "dayGrid" : currentView.startsWith("timeGrid") ? "timeGrid" : currentView.startsWith("timeline") ? "timeline" : currentView.startsWith("multiMonth") ? "multiMonth" : currentView.startsWith("resourceTimeGrid") ? "resourceTimeGrid" : "agenda";
+  switch (viewType) {
+    case "dayGrid":
+      return /* @__PURE__ */ jsx(DayGrid, { className });
+    case "timeGrid":
+      return /* @__PURE__ */ jsx(TimeGrid, { className });
+    case "timeline":
+      return /* @__PURE__ */ jsx(Timeline, { className });
+    case "multiMonth":
+      return /* @__PURE__ */ jsx(MultiMonth, { className });
+    case "resourceTimeGrid":
+      return /* @__PURE__ */ jsx(ResourceTimeGrid, { className });
+    case "agenda":
+      return /* @__PURE__ */ jsx(Agenda, { className });
+    default:
+      return null;
+  }
+}
+function CalendarFooter({
+  className,
+  toolbar,
+  buttonText,
+  customButtons
+}) {
+  if (!toolbar) return null;
+  return /* @__PURE__ */ jsx("div", { className: cn("border-t border-cal-border", className), children: /* @__PURE__ */ jsx(
+    CalendarHeader,
+    {
+      toolbar,
+      buttonText,
+      customButtons,
+      className: "border-b-0"
+    }
+  ) });
+}
+function BackgroundEvent({ backgroundEvent, variant = "timeGrid" }) {
+  const { event, top, height } = backgroundEvent;
+  const bgColor = event.backgroundColor ?? event.color ?? "var(--cal-event-default-bg)";
+  if (variant === "dayGrid") {
+    return /* @__PURE__ */ jsx(
+      "div",
+      {
+        className: cn("absolute inset-0 pointer-events-none", event.className),
+        style: {
+          backgroundColor: bgColor,
+          opacity: 0.3
+        },
+        "aria-hidden": "true",
+        title: event.title
+      }
+    );
+  }
+  return /* @__PURE__ */ jsx(
+    "div",
+    {
+      className: cn("absolute left-0 right-0 pointer-events-none rounded-sm", event.className),
+      style: {
+        top: `${top}%`,
+        height: `${Math.max(height, 0.5)}%`,
+        backgroundColor: bgColor,
+        opacity: 0.3
+      },
+      "aria-hidden": "true",
+      title: event.title
+    }
+  );
+}
+
+// src/hooks/use-navigation.ts
+function useNavigation() {
+  const { next, prev, today, goToDate, currentDate, title } = useCalendarContext();
+  return { next, prev, today, goToDate, currentDate, title };
+}
+
+// src/hooks/use-events.ts
+function useEvents() {
+  const { events, addEvent, updateEvent, removeEvent } = useCalendarContext();
+  return { events, addEvent, updateEvent, removeEvent };
+}
+
+// src/hooks/use-view.ts
+function useView() {
+  const { currentView, changeView, viewLayout } = useCalendarContext();
+  return { currentView, changeView, viewLayout };
+}
+function useSlots() {
+  const { viewLayout } = useCalendarContext();
+  return {
+    timeSlots: viewLayout?.timeSlots ?? [],
+    columns: viewLayout?.columns ?? []
+  };
+}
+function useDropSlot(options) {
+  const { date, time, resourceId, viewConfig, timezone, onEventDrop, onDragEnter, onDragLeave } = options;
+  const dropRef = useRef(null);
+  const [isDragOver, setIsDragOver] = useState(false);
+  const [canDrop, setCanDrop] = useState(false);
+  useEffect(() => {
+    const el = dropRef.current;
+    if (!el) return;
+    const cleanup = dropTargetForElements({
+      element: el,
+      getData: () => ({
+        date: date.toString(),
+        time: time?.toString() ?? null,
+        resourceId: resourceId ?? null
+      }),
+      canDrop: ({ source }) => {
+        return source.data.type === CALENDAR_EVENT_TYPE;
+      },
+      onDragEnter: () => {
+        setIsDragOver(true);
+        setCanDrop(true);
+        onDragEnter?.();
+      },
+      onDragLeave: () => {
+        setIsDragOver(false);
+        setCanDrop(false);
+        onDragLeave?.();
+      },
+      onDrop: ({ source }) => {
+        setIsDragOver(false);
+        setCanDrop(false);
+        const data = source.data;
+        if (data.type !== CALENDAR_EVENT_TYPE) return;
+        const slotTime = time ?? Temporal.PlainTime.from("00:00");
+        const newStart = date.toZonedDateTime({
+          timeZone: timezone,
+          plainTime: slotTime
+        });
+        const originalStart = Temporal.ZonedDateTime.from(data.eventStart);
+        const originalEnd = Temporal.ZonedDateTime.from(data.eventEnd);
+        const duration = originalStart.until(originalEnd);
+        const newEnd = newStart.add(duration);
+        onEventDrop?.({
+          event: {
+            id: data.eventId,
+            title: data.eventTitle
+          },
+          newStart,
+          newEnd,
+          newResourceId: resourceId
+        });
+      }
+    });
+    return cleanup;
+  }, [date, time, resourceId, viewConfig, timezone, onEventDrop, onDragEnter, onDragLeave]);
+  return { dropRef, isDragOver, canDrop };
+}
+function useSelection(options = {}) {
+  const {
+    selectable = true,
+    selectMinDistance = 0,
+    selectMirror = false,
+    unselectAuto = true,
+    unselectCancel,
+    timezone = "UTC",
+    onSelect,
+    onUnselect,
+    onDateClick
+  } = options;
+  const [state, setState] = useState({
+    isSelecting: false,
+    selection: null,
+    previewStart: null,
+    previewEnd: null
+  });
+  const previewEndRef = useRef(null);
+  const selectionContext = useRef(null);
+  const startSelection = useCallback(
+    (info) => {
+      if (!selectable) return;
+      const plainTime = info.time ?? Temporal.PlainTime.from("00:00");
+      const startZdt = info.date.toZonedDateTime({
+        timeZone: timezone,
+        plainTime
+      });
+      selectionContext.current = {
+        startDate: info.date,
+        startTime: info.time ?? null,
+        resourceId: info.resourceId,
+        allDay: info.allDay ?? !info.time,
+        startX: 0,
+        startY: 0,
+        hasMovedEnough: selectMinDistance === 0
+      };
+      setState({
+        isSelecting: true,
+        selection: null,
+        previewStart: selectMirror ? startZdt : null,
+        previewEnd: selectMirror ? startZdt : null
+      });
+    },
+    [selectable, timezone, selectMinDistance, selectMirror]
+  );
+  const updateSelection = useCallback(
+    (info) => {
+      if (!selectionContext.current) return;
+      const ctx = selectionContext.current;
+      ctx.hasMovedEnough = true;
+      const endTime = info.time ?? Temporal.PlainTime.from("23:59:59");
+      const endZdt = info.date.toZonedDateTime({
+        timeZone: timezone,
+        plainTime: endTime
+      });
+      const startTime = ctx.startTime ?? Temporal.PlainTime.from("00:00");
+      const startZdt = ctx.startDate.toZonedDateTime({
+        timeZone: timezone,
+        plainTime: startTime
+      });
+      const [realStart, realEnd] = Temporal.ZonedDateTime.compare(startZdt, endZdt) <= 0 ? [startZdt, endZdt] : [endZdt, startZdt];
+      if (selectMirror) {
+        previewEndRef.current = realEnd;
+      }
+      setState((prev) => ({
+        ...prev,
+        previewStart: selectMirror ? realStart : null,
+        previewEnd: selectMirror ? realEnd : null
+      }));
+    },
+    [timezone, selectMirror]
+  );
+  const endSelection = useCallback(() => {
+    const ctx = selectionContext.current;
+    if (!ctx) return;
+    const startTime = ctx.startTime ?? Temporal.PlainTime.from("00:00");
+    const startZdt = ctx.startDate.toZonedDateTime({
+      timeZone: timezone,
+      plainTime: startTime
+    });
+    if (!ctx.hasMovedEnough) {
+      onDateClick?.({
+        date: ctx.startDate,
+        dateStr: ctx.startDate.toString(),
+        allDay: ctx.allDay,
+        resourceId: ctx.resourceId
+      });
+      setState({
+        isSelecting: false,
+        selection: null,
+        previewStart: null,
+        previewEnd: null
+      });
+      selectionContext.current = null;
+      return;
+    }
+    const endZdt = previewEndRef.current ?? startZdt.add({ hours: 1 });
+    const [realStart, realEnd] = Temporal.ZonedDateTime.compare(startZdt, endZdt) <= 0 ? [startZdt, endZdt] : [endZdt, startZdt];
+    const selection = {
+      start: realStart,
+      end: realEnd,
+      allDay: ctx.allDay,
+      resourceId: ctx.resourceId
+    };
+    setState({
+      isSelecting: false,
+      selection,
+      previewStart: null,
+      previewEnd: null
+    });
+    previewEndRef.current = null;
+    onSelect?.(selection);
+    selectionContext.current = null;
+  }, [timezone, onSelect, onDateClick]);
+  const clearSelection = useCallback(() => {
+    setState({
+      isSelecting: false,
+      selection: null,
+      previewStart: null,
+      previewEnd: null
+    });
+    selectionContext.current = null;
+    onUnselect?.();
+  }, [onUnselect]);
+  const select = useCallback(
+    (start, end) => {
+      const selection = {
+        start,
+        end,
+        allDay: false
+      };
+      setState({
+        isSelecting: false,
+        selection,
+        previewStart: null,
+        previewEnd: null
+      });
+      onSelect?.(selection);
+    },
+    [onSelect]
+  );
+  useEffect(() => {
+    if (!unselectAuto || !state.selection) return;
+    const handleClick = (e) => {
+      if (unselectCancel && e.target.closest(unselectCancel)) {
+        return;
+      }
+      clearSelection();
+    };
+    const timeoutId = setTimeout(() => {
+      document.addEventListener("mousedown", handleClick);
+    }, 0);
+    return () => {
+      clearTimeout(timeoutId);
+      document.removeEventListener("mousedown", handleClick);
+    };
+  }, [unselectAuto, unselectCancel, state.selection, clearSelection]);
+  return {
+    state,
+    startSelection,
+    updateSelection,
+    endSelection,
+    clearSelection,
+    select
+  };
+}
+function useTemporalNow(intervalMs = 6e4, timezone) {
+  const [now, setNow] = useState(
+    () => timezone ? Temporal.Now.zonedDateTimeISO(timezone) : Temporal.Now.zonedDateTimeISO()
+  );
+  useEffect(() => {
+    const update = () => {
+      setNow(timezone ? Temporal.Now.zonedDateTimeISO(timezone) : Temporal.Now.zonedDateTimeISO());
+    };
+    const id = setInterval(update, intervalMs);
+    return () => clearInterval(id);
+  }, [intervalMs, timezone]);
+  return now;
+}
+function useEventSources(options) {
+  const {
+    eventSources: sourceInputs,
+    visibleRange,
+    timezone,
+    eventDefaults,
+    progressiveEventRendering = false,
+    onLoading,
+    onSourceError
+  } = options;
+  const [sources, setSources] = useState(
+    () => createEventSources(sourceInputs)
+  );
+  const [eventStore, setEventStore] = useState(() => EventStore.from([], timezone, eventDefaults));
+  const [isLoading, setIsLoading] = useState(false);
+  const prevRangeRef = useRef("");
+  const abortRef = useRef(null);
+  const sourcesRef = useRef(sources);
+  useEffect(() => {
+    sourcesRef.current = sources;
+  }, [sources]);
+  useEffect(() => {
+    setSources(createEventSources(sourceInputs));
+  }, [sourceInputs]);
+  const fetchAll = useCallback(async () => {
+    abortRef.current?.abort();
+    const abort = new AbortController();
+    abortRef.current = abort;
+    setIsLoading(true);
+    onLoading?.(true);
+    setSources(
+      (prev) => prev.map((s) => ({ ...s, state: "loading", error: null }))
+    );
+    const sourceDefs = sourcesRef.current.map((s) => s.def);
+    if (progressiveEventRendering) {
+      const allEvents = [];
+      for (const source of sourceDefs) {
+        if (abort.signal.aborted) break;
+        try {
+          const events = await fetchEventSource(source, visibleRange, timezone);
+          allEvents.push(...events);
+          setSources(
+            (prev) => prev.map(
+              (s) => s.id === source.id ? { ...s, state: "success", events, lastFetched: Date.now() } : s
+            )
+          );
+          setEventStore(EventStore.from(allEvents, timezone, eventDefaults));
+        } catch (error) {
+          const err = error;
+          setSources(
+            (prev) => prev.map(
+              (s) => s.id === source.id ? { ...s, state: "failure", error: err } : s
+            )
+          );
+          onSourceError?.(source.id, err);
+        }
+      }
+    } else {
+      const { events, errors } = await mergeEventSources(sourceDefs, visibleRange, timezone);
+      if (!abort.signal.aborted) {
+        setEventStore(EventStore.from(events, timezone, eventDefaults));
+        setSources(
+          (prev) => prev.map((s) => {
+            if (errors.has(s.id)) {
+              const err = errors.get(s.id);
+              onSourceError?.(s.id, err);
+              return { ...s, state: "failure", error: err };
+            }
+            return { ...s, state: "success", lastFetched: Date.now() };
+          })
+        );
+      }
+    }
+    if (!abort.signal.aborted) {
+      setIsLoading(false);
+      onLoading?.(false);
+    }
+  }, [visibleRange, timezone, eventDefaults, progressiveEventRendering, onLoading, onSourceError]);
+  useEffect(() => {
+    const rangeKey = `${visibleRange.start.toString()}-${visibleRange.end.toString()}`;
+    if (rangeKey === prevRangeRef.current) return;
+    prevRangeRef.current = rangeKey;
+    fetchAll();
+  }, [visibleRange, fetchAll]);
+  const refetchAll = useCallback(() => {
+    prevRangeRef.current = "";
+    fetchAll();
+  }, [fetchAll]);
+  const refetch = useCallback(
+    async (sourceId) => {
+      const source = sources.find((s) => s.id === sourceId);
+      if (!source) return;
+      setSources(
+        (prev) => prev.map((s) => s.id === sourceId ? { ...s, state: "loading" } : s)
+      );
+      try {
+        const events = await fetchEventSource(source.def, visibleRange, timezone);
+        setSources(
+          (prev) => prev.map(
+            (s) => s.id === sourceId ? { ...s, state: "success", events, lastFetched: Date.now() } : s
+          )
+        );
+        const allEvents = [];
+        sources.forEach((s) => {
+          if (s.id === sourceId) {
+            allEvents.push(...events);
+          } else {
+            allEvents.push(...s.events);
+          }
+        });
+        setEventStore(EventStore.from(allEvents, timezone, eventDefaults));
+      } catch (error) {
+        const err = error;
+        setSources(
+          (prev) => prev.map(
+            (s) => s.id === sourceId ? { ...s, state: "failure", error: err } : s
+          )
+        );
+        onSourceError?.(sourceId, err);
+      }
+    },
+    [sources, visibleRange, timezone, eventDefaults, onSourceError]
+  );
+  return {
+    events: eventStore.getAll(),
+    isLoading,
+    sources,
+    refetchAll,
+    refetch
+  };
+}
+function useExternalDrop(options) {
+  const { droppable = true, dropAccept, onDrop, onEventReceive } = options;
+  const dropRef = useRef(null);
+  const [isDraggingOver, setIsDraggingOver] = useState(false);
+  const [isExternalDragActive, setIsExternalDragActive] = useState(false);
+  const isAccepted = useCallback(
+    (type) => {
+      if (!dropAccept) return true;
+      if (typeof dropAccept === "string") return type === dropAccept;
+      if (Array.isArray(dropAccept)) return dropAccept.includes(type);
+      return dropAccept(type);
+    },
+    [dropAccept]
+  );
+  useEffect(() => {
+    if (!droppable) return;
+    return monitorForExternal({
+      onDragStart: () => setIsExternalDragActive(true),
+      onDrop: () => setIsExternalDragActive(false)
+    });
+  }, [droppable]);
+  useEffect(() => {
+    const element = dropRef.current;
+    if (!element || !droppable) return;
+    return dropTargetForExternal({
+      element,
+      onDragEnter: () => setIsDraggingOver(true),
+      onDragLeave: () => setIsDraggingOver(false),
+      onDrop: ({ source, location }) => {
+        setIsDraggingOver(false);
+        const dragData = {
+          type: "external",
+          raw: source
+        };
+        const types = source.types;
+        if (types.includes("text/plain")) {
+          dragData.type = "text";
+        }
+        if (types.includes("Files")) {
+          dragData.type = "files";
+        }
+        if (types.includes("application/json")) {
+          dragData.type = "json";
+        }
+        if (!isAccepted(dragData.type)) return;
+        const innerTarget = location.current.dropTargets[0];
+        const targetDateStr = innerTarget?.data?.date;
+        const targetTimeStr = innerTarget?.data?.time;
+        const dropInfo = {
+          date: targetDateStr ? Temporal.PlainDate.from(targetDateStr) : Temporal.Now.plainDateISO(),
+          // Fallback only if no date on drop target
+          time: targetTimeStr ? Temporal.PlainTime.from(targetTimeStr) : void 0,
+          resourceId: innerTarget?.data?.resourceId ?? void 0,
+          dragData,
+          allDay: !targetTimeStr
+        };
+        onDrop?.(dropInfo);
+        if (dragData.eventData) {
+          onEventReceive?.(dragData.eventData);
+        }
+      }
+    });
+  }, [droppable, isAccepted, onDrop, onEventReceive]);
+  return {
+    dropRef,
+    isDraggingOver,
+    isExternalDragActive
+  };
+}
+var CALENDAR_BRIDGE_TYPE = "tempus-machina-bridge";
+function useCalendarBridge(options) {
+  const { calendarId, onEventLeave, onEventReceive, onEventReturn, enabled = true } = options;
+  const calendarIdRef = useRef(calendarId);
+  useEffect(() => {
+    calendarIdRef.current = calendarId;
+  }, [calendarId]);
+  useEffect(() => {
+    if (!enabled) return;
+    return monitorForElements({
+      onDrop: ({ source, location }) => {
+        const sourceData = source.data;
+        if (sourceData[CALENDAR_BRIDGE_TYPE] !== true) return;
+        const sourceCalId = sourceData.sourceCalendarId;
+        const event = sourceData.event;
+        if (!event || !sourceCalId) return;
+        const dropTargets = location.current.dropTargets;
+        if (dropTargets.length === 0) return;
+        const targetData = dropTargets[0].data;
+        const targetCalId = targetData.calendarId;
+        if (targetCalId && targetCalId !== sourceCalId) {
+          if (sourceCalId === calendarIdRef.current) {
+            onEventLeave?.(event);
+          }
+          if (targetCalId === calendarIdRef.current) {
+            onEventReceive?.(event, sourceCalId);
+          }
+        } else if (targetCalId === sourceCalId && sourceCalId === calendarIdRef.current) {
+          onEventReturn?.(event);
+        }
+      }
+    });
+  }, [enabled, onEventLeave, onEventReceive, onEventReturn]);
+  const getBridgeData = useCallback(
+    (event) => ({
+      [CALENDAR_BRIDGE_TYPE]: true,
+      sourceCalendarId: calendarIdRef.current,
+      event
+    }),
+    []
+  );
+  const isFromOtherCalendar = useCallback((data) => {
+    return data[CALENDAR_BRIDGE_TYPE] === true && data.sourceCalendarId !== calendarIdRef.current;
+  }, []);
+  return {
+    calendarId,
+    getBridgeData,
+    isFromOtherCalendar
+  };
+}
+function useKeyboardNav(options) {
+  const {
+    containerRef,
+    enabled = true,
+    onDateNav,
+    onDateSelect,
+    onCancel,
+    onEventFocus,
+    currentView,
+    hints = {}
+  } = options;
+  const focusedIndexRef = useRef(0);
+  const handleKeyDown = useCallback(
+    (e) => {
+      if (!enabled) return;
+      const isMonthView = currentView?.startsWith("dayGrid") || currentView?.startsWith("multiMonth");
+      switch (e.key) {
+        case "ArrowLeft":
+          e.preventDefault();
+          onDateNav?.("left");
+          break;
+        case "ArrowRight":
+          e.preventDefault();
+          onDateNav?.("right");
+          break;
+        case "ArrowUp":
+          e.preventDefault();
+          onDateNav?.(isMonthView ? "up" : "up");
+          break;
+        case "ArrowDown":
+          e.preventDefault();
+          onDateNav?.(isMonthView ? "down" : "down");
+          break;
+        case "Enter":
+        case " ":
+          e.preventDefault();
+          onDateSelect?.();
+          break;
+        case "Escape":
+          e.preventDefault();
+          onCancel?.();
+          break;
+        case "Tab": {
+          const container = containerRef.current;
+          if (!container) break;
+          const focusableEvents = container.querySelectorAll(
+            '[role="button"][tabindex="0"]'
+          );
+          if (focusableEvents.length === 0) break;
+          e.preventDefault();
+          const direction = e.shiftKey ? -1 : 1;
+          focusedIndexRef.current = (focusedIndexRef.current + direction + focusableEvents.length) % focusableEvents.length;
+          const target = focusableEvents[focusedIndexRef.current];
+          target.focus();
+          onEventFocus?.(target.dataset.eventId ?? "");
+          break;
+        }
+      }
+    },
+    [enabled, onDateNav, onDateSelect, onCancel, onEventFocus, containerRef, currentView]
+  );
+  const ariaRoleDescription = currentView?.startsWith("dayGrid") ? "Month calendar" : currentView?.startsWith("timeGrid") ? "Time grid calendar" : currentView?.startsWith("timeline") ? "Timeline calendar" : "Calendar";
+  const containerProps = {
+    role: "grid",
+    tabIndex: 0,
+    "aria-label": "Calendar",
+    "aria-roledescription": ariaRoleDescription,
+    onKeyDown: handleKeyDown
+  };
+  const getCellProps = useCallback(
+    (opts) => ({
+      role: "gridcell",
+      tabIndex: opts.isSelected ? 0 : -1,
+      "aria-selected": opts.isSelected ?? false,
+      "aria-label": hints.navLinkHint ? `${hints.navLinkHint} ${opts.date}` : opts.date
+    }),
+    [hints.navLinkHint]
+  );
+  const getEventProps = useCallback(
+    (opts) => ({
+      role: "button",
+      tabIndex: 0,
+      "aria-label": hints.eventHint ? hints.eventHint(opts.title) : `${opts.title}, ${opts.timeText}`,
+      "data-event-id": opts.id
+    }),
+    [hints]
+  );
+  return {
+    containerProps,
+    getCellProps,
+    getEventProps
+  };
+}
+var SWIPE_THRESHOLD = 50;
+var SWIPE_VELOCITY_THRESHOLD = 0.3;
+function useTouch(options) {
+  const {
+    elementRef,
+    enabled = true,
+    longPressDelay = 1e3,
+    eventLongPressDelay,
+    selectLongPressDelay,
+    onEventLongPress,
+    onSlotLongPress,
+    onTap,
+    onSwipe
+  } = options;
+  const longPressTimerRef = useRef(null);
+  const [isLongPressing, setIsLongPressing] = useState(false);
+  const touchStartRef = useRef(null);
+  const hasMoved = useRef(false);
+  const clearLongPress = useCallback(() => {
+    if (longPressTimerRef.current) {
+      clearTimeout(longPressTimerRef.current);
+      longPressTimerRef.current = null;
+    }
+    setIsLongPressing(false);
+  }, []);
+  const extractTouchInfo = useCallback((touch, target) => {
+    const dataset = target.dataset;
+    return {
+      clientX: touch.clientX,
+      clientY: touch.clientY,
+      target,
+      date: dataset.date,
+      time: dataset.time,
+      eventId: dataset.eventId,
+      resourceId: dataset.resourceId
+    };
+  }, []);
+  useEffect(() => {
+    const element = elementRef.current;
+    if (!element || !enabled) return;
+    const handleTouchStart = (e) => {
+      if (e.touches.length !== 1) return;
+      const touch = e.touches[0];
+      const target = e.target;
+      touchStartRef.current = { x: touch.clientX, y: touch.clientY, time: Date.now() };
+      hasMoved.current = false;
+      const info = extractTouchInfo(touch, target);
+      const isEvent = !!info.eventId;
+      const delay = isEvent ? eventLongPressDelay ?? longPressDelay : selectLongPressDelay ?? longPressDelay;
+      longPressTimerRef.current = setTimeout(() => {
+        setIsLongPressing(true);
+        if (isEvent) {
+          onEventLongPress?.(info);
+        } else {
+          onSlotLongPress?.(info);
+        }
+      }, delay);
+    };
+    const handleTouchMove = (e) => {
+      if (!touchStartRef.current) return;
+      const touch = e.touches[0];
+      const dx = Math.abs(touch.clientX - touchStartRef.current.x);
+      const dy = Math.abs(touch.clientY - touchStartRef.current.y);
+      if (dx > 10 || dy > 10) {
+        hasMoved.current = true;
+        clearLongPress();
+      }
+    };
+    const handleTouchEnd = (e) => {
+      clearLongPress();
+      if (!touchStartRef.current) return;
+      const touch = e.changedTouches[0];
+      const dx = touch.clientX - touchStartRef.current.x;
+      const dy = touch.clientY - touchStartRef.current.y;
+      const elapsed = Date.now() - touchStartRef.current.time;
+      if (Math.abs(dx) > SWIPE_THRESHOLD || Math.abs(dy) > SWIPE_THRESHOLD) {
+        const velocity = Math.max(Math.abs(dx), Math.abs(dy)) / elapsed;
+        if (velocity > SWIPE_VELOCITY_THRESHOLD) {
+          if (Math.abs(dx) > Math.abs(dy)) {
+            onSwipe?.(dx > 0 ? "right" : "left");
+          } else {
+            onSwipe?.(dy > 0 ? "down" : "up");
+          }
+        }
+      } else if (!hasMoved.current && elapsed < 300) {
+        const target = e.target;
+        const info = extractTouchInfo(touch, target);
+        onTap?.(info);
+      }
+      touchStartRef.current = null;
+    };
+    const handleTouchCancel = () => {
+      clearLongPress();
+      touchStartRef.current = null;
+    };
+    element.addEventListener("touchstart", handleTouchStart, { passive: true });
+    element.addEventListener("touchmove", handleTouchMove, { passive: true });
+    element.addEventListener("touchend", handleTouchEnd, { passive: true });
+    element.addEventListener("touchcancel", handleTouchCancel);
+    return () => {
+      clearLongPress();
+      element.removeEventListener("touchstart", handleTouchStart);
+      element.removeEventListener("touchmove", handleTouchMove);
+      element.removeEventListener("touchend", handleTouchEnd);
+      element.removeEventListener("touchcancel", handleTouchCancel);
+    };
+  }, [
+    elementRef,
+    enabled,
+    longPressDelay,
+    eventLongPressDelay,
+    selectLongPressDelay,
+    onEventLongPress,
+    onSlotLongPress,
+    onTap,
+    onSwipe,
+    clearLongPress,
+    extractTouchInfo
+  ]);
+  return {
+    isLongPressing
+  };
+}
+function useResources(options = {}) {
+  const {
+    resources: resourcesInput,
+    resourceOrder,
+    resourceAreaWidth = 200,
+    refetchResourcesOnNavigate = false,
+    onResourceAdd,
+    onResourceChange,
+    onResourceRemove,
+    onResourcesSet
+  } = options;
+  const [resources, setResourcesState] = useState([]);
+  const [isLoading, setIsLoading] = useState(false);
+  const fetchIdRef = useRef(0);
+  const sortResources = useCallback(
+    (items) => {
+      if (!resourceOrder) return items;
+      const sorted = [...items];
+      if (typeof resourceOrder === "string") {
+        sorted.sort((a, b) => {
+          const aVal = a[resourceOrder] ?? "";
+          const bVal = b[resourceOrder] ?? "";
+          return String(aVal).localeCompare(String(bVal));
+        });
+      } else {
+        sorted.sort(resourceOrder);
+      }
+      return sorted;
+    },
+    [resourceOrder]
+  );
+  const resolveResources = useCallback(async () => {
+    if (!resourcesInput) return;
+    const fetchId = ++fetchIdRef.current;
+    if (Array.isArray(resourcesInput)) {
+      setResourcesState(sortResources(resourcesInput));
+      return;
+    }
+    setIsLoading(true);
+    try {
+      let resolved;
+      if (typeof resourcesInput === "string") {
+        const response = await fetch(resourcesInput);
+        resolved = await response.json();
+      } else {
+        resolved = await resourcesInput({
+          start: (/* @__PURE__ */ new Date()).toISOString(),
+          end: (/* @__PURE__ */ new Date()).toISOString()
+        });
+      }
+      if (fetchId === fetchIdRef.current) {
+        setResourcesState(sortResources(resolved));
+      }
+    } catch (error) {
+      console.error("[TempusMachina] Resource fetch error:", error);
+    } finally {
+      if (fetchId === fetchIdRef.current) {
+        setIsLoading(false);
+      }
+    }
+  }, [resourcesInput, sortResources]);
+  useEffect(() => {
+    resolveResources();
+  }, [resolveResources]);
+  const addResource = useCallback(
+    (resource) => {
+      const newResource = {
+        id: resource.id ?? `resource-${Date.now()}`,
+        ...resource
+      };
+      setResourcesState((prev) => sortResources([...prev, newResource]));
+      onResourceAdd?.(newResource);
+    },
+    [sortResources, onResourceAdd]
+  );
+  const removeResource = useCallback(
+    (resourceId) => {
+      setResourcesState((prev) => {
+        const removed = prev.find((r) => r.id === resourceId);
+        const next = prev.filter((r) => r.id !== resourceId);
+        if (removed) onResourceRemove?.(removed);
+        return next;
+      });
+    },
+    [onResourceRemove]
+  );
+  const updateResource = useCallback(
+    (resourceId, updates) => {
+      setResourcesState((prev) => {
+        const next = prev.map((r) => {
+          if (r.id !== resourceId) return r;
+          const updated = { ...r, ...updates };
+          onResourceChange?.(updated);
+          return updated;
+        });
+        return sortResources(next);
+      });
+    },
+    [sortResources, onResourceChange]
+  );
+  const setResources = useCallback(
+    (newResources) => {
+      const sorted = sortResources(newResources);
+      setResourcesState(sorted);
+      onResourcesSet?.(sorted);
+    },
+    [sortResources, onResourcesSet]
+  );
+  const refetchResources = useCallback(() => {
+    resolveResources();
+  }, [resolveResources]);
+  return {
+    resources,
+    isLoading,
+    addResource,
+    removeResource,
+    updateResource,
+    setResources,
+    refetchResources,
+    resourceAreaWidth
+  };
+}
+var ThemeContext = createContext(null);
+function useTheme() {
+  const context = useContext(ThemeContext);
+  if (!context) {
+    throw new Error("[tempus-machina] useTheme must be used within a CalendarThemeProvider.");
+  }
+  return context;
+}
+function CalendarThemeProvider({
+  children,
+  defaultTheme = "light"
+}) {
+  const [theme, setTheme] = useState(defaultTheme);
+  const toggleTheme = useCallback(() => {
+    setTheme((prev) => prev === "light" ? "dark" : "light");
+  }, []);
+  const value = useMemo(() => ({ theme, setTheme, toggleTheme }), [theme, toggleTheme]);
+  return /* @__PURE__ */ jsx(ThemeContext.Provider, { value, children: /* @__PURE__ */ jsx("div", { className: theme === "dark" ? "dark" : "", children }) });
+}
+
+export { Agenda, AllDayRow, BackgroundEvent, Button, CALENDAR_BRIDGE_TYPE, CALENDAR_EVENT_TYPE, Calendar, CalendarContext, CalendarFooter, CalendarHeader, CalendarThemeProvider, DayCell, DayGrid, EventCard, MultiMonth, NowIndicator, ResourceLane, ResourceTimeGrid, TimeGrid, TimeSlot, Timeline, Toggle, ToggleGroup, ToggleGroupItem, buttonVariants, cn, dayCellVariants, eventCardVariants, timeSlotVariants, toggleVariants, useCalendar, useCalendarBridge, useCalendarContext, useDragEvent, useDropSlot, useEventSources, useEvents, useExternalDrop, useInteraction, useKeyboardNav, useNavigation, useResources, useSelection, useSlots, useTemporalNow, useTheme, useTouch, useView };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map