@omidrahmati/react-slot-scheduler 1.0.0

package/dist/index.js

@@ -0,0 +1,1154 @@
+// src/components/BookingCalendar.tsx
+import React2, { useEffect, useMemo as useMemo2, useState as useState2 } from "react";
+
+// src/utils/date.ts
+function toIsoDate(date) {
+  return date.toISOString().slice(0, 10);
+}
+function getWeekDays(anchor, weekStartsOn = 6) {
+  const current = new Date(anchor);
+  current.setHours(12, 0, 0, 0);
+  const day = current.getDay();
+  const offset = (day - weekStartsOn + 7) % 7;
+  current.setDate(current.getDate() - offset);
+  return Array.from({ length: 7 }, (_, i) => {
+    const d = new Date(current);
+    d.setDate(current.getDate() + i);
+    return d;
+  });
+}
+function addDays(date, amount) {
+  const d = new Date(date);
+  d.setDate(d.getDate() + amount);
+  return d;
+}
+function generateTimeSlots(startHour, endHour, granularity) {
+  const items = [];
+  const startMinutes = startHour * 60;
+  const endMinutes = endHour * 60;
+  for (let m = startMinutes; m < endMinutes; m += granularity) {
+    const h = Math.floor(m / 60);
+    const mm = m % 60;
+    items.push(`${h.toString().padStart(2, "0")}:${mm.toString().padStart(2, "0")}`);
+  }
+  return items;
+}
+function getHourBounds(work) {
+  let start = 8;
+  let end = 20;
+  const starts = [];
+  const ends = [];
+  for (const d of work) {
+    if (d.workStartTime && d.workEndTime) {
+      starts.push(Number(d.workStartTime.split(":")[0]));
+      const [eh, em] = d.workEndTime.split(":").map(Number);
+      ends.push(eh + (em > 0 ? 1 : 0));
+    }
+  }
+  if (starts.length && ends.length) {
+    start = Math.min(...starts);
+    end = Math.max(...ends);
+  }
+  return { start, end };
+}
+function rangesOverlap(startA, endA, startB, endB) {
+  return startA < endB && endA > startB;
+}
+
+// src/styles/defaultTheme.ts
+var defaultTheme = {
+  primary: "#0f766e",
+  bg: "#f4f7f7",
+  panel: "#ffffff",
+  border: "#d6e0df",
+  text: "#102725",
+  mutedText: "#5c7270",
+  availableBg: "#dcfce7",
+  bookedBg: "#fee2e2",
+  blockedBg: "#e5e7eb",
+  customBg: "#e0f2fe"
+};
+
+// src/components/GanttScheduler.tsx
+import { useCallback, useMemo, useRef, useState } from "react";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+function toMin(t) {
+  const [h, m] = t.split(":").map(Number);
+  return h * 60 + m;
+}
+function toTime(mins) {
+  const clamped = Math.max(0, Math.min(23 * 60 + 59, mins));
+  return `${String(Math.floor(clamped / 60)).padStart(2, "0")}:${String(clamped % 60).padStart(2, "0")}`;
+}
+function snapToGrid(mins, gran) {
+  return Math.round(mins / gran) * gran;
+}
+function isoStr(d) {
+  return d.toISOString().slice(0, 10);
+}
+function addDays2(d, n) {
+  const dd = new Date(d);
+  dd.setDate(dd.getDate() + n);
+  return dd;
+}
+function assignLanesSequential(items) {
+  const n = items.length || 1;
+  return items.map((item, i) => ({ ...item, lane: i, totalLanes: n }));
+}
+function daysBetween(a, b) {
+  return Math.round((new Date(b).getTime() - new Date(a).getTime()) / 864e5);
+}
+function addDaysToIso(iso, n) {
+  const d = new Date(iso);
+  d.setDate(d.getDate() + n);
+  return isoStr(d);
+}
+function assignLanes(items) {
+  const sorted = [...items].sort((a, b) => toMin(a.startTime) - toMin(b.startTime));
+  const laneEnds = [];
+  const result = [];
+  for (const item of sorted) {
+    const s = toMin(item.startTime);
+    const e = toMin(item.endTime);
+    let assigned = laneEnds.findIndex((end) => end <= s);
+    if (assigned === -1) {
+      assigned = laneEnds.length;
+      laneEnds.push(0);
+    }
+    laneEnds[assigned] = e;
+    result.push({ ...item, lane: assigned, totalLanes: 0 });
+  }
+  const n = laneEnds.length || 1;
+  return result.map((r) => ({ ...r, totalLanes: n }));
+}
+var ROW_MIN_H = 60;
+var LANE_H = 44;
+var LANE_GAP = 4;
+var LABEL_W = 144;
+function GanttScheduler({
+  schedulerMode,
+  rows,
+  items,
+  date,
+  timeUnit = "hour",
+  scale = "week",
+  weekStartsOn = 1,
+  timeStart = 8,
+  timeEnd = 20,
+  granularity = 30,
+  locale = "en-US",
+  direction = "ltr",
+  theme,
+  onItemClick,
+  onItemMove,
+  onItemResize,
+  onItemCreate,
+  translations,
+  onDateChange
+}) {
+  const merged = { ...defaultTheme, ...theme };
+  const isRtl = direction === "rtl";
+  const todayStr = (() => {
+    const d = /* @__PURE__ */ new Date();
+    d.setHours(12, 0, 0, 0);
+    return isoStr(d);
+  })();
+  const totalMins = (timeEnd - timeStart) * 60;
+  const t = { previous: "Previous", today: "Today", next: "Next", week: "Week", month: "Month", ...translations };
+  const cssVars = {
+    "--gantt-primary": merged.primary,
+    "--gantt-bg": merged.bg,
+    "--gantt-panel": merged.panel,
+    "--gantt-border": merged.border,
+    "--gantt-text": merged.text,
+    "--gantt-muted": merged.mutedText,
+    "--gantt-booked": merged.bookedBg,
+    "--gantt-blocked": merged.blockedBg,
+    "--gantt-custom": merged.customBg
+  };
+  const hourCols = useMemo(() => {
+    if (timeUnit !== "hour") return [];
+    return Array.from(
+      { length: timeEnd - timeStart },
+      (_, i) => `${String(timeStart + i).padStart(2, "0")}:00`
+    );
+  }, [timeUnit, timeStart, timeEnd]);
+  const dayColumns = useMemo(() => {
+    if (timeUnit !== "day") return [];
+    const anchor = new Date(date);
+    anchor.setHours(12, 0, 0, 0);
+    if (scale === "week") {
+      const dow = anchor.getDay();
+      const offset = (dow - weekStartsOn + 7) % 7;
+      anchor.setDate(anchor.getDate() - offset);
+      return Array.from({ length: 7 }, (_, i) => addDays2(anchor, i));
+    }
+    if (scale === "month") {
+      const first = new Date(anchor.getFullYear(), anchor.getMonth(), 1, 12);
+      const daysInMonth = new Date(anchor.getFullYear(), anchor.getMonth() + 1, 0).getDate();
+      return Array.from({ length: daysInMonth }, (_, i) => addDays2(first, i));
+    }
+    return [new Date(anchor)];
+  }, [timeUnit, date, scale, weekStartsOn]);
+  const dayColStrs = useMemo(() => dayColumns.map(isoStr), [dayColumns]);
+  const itemsByRowHour = useMemo(() => {
+    if (timeUnit !== "hour") return /* @__PURE__ */ new Map();
+    const dateStr = isoStr(date);
+    const map = /* @__PURE__ */ new Map();
+    for (const item of items) {
+      if (item.date !== dateStr) continue;
+      const list = map.get(item.rowId) ?? [];
+      list.push(item);
+      map.set(item.rowId, list);
+    }
+    return map;
+  }, [items, date, timeUnit]);
+  const itemsByRowDate = useMemo(() => {
+    if (timeUnit !== "day") return /* @__PURE__ */ new Map();
+    const dateSet = new Set(dayColStrs);
+    const map = /* @__PURE__ */ new Map();
+    for (const item of items) {
+      if (!dateSet.has(item.date)) continue;
+      const key = `${item.rowId}__${item.date}`;
+      const list = map.get(key) ?? [];
+      list.push(item);
+      map.set(key, list);
+    }
+    return map;
+  }, [items, timeUnit, dayColStrs]);
+  const gridRef = useRef(null);
+  const [dragging, setDragging] = useState(null);
+  const [creating, setCreating] = useState(null);
+  const getTimeFromX = useCallback((clientX, grid) => {
+    const rect = grid.getBoundingClientRect();
+    const contentW = rect.width - LABEL_W;
+    const contentLeft = isRtl ? rect.left : rect.left + LABEL_W;
+    const contentRight = isRtl ? rect.right - LABEL_W : rect.right;
+    let frac = isRtl ? (contentRight - clientX) / contentW : (clientX - contentLeft) / contentW;
+    frac = Math.max(0, Math.min(1, frac));
+    return timeStart * 60 + frac * totalMins;
+  }, [isRtl, timeStart, totalMins]);
+  const getDateFromX = useCallback((clientX, grid) => {
+    if (!dayColumns.length) return null;
+    const rect = grid.getBoundingClientRect();
+    const contentW = rect.width - LABEL_W;
+    const contentLeft = isRtl ? rect.left : rect.left + LABEL_W;
+    const contentRight = isRtl ? rect.right - LABEL_W : rect.right;
+    let frac = isRtl ? (contentRight - clientX) / contentW : (clientX - contentLeft) / contentW;
+    frac = Math.max(0, Math.min(0.9999, frac));
+    const colIdx = Math.floor(frac * dayColumns.length);
+    return isoStr(dayColumns[Math.min(colIdx, dayColumns.length - 1)]);
+  }, [dayColumns, isRtl]);
+  const getRowFromY = useCallback((clientY, grid) => {
+    const scrollTop = grid.scrollTop ?? 0;
+    const rect = grid.getBoundingClientRect();
+    const relY = clientY - rect.top + scrollTop - 40;
+    let acc = 0;
+    for (const row of rows) {
+      const h = ROW_MIN_H;
+      if (relY >= acc && relY < acc + h) return row.id;
+      acc += h;
+    }
+    return null;
+  }, [rows]);
+  const onMouseMove = useCallback((e) => {
+    if (creating && gridRef.current && timeUnit === "hour") {
+      const rawMin = getTimeFromX(e.clientX, gridRef.current);
+      const snapped = snapToGrid(rawMin, granularity);
+      const endMin = Math.max(snapped, creating.startMin + granularity);
+      setCreating((c) => c ? { ...c, endMin } : null);
+      return;
+    }
+    if (creating && gridRef.current && timeUnit === "day") {
+      const hovered = getDateFromX(e.clientX, gridRef.current);
+      if (hovered) setCreating((c) => c ? { ...c, endDate: hovered } : null);
+      return;
+    }
+    if (!dragging || !gridRef.current) return;
+    if (timeUnit === "hour") {
+      const rawMin = getTimeFromX(e.clientX, gridRef.current);
+      const duration = dragging.origEnd - dragging.origStart;
+      if (dragging.type === "move") {
+        const snapped = snapToGrid(rawMin - duration / 2, granularity);
+        const newStart = Math.max(timeStart * 60, snapped);
+        const newRowId = getRowFromY(e.clientY, gridRef.current) ?? dragging.curRowId;
+        setDragging((d) => d ? { ...d, curStart: newStart, curEnd: newStart + duration, curRowId: newRowId } : null);
+      } else if (dragging.type === "resize-left") {
+        const snapped = snapToGrid(rawMin, granularity);
+        setDragging((d) => d ? { ...d, curStart: Math.min(snapped, dragging.curEnd - granularity) } : null);
+      } else {
+        const snapped = snapToGrid(rawMin, granularity);
+        setDragging((d) => d ? { ...d, curEnd: Math.max(snapped, dragging.curStart + granularity) } : null);
+      }
+    } else if (timeUnit === "day" && dragging.type === "move") {
+      const newDate = getDateFromX(e.clientX, gridRef.current) ?? dragging.curDate;
+      const newRowId = getRowFromY(e.clientY, gridRef.current) ?? dragging.curRowId;
+      setDragging((d) => d ? { ...d, curDate: newDate, curRowId: newRowId } : null);
+    }
+  }, [creating, dragging, getTimeFromX, getDateFromX, getRowFromY, granularity, timeStart, timeUnit]);
+  const onMouseUp = useCallback(() => {
+    if (creating) {
+      if (timeUnit === "hour") {
+        const dur = creating.endMin - creating.startMin;
+        if (dur >= granularity) {
+          onItemCreate?.({
+            rowId: creating.rowId,
+            date: creating.date,
+            startTime: toTime(creating.startMin),
+            endTime: toTime(creating.endMin)
+          });
+        }
+      } else {
+        const endDate = creating.endDate ?? creating.date;
+        const [startDate, finalEnd] = creating.date <= endDate ? [creating.date, endDate] : [endDate, creating.date];
+        onItemCreate?.({
+          rowId: creating.rowId,
+          date: startDate,
+          endDate: finalEnd !== startDate ? finalEnd : void 0,
+          startTime: "09:00",
+          endTime: "18:00"
+        });
+      }
+      setCreating(null);
+      return;
+    }
+    if (!dragging) return;
+    const { item, type, curStart, curEnd, curRowId, curDate } = dragging;
+    if (type === "move") {
+      let newEndDate;
+      if (item.endDate) {
+        const span = daysBetween(item.date, item.endDate);
+        newEndDate = addDaysToIso(curDate, span);
+      }
+      onItemMove?.({
+        item,
+        newRowId: curRowId,
+        newDate: curDate,
+        newEndDate,
+        newStartTime: toTime(curStart),
+        newEndTime: toTime(curEnd)
+      });
+    } else {
+      onItemResize?.({ item, newStartTime: toTime(curStart), newEndTime: toTime(curEnd) });
+    }
+    setDragging(null);
+  }, [creating, dragging, granularity, onItemCreate, onItemMove, onItemResize, timeUnit]);
+  const navDelta = timeUnit === "day" ? scale === "month" ? 30 : scale === "week" ? 7 : 1 : 1;
+  const navigate = (delta) => {
+    if (!onDateChange) return;
+    onDateChange(addDays2(date, delta * navDelta));
+  };
+  const titleLabel = useMemo(() => {
+    if (timeUnit === "day" && dayColumns.length > 1) {
+      const first = dayColumns[0].toLocaleDateString(locale, { month: "short", day: "numeric" });
+      const last = dayColumns[dayColumns.length - 1].toLocaleDateString(locale, { month: "short", day: "numeric", year: "numeric" });
+      return `${first} \u2013 ${last}`;
+    }
+    return date.toLocaleDateString(locale, { weekday: "long", year: "numeric", month: "short", day: "numeric" });
+  }, [timeUnit, dayColumns, date, locale]);
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      className: `gantt-root ${isRtl ? "gantt-rtl" : "gantt-ltr"}`,
+      "data-scheduler-mode": schedulerMode,
+      style: { ...cssVars, direction: isRtl ? "rtl" : "ltr" },
+      onMouseMove: dragging || creating ? onMouseMove : void 0,
+      onMouseUp: dragging || creating ? onMouseUp : void 0,
+      onMouseLeave: dragging || creating ? onMouseUp : void 0,
+      children: [
+        /* @__PURE__ */ jsxs("div", { className: "gantt-toolbar", children: [
+          /* @__PURE__ */ jsxs("div", { style: { display: "flex", gap: 6 }, children: [
+            /* @__PURE__ */ jsx("button", { className: "gantt-btn", onClick: () => navigate(-1), children: t.previous }),
+            /* @__PURE__ */ jsx("button", { className: "gantt-btn", onClick: () => onDateChange?.(/* @__PURE__ */ new Date()), children: t.today }),
+            /* @__PURE__ */ jsx("button", { className: "gantt-btn", onClick: () => navigate(1), children: t.next })
+          ] }),
+          /* @__PURE__ */ jsx("strong", { className: "gantt-title", children: titleLabel }),
+          /* @__PURE__ */ jsx("div", { style: { display: "flex", gap: 4 }, children: /* @__PURE__ */ jsx("span", { className: "gantt-badge", children: timeUnit === "hour" ? "\u23F1 Hour" : scale === "month" ? "\u{1F4C5} Month" : scale === "week" ? "\u{1F4C5} Week" : "\u{1F4C5} Day" }) })
+        ] }),
+        /* @__PURE__ */ jsxs("div", { className: "gantt-scroll-wrap", ref: gridRef, children: [
+          timeUnit === "hour" && /* @__PURE__ */ jsxs(Fragment, { children: [
+            /* @__PURE__ */ jsxs("div", { className: "gantt-header", children: [
+              /* @__PURE__ */ jsx("div", { className: "gantt-label-col gantt-header-label" }),
+              /* @__PURE__ */ jsx("div", { className: "gantt-time-header", children: hourCols.map((slot) => /* @__PURE__ */ jsx("div", { className: "gantt-time-cell", children: slot }, slot)) })
+            ] }),
+            rows.map((row) => {
+              const baseItems = itemsByRowHour.get(row.id) ?? [];
+              const dragItem = dragging?.item;
+              const isDragTargetRow = dragging?.type === "move" && dragging.curRowId === row.id && dragItem?.rowId !== row.id;
+              const isDragSourceRow = dragging?.type === "move" && dragItem?.rowId === row.id && dragging.curRowId !== row.id;
+              const visibleItems = isDragSourceRow ? baseItems.filter((i) => i.id !== dragItem.id) : baseItems;
+              const ghostItems = isDragTargetRow && dragItem ? [{ ...dragItem, rowId: row.id, startTime: toTime(dragging.curStart), endTime: toTime(dragging.curEnd) }] : [];
+              const allVisible = [...visibleItems, ...ghostItems];
+              const laned = assignLanes(allVisible);
+              const maxLanes = Math.max(1, laned.length > 0 ? Math.max(...laned.map((l) => l.totalLanes)) : 1);
+              const rowH = Math.max(ROW_MIN_H, maxLanes * (LANE_H + LANE_GAP) + LANE_GAP * 2);
+              return /* @__PURE__ */ jsxs("div", { className: "gantt-row", style: { minHeight: rowH }, children: [
+                /* @__PURE__ */ jsxs("div", { className: "gantt-label-col", children: [
+                  /* @__PURE__ */ jsx("div", { className: "gantt-row-label-text", children: row.label }),
+                  row.subLabel && /* @__PURE__ */ jsx("div", { className: "gantt-row-sublabel", children: row.subLabel })
+                ] }),
+                /* @__PURE__ */ jsxs(
+                  "div",
+                  {
+                    className: "gantt-row-content",
+                    style: { "--gantt-cols": hourCols.length, cursor: onItemCreate ? "cell" : "default" },
+                    onMouseDown: (ev) => {
+                      if (ev.button !== 0 || !onItemCreate || !gridRef.current) return;
+                      if (ev.target.closest(".gantt-item")) return;
+                      ev.preventDefault();
+                      const rawMin = getTimeFromX(ev.clientX, gridRef.current);
+                      const snapped = snapToGrid(rawMin, granularity);
+                      setCreating({ rowId: row.id, date: isoStr(date), startMin: snapped, endMin: snapped });
+                    },
+                    children: [
+                      hourCols.map((_, i) => /* @__PURE__ */ jsx(
+                        "div",
+                        {
+                          className: "gantt-grid-line",
+                          style: isRtl ? { right: `${i / hourCols.length * 100}%` } : { left: `${i / hourCols.length * 100}%` }
+                        },
+                        i
+                      )),
+                      creating?.rowId === row.id && /* @__PURE__ */ jsx(
+                        "div",
+                        {
+                          className: "gantt-selection-ghost",
+                          style: {
+                            ...isRtl ? { right: `${Math.max(0, (creating.startMin - timeStart * 60) / totalMins * 100)}%` } : { left: `${Math.max(0, (creating.startMin - timeStart * 60) / totalMins * 100)}%` },
+                            width: `${Math.max(0.5, (creating.endMin - creating.startMin) / totalMins * 100)}%`,
+                            top: LANE_GAP,
+                            height: LANE_H
+                          },
+                          children: /* @__PURE__ */ jsx("div", { className: "gantt-item-inner", children: /* @__PURE__ */ jsxs("div", { className: "gantt-item-title", children: [
+                            toTime(creating.startMin),
+                            " \u2013 ",
+                            toTime(creating.endMin)
+                          ] }) })
+                        }
+                      ),
+                      laned.map((item) => {
+                        const isOrigDrg = dragging?.item.id === item.id && dragging.curRowId === row.id;
+                        const isGhost = ghostItems.some((g) => g.id === item.id);
+                        const s = isOrigDrg || isGhost ? dragging.curStart : toMin(item.startTime);
+                        const e = isOrigDrg || isGhost ? dragging.curEnd : toMin(item.endTime);
+                        const leftPct = (s - timeStart * 60) / totalMins * 100;
+                        const widthPct = (e - s) / totalMins * 100;
+                        const topPx = LANE_GAP + item.lane * (LANE_H + LANE_GAP);
+                        const cls = `gantt-item gantt-item-${item.status} ${isOrigDrg || isGhost ? "gantt-item-dragging" : ""}`;
+                        return /* @__PURE__ */ jsxs(
+                          "div",
+                          {
+                            className: cls,
+                            style: {
+                              ...isRtl ? { right: `${Math.max(0, leftPct)}%` } : { left: `${Math.max(0, leftPct)}%` },
+                              width: `${Math.max(0.5, widthPct)}%`,
+                              top: topPx,
+                              height: LANE_H,
+                              cursor: isGhost ? "grabbing" : "grab"
+                            },
+                            onClick: (ev) => {
+                              ev.stopPropagation();
+                              if (!dragging) onItemClick?.(item.id);
+                            },
+                            onKeyDown: (ev) => {
+                              if (ev.key !== "Enter" && ev.key !== " ") return;
+                              ev.preventDefault();
+                              ev.stopPropagation();
+                              if (!dragging) onItemClick?.(item.id);
+                            },
+                            role: "button",
+                            tabIndex: 0,
+                            onMouseDown: (ev) => {
+                              if (ev.button !== 0 || isGhost) return;
+                              ev.preventDefault();
+                              setDragging({ type: "move", item, origStart: toMin(item.startTime), origEnd: toMin(item.endTime), curStart: toMin(item.startTime), curEnd: toMin(item.endTime), curRowId: row.id, curDate: item.date });
+                            },
+                            children: [
+                              /* @__PURE__ */ jsx("div", { className: "gantt-handle gantt-handle-left", onMouseDown: (ev) => {
+                                if (isGhost) return;
+                                ev.preventDefault();
+                                ev.stopPropagation();
+                                setDragging({ type: isRtl ? "resize-right" : "resize-left", item, origStart: toMin(item.startTime), origEnd: toMin(item.endTime), curStart: toMin(item.startTime), curEnd: toMin(item.endTime), curRowId: row.id, curDate: item.date });
+                              } }),
+                              /* @__PURE__ */ jsxs("div", { className: "gantt-item-inner", children: [
+                                /* @__PURE__ */ jsx("div", { className: "gantt-item-title", children: item.title }),
+                                item.subTitle && /* @__PURE__ */ jsx("div", { className: "gantt-item-sub", children: item.subTitle })
+                              ] }),
+                              /* @__PURE__ */ jsx("div", { className: "gantt-handle gantt-handle-right", onMouseDown: (ev) => {
+                                if (isGhost) return;
+                                ev.preventDefault();
+                                ev.stopPropagation();
+                                setDragging({ type: isRtl ? "resize-left" : "resize-right", item, origStart: toMin(item.startTime), origEnd: toMin(item.endTime), curStart: toMin(item.startTime), curEnd: toMin(item.endTime), curRowId: row.id, curDate: item.date });
+                              } })
+                            ]
+                          },
+                          `${item.id}-${row.id}`
+                        );
+                      })
+                    ]
+                  }
+                )
+              ] }, row.id);
+            })
+          ] }),
+          timeUnit === "day" && /* @__PURE__ */ jsxs(Fragment, { children: [
+            /* @__PURE__ */ jsxs("div", { className: "gantt-header", children: [
+              /* @__PURE__ */ jsx("div", { className: "gantt-label-col gantt-header-label" }),
+              /* @__PURE__ */ jsx("div", { className: "gantt-time-header", children: dayColumns.map((d) => {
+                const ds = isoStr(d);
+                const isToday = ds === todayStr;
+                const label = scale === "month" ? d.toLocaleDateString(locale, { day: "numeric" }) : d.toLocaleDateString(locale, { weekday: "short", month: "short", day: "numeric" });
+                return /* @__PURE__ */ jsx("div", { className: `gantt-time-cell ${isToday ? "gantt-today-col" : ""}`, children: label }, ds);
+              }) })
+            ] }),
+            rows.map((row) => {
+              const rowItems = dayColStrs.flatMap(
+                (ds) => assignLanesSequential(itemsByRowDate.get(`${row.id}__${ds}`) ?? [])
+              );
+              const maxPerCol = Math.max(1, ...dayColStrs.map(
+                (ds) => (itemsByRowDate.get(`${row.id}__${ds}`) ?? []).length
+              ));
+              const rowH = Math.max(ROW_MIN_H, maxPerCol * (LANE_H + LANE_GAP) + LANE_GAP * 2);
+              const creatingThisRow = creating?.rowId === row.id && creating.endDate !== void 0;
+              let ghostColStart = -1, ghostColEnd = -1;
+              if (creatingThisRow && creating) {
+                const a = dayColStrs.indexOf(creating.date);
+                const b = dayColStrs.indexOf(creating.endDate);
+                const ai = a < 0 ? 0 : a;
+                const bi = b < 0 ? 0 : b;
+                ghostColStart = Math.min(ai, bi);
+                ghostColEnd = Math.max(ai, bi);
+              }
+              return /* @__PURE__ */ jsxs("div", { className: "gantt-row", style: { minHeight: rowH }, children: [
+                /* @__PURE__ */ jsxs("div", { className: "gantt-label-col", children: [
+                  /* @__PURE__ */ jsx("div", { className: "gantt-row-label-text", children: row.label }),
+                  row.subLabel && /* @__PURE__ */ jsx("div", { className: "gantt-row-sublabel", children: row.subLabel })
+                ] }),
+                /* @__PURE__ */ jsxs("div", { className: "gantt-row-day-content", style: { position: "relative" }, children: [
+                  dayColumns.map((d) => {
+                    const ds = isoStr(d);
+                    const isToday = ds === todayStr;
+                    const isDragTarget = dragging?.type === "move" && dragging.curRowId === row.id && dragging.curDate === ds && (dragging.curDate !== dragging.item.date || dragging.curRowId !== dragging.item.rowId);
+                    return /* @__PURE__ */ jsx(
+                      "div",
+                      {
+                        className: `gantt-day-cell ${isToday ? "gantt-today-col" : ""} ${isDragTarget ? "gantt-day-cell-target" : ""}`,
+                        style: { minHeight: rowH, cursor: onItemCreate ? "cell" : "default" },
+                        onMouseDown: (ev) => {
+                          if (ev.button !== 0 || !onItemCreate || !gridRef.current) return;
+                          if (ev.target.closest(".gantt-item")) return;
+                          ev.preventDefault();
+                          setCreating({ rowId: row.id, date: ds, startMin: 0, endMin: 0, endDate: ds });
+                        }
+                      },
+                      ds
+                    );
+                  }),
+                  creatingThisRow && ghostColStart >= 0 && /* @__PURE__ */ jsx(
+                    "div",
+                    {
+                      className: "gantt-selection-ghost",
+                      style: {
+                        position: "absolute",
+                        top: LANE_GAP,
+                        height: LANE_H,
+                        ...isRtl ? { right: `${ghostColStart / dayColumns.length * 100}%` } : { left: `${ghostColStart / dayColumns.length * 100}%` },
+                        width: `${(ghostColEnd - ghostColStart + 1) / dayColumns.length * 100}%`
+                      },
+                      children: /* @__PURE__ */ jsx("div", { className: "gantt-item-inner", children: /* @__PURE__ */ jsxs("div", { className: "gantt-item-title", children: [
+                        dayColumns[ghostColStart]?.toLocaleDateString(locale, { month: "short", day: "numeric" }),
+                        ghostColEnd !== ghostColStart && ` \u2013 ${dayColumns[ghostColEnd]?.toLocaleDateString(locale, { month: "short", day: "numeric" })}`
+                      ] }) })
+                    }
+                  ),
+                  rowItems.map((item) => {
+                    const colStart = dayColStrs.indexOf(item.date);
+                    if (colStart < 0) return null;
+                    const rawColEnd = item.endDate ? dayColStrs.indexOf(item.endDate) : colStart;
+                    const colEnd = rawColEnd < 0 ? dayColStrs.length - 1 : Math.max(colStart, rawColEnd);
+                    const spanCols = colEnd - colStart + 1;
+                    const isDraggingThis = dragging?.item.id === item.id && dragging.type === "move";
+                    const rawEffectiveColStart = isDraggingThis ? dayColStrs.indexOf(dragging.curDate) : colStart;
+                    if (rawEffectiveColStart < 0) return null;
+                    const effectiveColStart = rawEffectiveColStart;
+                    const effectiveSpan = spanCols;
+                    const leftPct = effectiveColStart / dayColumns.length * 100;
+                    const widthPct = effectiveSpan / dayColumns.length * 100;
+                    const topPx = LANE_GAP + item.lane * (LANE_H + LANE_GAP);
+                    const cls = `gantt-item gantt-item-${item.status} gantt-day-item-overlay${isDraggingThis ? " gantt-item-dragging" : ""}`;
+                    return /* @__PURE__ */ jsx(
+                      "div",
+                      {
+                        className: cls,
+                        style: {
+                          position: "absolute",
+                          top: topPx,
+                          height: LANE_H,
+                          ...isRtl ? { right: `${Math.max(0, leftPct)}%` } : { left: `${Math.max(0, leftPct)}%` },
+                          width: `${Math.max(0.5, widthPct)}%`,
+                          cursor: isDraggingThis ? "grabbing" : "grab",
+                          boxSizing: "border-box",
+                          paddingLeft: 4,
+                          paddingRight: 4
+                        },
+                        onClick: (ev) => {
+                          ev.stopPropagation();
+                          if (!dragging) onItemClick?.(item.id);
+                        },
+                        onKeyDown: (ev) => {
+                          if (ev.key !== "Enter" && ev.key !== " ") return;
+                          ev.preventDefault();
+                          ev.stopPropagation();
+                          if (!dragging) onItemClick?.(item.id);
+                        },
+                        role: "button",
+                        tabIndex: 0,
+                        onMouseDown: (ev) => {
+                          if (ev.button !== 0) return;
+                          ev.preventDefault();
+                          ev.stopPropagation();
+                          setDragging({
+                            type: "move",
+                            item,
+                            origStart: toMin(item.startTime),
+                            origEnd: toMin(item.endTime),
+                            curStart: toMin(item.startTime),
+                            curEnd: toMin(item.endTime),
+                            curRowId: row.id,
+                            curDate: item.date
+                          });
+                        },
+                        children: /* @__PURE__ */ jsxs("div", { className: "gantt-item-inner", children: [
+                          /* @__PURE__ */ jsx("div", { className: "gantt-item-title", children: item.title }),
+                          /* @__PURE__ */ jsxs("div", { className: "gantt-item-sub", children: [
+                            item.endDate ? `${item.date} \u2013 ${item.endDate}` : `${item.startTime}\u2013${item.endTime}`,
+                            item.subTitle ? ` \xB7 ${item.subTitle}` : ""
+                          ] })
+                        ] })
+                      },
+                      `${item.id}-${row.id}`
+                    );
+                  })
+                ] })
+              ] }, row.id);
+            })
+          ] })
+        ] })
+      ]
+    }
+  );
+}
+
+// src/components/BookingCalendar.tsx
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+function toMinutes(t) {
+  const [h, m] = t.split(":").map(Number);
+  return h * 60 + m;
+}
+function slotClass(status) {
+  return `rbc-slot ${status}`;
+}
+function minutesToTime(total) {
+  const h = Math.floor(total / 60);
+  const m = total % 60;
+  return `${h.toString().padStart(2, "0")}:${m.toString().padStart(2, "0")}`;
+}
+function compressSelectionKeys(keys, slotGranularity) {
+  const byDate = /* @__PURE__ */ new Map();
+  for (const k of keys) {
+    const [date, startTime] = k.split("__");
+    const minute = toMinutes(startTime);
+    const arr = byDate.get(date) ?? [];
+    arr.push(minute);
+    byDate.set(date, arr);
+  }
+  const merged = [];
+  for (const [date, mins] of byDate.entries()) {
+    mins.sort((a, b) => a - b);
+    let rangeStart = mins[0];
+    let prev = mins[0];
+    for (let i = 1; i < mins.length; i += 1) {
+      const current = mins[i];
+      if (current === prev + slotGranularity) {
+        prev = current;
+        continue;
+      }
+      merged.push({ date, startTime: minutesToTime(rangeStart), endTime: minutesToTime(prev + slotGranularity) });
+      rangeStart = current;
+      prev = current;
+    }
+    merged.push({ date, startTime: minutesToTime(rangeStart), endTime: minutesToTime(prev + slotGranularity) });
+  }
+  return merged.sort((a, b) => a.date === b.date ? toMinutes(a.startTime) - toMinutes(b.startTime) : a.date.localeCompare(b.date));
+}
+function BookingCalendar({
+  value,
+  onChange,
+  schedules,
+  mode: schedulerMode = "time-grid",
+  dataAdapter,
+  dataSource,
+  ganttTimeUnit,
+  ganttScale,
+  viewMode,
+  onViewModeChange,
+  onSlotClick,
+  onItemClick,
+  onBookingClick,
+  onSlotMove,
+  onGanttItemMove,
+  onGanttItemResize,
+  onGanttItemCreate,
+  onBeforeSlotMove,
+  onSlotConflict,
+  draggableSlots = false,
+  selectionMode = false,
+  selectedSlots,
+  onSelectionChange,
+  onSlotDragSelectStart,
+  onSlotDragSelectMove,
+  onSlotDragSelectEnd,
+  isSlotSelected,
+  slotGranularity = 30,
+  locale = "fa-IR",
+  weekStartsOn = 6,
+  direction = "auto",
+  translations,
+  theme,
+  hideTimeColumn = false,
+  className
+}) {
+  const [internalMode, setInternalMode] = useState2("week");
+  const [dragOverKey, setDragOverKey] = useState2(null);
+  const [internalSelectedKeys, setInternalSelectedKeys] = useState2(/* @__PURE__ */ new Set());
+  const liveSelectionRef = React2.useRef(/* @__PURE__ */ new Set());
+  const isSelectingRef = React2.useRef(false);
+  const [isSelecting, setIsSelecting] = useState2(false);
+  useEffect(() => {
+    if (typeof window === "undefined") return;
+    setInternalMode(window.innerWidth < 768 ? "day" : "week");
+  }, []);
+  useEffect(() => {
+    if (typeof window === "undefined") return;
+    const onUp = () => {
+      isSelectingRef.current = false;
+      setIsSelecting(false);
+    };
+    window.addEventListener("mouseup", onUp);
+    return () => window.removeEventListener("mouseup", onUp);
+  }, []);
+  const calendarMode = viewMode ?? internalMode;
+  const setCalendarMode = (m) => {
+    setInternalMode(m);
+    onViewModeChange?.(m);
+  };
+  const isRtlLocale = /^fa|^ar|^he/.test(locale.toLowerCase());
+  const resolvedDirection = direction === "auto" ? isRtlLocale ? "rtl" : "ltr" : direction;
+  const t = {
+    previous: isRtlLocale ? "\u0642\u0628\u0644\u06CC" : "Previous",
+    today: isRtlLocale ? "\u0627\u0645\u0631\u0648\u0632" : "Today",
+    next: isRtlLocale ? "\u0628\u0639\u062F\u06CC" : "Next",
+    day: isRtlLocale ? "\u0631\u0648\u0632" : "Day",
+    week: isRtlLocale ? "\u0647\u0641\u062A\u0647" : "Week",
+    ...translations
+  };
+  const ganttTranslations = useMemo2(() => {
+    const map = {};
+    if (t.previous) map.previous = t.previous;
+    if (t.today) map.today = t.today;
+    if (t.next) map.next = t.next;
+    return map;
+  }, [t.previous, t.today, t.next]);
+  const mergedTheme = { ...defaultTheme, ...theme };
+  const cssVars = {
+    ["--rbc-primary"]: mergedTheme.primary,
+    ["--rbc-bg"]: mergedTheme.bg,
+    ["--rbc-panel"]: mergedTheme.panel,
+    ["--rbc-border"]: mergedTheme.border,
+    ["--rbc-text"]: mergedTheme.text,
+    ["--rbc-muted"]: mergedTheme.mutedText,
+    ["--rbc-available"]: mergedTheme.availableBg,
+    ["--rbc-booked"]: mergedTheme.bookedBg,
+    ["--rbc-blocked"]: mergedTheme.blockedBg,
+    ["--rbc-custom"]: mergedTheme.customBg
+  };
+  const isGanttMode = schedulerMode === "task-timeline" || schedulerMode === "resource-planner";
+  const ganttData = useMemo2(() => {
+    if (!isGanttMode || !dataAdapter || dataSource === void 0) return null;
+    const adapter = dataAdapter;
+    if (typeof adapter.toGantt !== "function") return null;
+    return adapter.toGantt(dataSource, { date: value, locale });
+  }, [isGanttMode, dataAdapter, dataSource, value, locale]);
+  if (isGanttMode && ganttData) {
+    return /* @__PURE__ */ jsx2(
+      GanttScheduler,
+      {
+        schedulerMode,
+        rows: ganttData.rows,
+        items: ganttData.items,
+        date: value,
+        timeStart: ganttData.timeStart,
+        timeEnd: ganttData.timeEnd,
+        granularity: ganttData.granularity,
+        timeUnit: ganttTimeUnit ?? ganttData.timeUnit,
+        scale: ganttScale ?? ganttData.scale ?? (ganttData.timeUnit === "day" ? "week" : void 0),
+        weekStartsOn,
+        locale,
+        direction: direction === "auto" ? /^fa|^ar|^he/.test(locale.toLowerCase()) ? "rtl" : "ltr" : direction,
+        theme,
+        onItemClick,
+        onItemMove: onGanttItemMove,
+        onItemResize: onGanttItemResize,
+        onItemCreate: onGanttItemCreate,
+        translations: ganttTranslations,
+        onDateChange: onChange
+      }
+    );
+  }
+  const normalizedSchedules = useMemo2(() => {
+    if (dataAdapter && dataSource !== void 0 && !isGanttMode) {
+      const adapter = dataAdapter;
+      if (typeof adapter.toSchedules === "function") return adapter.toSchedules(dataSource);
+    }
+    return schedules;
+  }, [dataAdapter, dataSource, schedules, isGanttMode]);
+  const days = useMemo2(() => calendarMode === "week" ? getWeekDays(value, weekStartsOn) : [value], [calendarMode, value, weekStartsOn]);
+  const byDate = useMemo2(() => new Map(normalizedSchedules.map((d) => [d.date, d])), [normalizedSchedules]);
+  const bounds = useMemo2(() => getHourBounds(normalizedSchedules), [normalizedSchedules]);
+  const times = useMemo2(() => generateTimeSlots(bounds.start, bounds.end, slotGranularity), [bounds, slotGranularity]);
+  const title = calendarMode === "week" ? `${days[0].toLocaleDateString(locale)} - ${days[days.length - 1].toLocaleDateString(locale)}` : value.toLocaleDateString(locale, { weekday: "long", year: "numeric", month: "long", day: "numeric" });
+  const rowsHeight = 30;
+  const totalMinutes = (bounds.end - bounds.start) * 60;
+  const currentSelectionKeys = useMemo2(() => {
+    if (selectedSlots) {
+      const keys = /* @__PURE__ */ new Set();
+      for (const s of selectedSlots) {
+        const start = toMinutes(s.startTime);
+        const end = toMinutes(s.endTime);
+        for (let m = start; m < end; m += slotGranularity) {
+          keys.add(`${s.date}__${minutesToTime(m)}`);
+        }
+      }
+      return keys;
+    }
+    return internalSelectedKeys;
+  }, [selectedSlots, internalSelectedKeys, slotGranularity]);
+  const emitSelection = (keys) => {
+    const values = compressSelectionKeys(keys, slotGranularity);
+    onSelectionChange?.(values);
+    return values;
+  };
+  const addSelection = (date, startTime) => {
+    const key = `${date}__${startTime}`;
+    if (liveSelectionRef.current.has(key)) return;
+    liveSelectionRef.current = new Set(liveSelectionRef.current);
+    liveSelectionRef.current.add(key);
+    const endTime = minutesToTime(toMinutes(startTime) + slotGranularity);
+    onSlotDragSelectMove?.({ date, startTime, endTime });
+    if (selectedSlots) {
+      emitSelection(liveSelectionRef.current);
+      return;
+    }
+    const nextKeys = new Set(liveSelectionRef.current);
+    setInternalSelectedKeys(nextKeys);
+    setTimeout(() => emitSelection(nextKeys), 0);
+  };
+  const findConflict = (payload) => {
+    const targetStart = toMinutes(payload.to.startTime);
+    const targetEnd = toMinutes(payload.to.endTime);
+    const sameSlotMove = payload.from.date === payload.to.date && payload.from.startTime === payload.to.startTime && payload.from.endTime === payload.to.endTime;
+    if (sameSlotMove) return void 0;
+    const targetDay = byDate.get(payload.to.date);
+    if (!targetDay) return void 0;
+    return targetDay.slots.find((s) => {
+      if (payload.from.date === payload.to.date && s.startTime === payload.from.startTime && s.endTime === payload.from.endTime && (s.itemId ?? s.bookingId) === (payload.slot.itemId ?? payload.slot.bookingId)) {
+        return false;
+      }
+      const sStart = toMinutes(s.startTime);
+      const sEnd = toMinutes(s.endTime);
+      return rangesOverlap(targetStart, targetEnd, sStart, sEnd);
+    });
+  };
+  return /* @__PURE__ */ jsxs2(
+    "div",
+    {
+      className: `rbc-root rbc-model-${schedulerMode} ${className ?? ""} ${resolvedDirection === "rtl" ? "rbc-rtl" : "rbc-ltr"}`,
+      style: cssVars,
+      dir: resolvedDirection,
+      "data-scheduler-mode": schedulerMode,
+      children: [
+        /* @__PURE__ */ jsxs2("div", { className: "rbc-toolbar", children: [
+          /* @__PURE__ */ jsxs2("div", { style: { display: "flex", gap: 8 }, children: [
+            /* @__PURE__ */ jsx2("button", { className: "rbc-btn", onClick: () => onChange(addDays(value, calendarMode === "week" ? -7 : -1)), children: t.previous }),
+            /* @__PURE__ */ jsx2("button", { className: "rbc-btn", onClick: () => onChange(/* @__PURE__ */ new Date()), children: t.today }),
+            /* @__PURE__ */ jsx2("button", { className: "rbc-btn", onClick: () => onChange(addDays(value, calendarMode === "week" ? 7 : 1)), children: t.next })
+          ] }),
+          /* @__PURE__ */ jsx2("strong", { children: title }),
+          /* @__PURE__ */ jsxs2("div", { style: { display: "flex", gap: 6 }, children: [
+            /* @__PURE__ */ jsx2("button", { className: `rbc-btn ${calendarMode === "day" ? "active" : ""}`, onClick: () => setCalendarMode("day"), children: t.day }),
+            /* @__PURE__ */ jsx2("button", { className: `rbc-btn ${calendarMode === "week" ? "active" : ""}`, onClick: () => setCalendarMode("week"), children: t.week })
+          ] })
+        ] }),
+        /* @__PURE__ */ jsxs2("div", { className: "rbc-grid", style: {
+          ["--rbc-days"]: String(days.length),
+          ["--rbc-rows"]: String(times.length),
+          gridTemplateRows: `auto repeat(${times.length}, ${rowsHeight}px)`
+        }, children: [
+          !hideTimeColumn && /* @__PURE__ */ jsx2("div", { className: "rbc-day-head" }),
+          days.map((d) => {
+            const isToday = toIsoDate(d) === toIsoDate(/* @__PURE__ */ new Date());
+            return /* @__PURE__ */ jsx2("div", { className: `rbc-day-head ${isToday ? "today" : ""}`, children: d.toLocaleDateString(locale, { weekday: "short", month: "short", day: "numeric" }) }, d.toISOString());
+          }),
+          times.map((t2, rowIdx) => /* @__PURE__ */ jsxs2(React2.Fragment, { children: [
+            !hideTimeColumn && /* @__PURE__ */ jsx2(
+              "div",
+              {
+                className: "rbc-time",
+                style: { gridRow: rowIdx + 2, gridColumn: 1 },
+                children: t2
+              }
+            ),
+            days.map((d, colIdx) => {
+              const dayIso = toIsoDate(d);
+              const cellKey = `${dayIso}-${t2}`;
+              const tMin = toMinutes(t2);
+              const cellHasSlot = byDate.get(dayIso)?.slots.some(
+                (s) => toMinutes(s.startTime) <= tMin && tMin < toMinutes(s.endTime)
+              ) ?? false;
+              return /* @__PURE__ */ jsx2(
+                "div",
+                {
+                  "data-slot-cell": "true",
+                  "data-date": dayIso,
+                  "data-start-time": t2,
+                  className: `rbc-cell ${dragOverKey === cellKey ? "rbc-drop-target" : ""} ${selectionMode && !cellHasSlot && (isSlotSelected?.({ date: dayIso, startTime: t2, endTime: minutesToTime(tMin + slotGranularity) }) || currentSelectionKeys.has(`${dayIso}__${t2}`)) ? "rbc-cell-selected" : ""}`,
+                  style: { height: rowsHeight, gridRow: rowIdx + 2, gridColumn: (hideTimeColumn ? 1 : 2) + colIdx },
+                  onMouseDown: (e) => {
+                    if (!selectionMode || e.button !== 0 || cellHasSlot) return;
+                    liveSelectionRef.current = /* @__PURE__ */ new Set();
+                    setInternalSelectedKeys(/* @__PURE__ */ new Set());
+                    isSelectingRef.current = true;
+                    setIsSelecting(true);
+                    const endTime = minutesToTime(tMin + slotGranularity);
+                    onSlotDragSelectStart?.({ date: dayIso, startTime: t2, endTime });
+                    addSelection(dayIso, t2);
+                  },
+                  onMouseEnter: () => {
+                    if (!selectionMode || !isSelectingRef.current || cellHasSlot) return;
+                    addSelection(dayIso, t2);
+                  },
+                  onMouseUp: () => {
+                    if (!selectionMode || !isSelectingRef.current) return;
+                    isSelectingRef.current = false;
+                    setIsSelecting(false);
+                    const keys = liveSelectionRef.current;
+                    const final = compressSelectionKeys(keys, slotGranularity);
+                    liveSelectionRef.current = /* @__PURE__ */ new Set();
+                    onSlotDragSelectEnd?.(final);
+                  }
+                },
+                `${t2}-${d.toISOString()}`
+              );
+            })
+          ] }, t2)),
+          !hideTimeColumn && /* @__PURE__ */ jsx2(
+            "div",
+            {
+              className: "rbc-empty-col",
+              style: { gridRow: `2 / span ${times.length}`, gridColumn: 1 }
+            }
+          ),
+          days.map((d, i) => {
+            const dayIso = toIsoDate(d);
+            const day = byDate.get(dayIso);
+            const calcTimeFromY = (e) => {
+              const rect = e.currentTarget.getBoundingClientRect();
+              const fraction = Math.max(0, Math.min(1, (e.clientY - rect.top) / rect.height));
+              const mins = Math.floor(fraction * totalMinutes / slotGranularity) * slotGranularity;
+              return minutesToTime(bounds.start * 60 + mins);
+            };
+            return /* @__PURE__ */ jsx2(
+              "div",
+              {
+                className: "rbc-empty-col",
+                style: {
+                  gridRow: `2 / span ${times.length}`,
+                  gridColumn: (hideTimeColumn ? 1 : 2) + i,
+                  pointerEvents: draggableSlots ? "auto" : "none"
+                },
+                onDragOver: (e) => {
+                  if (!draggableSlots) return;
+                  e.preventDefault();
+                  const t2 = calcTimeFromY(e);
+                  setDragOverKey(`${dayIso}-${t2}`);
+                },
+                onDragLeave: () => setDragOverKey(null),
+                onDrop: (e) => {
+                  if (!draggableSlots || !onSlotMove) return;
+                  e.preventDefault();
+                  setDragOverKey(null);
+                  const raw = e.dataTransfer.getData("application/x-rbc-slot");
+                  if (!raw) return;
+                  const payload = JSON.parse(raw);
+                  const targetStart = calcTimeFromY(e);
+                  const duration = toMinutes(payload.slot.endTime) - toMinutes(payload.slot.startTime);
+                  if (duration <= 0) return;
+                  const movePayload = {
+                    slot: payload.slot,
+                    from: { date: payload.date, startTime: payload.slot.startTime, endTime: payload.slot.endTime },
+                    to: { date: dayIso, startTime: targetStart, endTime: minutesToTime(toMinutes(targetStart) + duration) }
+                  };
+                  const conflict = findConflict(movePayload);
+                  if (conflict) {
+                    onSlotConflict?.({ ...movePayload, reason: "overlap", conflictingSlot: conflict });
+                    return;
+                  }
+                  Promise.resolve(onBeforeSlotMove?.(movePayload) ?? true).then((allowed) => {
+                    if (!allowed) {
+                      onSlotConflict?.({ ...movePayload, reason: "blocked-by-policy" });
+                      return;
+                    }
+                    onSlotMove(movePayload);
+                  });
+                },
+                children: (day?.slots ?? []).map((slot, i2) => {
+                  const start = toMinutes(slot.startTime);
+                  const end = toMinutes(slot.endTime);
+                  const top = (start - bounds.start * 60) / totalMinutes * 100;
+                  const height = (end - start) / totalMinutes * 100;
+                  return /* @__PURE__ */ jsxs2(
+                    "div",
+                    {
+                      "data-slot-item": "true",
+                      "data-date": dayIso,
+                      "data-start-time": slot.startTime,
+                      "data-end-time": slot.endTime,
+                      className: slotClass(slot.status),
+                      style: { top: `${top}%`, height: `${height}%` },
+                      draggable: draggableSlots,
+                      onDragStart: (e) => {
+                        if (!draggableSlots) return;
+                        e.stopPropagation();
+                        e.dataTransfer.effectAllowed = "move";
+                        e.dataTransfer.setData("application/x-rbc-slot", JSON.stringify({ slot, date: dayIso }));
+                      },
+                      onClick: () => {
+                        const id = slot.itemId ?? slot.bookingId;
+                        if (id) {
+                          onItemClick?.(id);
+                          onBookingClick?.(id);
+                          return;
+                        }
+                        onSlotClick?.(dayIso, slot);
+                      },
+                      role: "button",
+                      tabIndex: 0,
+                      onKeyDown: (e) => {
+                        if (e.key !== "Enter" && e.key !== " ") return;
+                        e.preventDefault();
+                        const id = slot.itemId ?? slot.bookingId;
+                        if (id) {
+                          onItemClick?.(id);
+                          onBookingClick?.(id);
+                          return;
+                        }
+                        onSlotClick?.(dayIso, slot);
+                      },
+                      children: [
+                        /* @__PURE__ */ jsx2("div", { className: "rbc-label", children: slot.title ?? `${slot.startTime} - ${slot.endTime}` }),
+                        /* @__PURE__ */ jsx2("div", { className: "rbc-sub", children: slot.description ?? slot.status })
+                      ]
+                    },
+                    `${slot.startTime}-${slot.endTime}-${i2}`
+                  );
+                })
+              },
+              `slots-${dayIso}`
+            );
+          })
+        ] })
+      ]
+    }
+  );
+}
+var BookingCalendar_default = BookingCalendar;
+
+// src/adapters.ts
+function defStatus(s) {
+  return s ?? "custom";
+}
+function createTaskTimelineAdapter() {
+  return {
+    toGantt(items, { date }) {
+      const assigneeOrder = [];
+      const seen = /* @__PURE__ */ new Set();
+      for (const item of items) {
+        const key = item.assignee ?? item.title;
+        if (!seen.has(key)) {
+          seen.add(key);
+          assigneeOrder.push(key);
+        }
+      }
+      const rows = assigneeOrder.map((a) => ({ id: a, label: a }));
+      const ganttItems = items.map((item) => ({
+        id: item.id,
+        rowId: item.assignee ?? item.title,
+        date: item.date,
+        endDate: item.endDate,
+        startTime: item.startTime,
+        endTime: item.endTime,
+        title: item.title,
+        subTitle: item.progress != null ? `${item.progress}%` : item.assignee,
+        status: defStatus(item.status)
+      }));
+      const todayStr = date.toISOString().slice(0, 10);
+      const todayItems = ganttItems.filter((i) => i.date === todayStr);
+      const allItems = ganttItems;
+      const starts = allItems.map((i) => toMin2(i.startTime));
+      const ends = allItems.map((i) => toMin2(i.endTime));
+      const timeStart = starts.length ? Math.max(0, Math.floor(Math.min(...starts) / 60) - 1) : 8;
+      const timeEnd = ends.length ? Math.min(24, Math.ceil(Math.max(...ends) / 60) + 1) : 20;
+      return { rows, items: ganttItems, timeStart, timeEnd, granularity: 30, timeUnit: "hour" };
+    }
+  };
+}
+function createResourcePlannerAdapter(resources) {
+  return {
+    toGantt(items) {
+      const rows = resources.map((r) => ({
+        id: r.id,
+        label: r.title,
+        subLabel: r.meta?.type
+      }));
+      const ganttItems = items.map((item) => ({
+        id: item.id,
+        rowId: item.resourceId,
+        date: item.date,
+        startTime: item.startTime,
+        endTime: item.endTime,
+        title: item.title,
+        subTitle: item.description,
+        status: defStatus(item.status)
+      }));
+      const starts = ganttItems.map((i) => toMin2(i.startTime));
+      const ends = ganttItems.map((i) => toMin2(i.endTime));
+      const timeStart = starts.length ? Math.max(0, Math.floor(Math.min(...starts) / 60) - 1) : 8;
+      const timeEnd = ends.length ? Math.min(24, Math.ceil(Math.max(...ends) / 60) + 1) : 20;
+      return { rows, items: ganttItems, timeStart, timeEnd, granularity: 30, timeUnit: "day" };
+    }
+  };
+}
+function toMin2(t) {
+  const [h, m] = t.split(":").map(Number);
+  return h * 60 + m;
+}
+export {
+  BookingCalendar,
+  BookingCalendar_default as BookingCalendarDefault,
+  BookingCalendar as SlotCalendar,
+  BookingCalendar as SlotScheduler,
+  createResourcePlannerAdapter,
+  createTaskTimelineAdapter,
+  defaultTheme
+};
+//# sourceMappingURL=index.js.map