@object-ui/plugin-kanban 0.3.1 → 0.5.0

package/dist/KanbanEnhanced-BqDEu7Z6.js

@@ -0,0 +1,894 @@
+import { j as h } from "./index-CrR06na7.js";
+import * as C from "react";
+import { forwardRef as K, createElement as R } from "react";
+import { flushSync as J } from "react-dom";
+import { u as Q, a as X, P as ee, D as te, c as se, b as ne, d as ie, e as Z, S as re, v as oe, C as le } from "./sortable.esm-ZHwgFQIO.js";
+import { Button as ae, Badge as F, Card as ce, CardHeader as he, CardTitle as de, CardDescription as ue, CardContent as fe } from "@object-ui/components";
+function N(n, l, e) {
+  let s = e.initialDeps ?? [], t, i = !0;
+  function o() {
+    var r, a, c;
+    let d;
+    e.key && ((r = e.debug) != null && r.call(e)) && (d = Date.now());
+    const v = n();
+    if (!(v.length !== s.length || v.some((w, p) => s[p] !== w)))
+      return t;
+    s = v;
+    let b;
+    if (e.key && ((a = e.debug) != null && a.call(e)) && (b = Date.now()), t = l(...v), e.key && ((c = e.debug) != null && c.call(e))) {
+      const w = Math.round((Date.now() - d) * 100) / 100, p = Math.round((Date.now() - b) * 100) / 100, y = p / 16, E = (f, g) => {
+        for (f = String(f); f.length < g; )
+          f = " " + f;
+        return f;
+      };
+      console.info(
+        `%c⏱ ${E(p, 5)} /${E(w, 5)} ms`,
+        `
+            font-size: .6rem;
+            font-weight: bold;
+            color: hsl(${Math.max(
+          0,
+          Math.min(120 - 120 * y, 120)
+        )}deg 100% 31%);`,
+        e?.key
+      );
+    }
+    return e?.onChange && !(i && e.skipInitialOnChange) && e.onChange(t), i = !1, t;
+  }
+  return o.updateDeps = (r) => {
+    s = r;
+  }, o;
+}
+function B(n, l) {
+  if (n === void 0)
+    throw new Error("Unexpected undefined");
+  return n;
+}
+const me = (n, l) => Math.abs(n - l) < 1.01, ge = (n, l, e) => {
+  let s;
+  return function(...t) {
+    n.clearTimeout(s), s = n.setTimeout(() => l.apply(this, t), e);
+  };
+}, $ = (n) => {
+  const { offsetWidth: l, offsetHeight: e } = n;
+  return { width: l, height: e };
+}, pe = (n) => n, ve = (n) => {
+  const l = Math.max(n.startIndex - n.overscan, 0), e = Math.min(n.endIndex + n.overscan, n.count - 1), s = [];
+  for (let t = l; t <= e; t++)
+    s.push(t);
+  return s;
+}, xe = (n, l) => {
+  const e = n.scrollElement;
+  if (!e)
+    return;
+  const s = n.targetWindow;
+  if (!s)
+    return;
+  const t = (o) => {
+    const { width: r, height: a } = o;
+    l({ width: Math.round(r), height: Math.round(a) });
+  };
+  if (t($(e)), !s.ResizeObserver)
+    return () => {
+    };
+  const i = new s.ResizeObserver((o) => {
+    const r = () => {
+      const a = o[0];
+      if (a?.borderBoxSize) {
+        const c = a.borderBoxSize[0];
+        if (c) {
+          t({ width: c.inlineSize, height: c.blockSize });
+          return;
+        }
+      }
+      t($(e));
+    };
+    n.options.useAnimationFrameWithResizeObserver ? requestAnimationFrame(r) : r();
+  });
+  return i.observe(e, { box: "border-box" }), () => {
+    i.unobserve(e);
+  };
+}, P = {
+  passive: !0
+}, H = typeof window > "u" ? !0 : "onscrollend" in window, be = (n, l) => {
+  const e = n.scrollElement;
+  if (!e)
+    return;
+  const s = n.targetWindow;
+  if (!s)
+    return;
+  let t = 0;
+  const i = n.options.useScrollendEvent && H ? () => {
+  } : ge(
+    s,
+    () => {
+      l(t, !1);
+    },
+    n.options.isScrollingResetDelay
+  ), o = (d) => () => {
+    const { horizontal: v, isRtl: u } = n.options;
+    t = v ? e.scrollLeft * (u && -1 || 1) : e.scrollTop, i(), l(t, d);
+  }, r = o(!0), a = o(!1);
+  e.addEventListener("scroll", r, P);
+  const c = n.options.useScrollendEvent && H;
+  return c && e.addEventListener("scrollend", a, P), () => {
+    e.removeEventListener("scroll", r), c && e.removeEventListener("scrollend", a);
+  };
+}, Ce = (n, l, e) => {
+  if (l?.borderBoxSize) {
+    const s = l.borderBoxSize[0];
+    if (s)
+      return Math.round(
+        s[e.options.horizontal ? "inlineSize" : "blockSize"]
+      );
+  }
+  return n[e.options.horizontal ? "offsetWidth" : "offsetHeight"];
+}, we = (n, {
+  adjustments: l = 0,
+  behavior: e
+}, s) => {
+  var t, i;
+  const o = n + l;
+  (i = (t = s.scrollElement) == null ? void 0 : t.scrollTo) == null || i.call(t, {
+    [s.options.horizontal ? "left" : "top"]: o,
+    behavior: e
+  });
+};
+class ye {
+  constructor(l) {
+    this.unsubs = [], this.scrollElement = null, this.targetWindow = null, this.isScrolling = !1, this.currentScrollToIndex = null, this.measurementsCache = [], this.itemSizeCache = /* @__PURE__ */ new Map(), this.laneAssignments = /* @__PURE__ */ new Map(), this.pendingMeasuredCacheIndexes = [], this.prevLanes = void 0, this.lanesChangedFlag = !1, this.lanesSettling = !1, this.scrollRect = null, this.scrollOffset = null, this.scrollDirection = null, this.scrollAdjustments = 0, this.elementsCache = /* @__PURE__ */ new Map(), this.observer = /* @__PURE__ */ (() => {
+      let e = null;
+      const s = () => e || (!this.targetWindow || !this.targetWindow.ResizeObserver ? null : e = new this.targetWindow.ResizeObserver((t) => {
+        t.forEach((i) => {
+          const o = () => {
+            this._measureElement(i.target, i);
+          };
+          this.options.useAnimationFrameWithResizeObserver ? requestAnimationFrame(o) : o();
+        });
+      }));
+      return {
+        disconnect: () => {
+          var t;
+          (t = s()) == null || t.disconnect(), e = null;
+        },
+        observe: (t) => {
+          var i;
+          return (i = s()) == null ? void 0 : i.observe(t, { box: "border-box" });
+        },
+        unobserve: (t) => {
+          var i;
+          return (i = s()) == null ? void 0 : i.unobserve(t);
+        }
+      };
+    })(), this.range = null, this.setOptions = (e) => {
+      Object.entries(e).forEach(([s, t]) => {
+        typeof t > "u" && delete e[s];
+      }), this.options = {
+        debug: !1,
+        initialOffset: 0,
+        overscan: 1,
+        paddingStart: 0,
+        paddingEnd: 0,
+        scrollPaddingStart: 0,
+        scrollPaddingEnd: 0,
+        horizontal: !1,
+        getItemKey: pe,
+        rangeExtractor: ve,
+        onChange: () => {
+        },
+        measureElement: Ce,
+        initialRect: { width: 0, height: 0 },
+        scrollMargin: 0,
+        gap: 0,
+        indexAttribute: "data-index",
+        initialMeasurementsCache: [],
+        lanes: 1,
+        isScrollingResetDelay: 150,
+        enabled: !0,
+        isRtl: !1,
+        useScrollendEvent: !1,
+        useAnimationFrameWithResizeObserver: !1,
+        ...e
+      };
+    }, this.notify = (e) => {
+      var s, t;
+      (t = (s = this.options).onChange) == null || t.call(s, this, e);
+    }, this.maybeNotify = N(
+      () => (this.calculateRange(), [
+        this.isScrolling,
+        this.range ? this.range.startIndex : null,
+        this.range ? this.range.endIndex : null
+      ]),
+      (e) => {
+        this.notify(e);
+      },
+      {
+        key: process.env.NODE_ENV !== "production" && "maybeNotify",
+        debug: () => this.options.debug,
+        initialDeps: [
+          this.isScrolling,
+          this.range ? this.range.startIndex : null,
+          this.range ? this.range.endIndex : null
+        ]
+      }
+    ), this.cleanup = () => {
+      this.unsubs.filter(Boolean).forEach((e) => e()), this.unsubs = [], this.observer.disconnect(), this.scrollElement = null, this.targetWindow = null;
+    }, this._didMount = () => () => {
+      this.cleanup();
+    }, this._willUpdate = () => {
+      var e;
+      const s = this.options.enabled ? this.options.getScrollElement() : null;
+      if (this.scrollElement !== s) {
+        if (this.cleanup(), !s) {
+          this.maybeNotify();
+          return;
+        }
+        this.scrollElement = s, this.scrollElement && "ownerDocument" in this.scrollElement ? this.targetWindow = this.scrollElement.ownerDocument.defaultView : this.targetWindow = ((e = this.scrollElement) == null ? void 0 : e.window) ?? null, this.elementsCache.forEach((t) => {
+          this.observer.observe(t);
+        }), this.unsubs.push(
+          this.options.observeElementRect(this, (t) => {
+            this.scrollRect = t, this.maybeNotify();
+          })
+        ), this.unsubs.push(
+          this.options.observeElementOffset(this, (t, i) => {
+            this.scrollAdjustments = 0, this.scrollDirection = i ? this.getScrollOffset() < t ? "forward" : "backward" : null, this.scrollOffset = t, this.isScrolling = i, this.maybeNotify();
+          })
+        ), this._scrollToOffset(this.getScrollOffset(), {
+          adjustments: void 0,
+          behavior: void 0
+        });
+      }
+    }, this.getSize = () => this.options.enabled ? (this.scrollRect = this.scrollRect ?? this.options.initialRect, this.scrollRect[this.options.horizontal ? "width" : "height"]) : (this.scrollRect = null, 0), this.getScrollOffset = () => this.options.enabled ? (this.scrollOffset = this.scrollOffset ?? (typeof this.options.initialOffset == "function" ? this.options.initialOffset() : this.options.initialOffset), this.scrollOffset) : (this.scrollOffset = null, 0), this.getFurthestMeasurement = (e, s) => {
+      const t = /* @__PURE__ */ new Map(), i = /* @__PURE__ */ new Map();
+      for (let o = s - 1; o >= 0; o--) {
+        const r = e[o];
+        if (t.has(r.lane))
+          continue;
+        const a = i.get(
+          r.lane
+        );
+        if (a == null || r.end > a.end ? i.set(r.lane, r) : r.end < a.end && t.set(r.lane, !0), t.size === this.options.lanes)
+          break;
+      }
+      return i.size === this.options.lanes ? Array.from(i.values()).sort((o, r) => o.end === r.end ? o.index - r.index : o.end - r.end)[0] : void 0;
+    }, this.getMeasurementOptions = N(
+      () => [
+        this.options.count,
+        this.options.paddingStart,
+        this.options.scrollMargin,
+        this.options.getItemKey,
+        this.options.enabled,
+        this.options.lanes
+      ],
+      (e, s, t, i, o, r) => (this.prevLanes !== void 0 && this.prevLanes !== r && (this.lanesChangedFlag = !0), this.prevLanes = r, this.pendingMeasuredCacheIndexes = [], {
+        count: e,
+        paddingStart: s,
+        scrollMargin: t,
+        getItemKey: i,
+        enabled: o,
+        lanes: r
+      }),
+      {
+        key: !1
+      }
+    ), this.getMeasurements = N(
+      () => [this.getMeasurementOptions(), this.itemSizeCache],
+      ({ count: e, paddingStart: s, scrollMargin: t, getItemKey: i, enabled: o, lanes: r }, a) => {
+        if (!o)
+          return this.measurementsCache = [], this.itemSizeCache.clear(), this.laneAssignments.clear(), [];
+        if (this.laneAssignments.size > e)
+          for (const u of this.laneAssignments.keys())
+            u >= e && this.laneAssignments.delete(u);
+        this.lanesChangedFlag && (this.lanesChangedFlag = !1, this.lanesSettling = !0, this.measurementsCache = [], this.itemSizeCache.clear(), this.laneAssignments.clear(), this.pendingMeasuredCacheIndexes = []), this.measurementsCache.length === 0 && !this.lanesSettling && (this.measurementsCache = this.options.initialMeasurementsCache, this.measurementsCache.forEach((u) => {
+          this.itemSizeCache.set(u.key, u.size);
+        }));
+        const c = this.lanesSettling ? 0 : this.pendingMeasuredCacheIndexes.length > 0 ? Math.min(...this.pendingMeasuredCacheIndexes) : 0;
+        this.pendingMeasuredCacheIndexes = [], this.lanesSettling && this.measurementsCache.length === e && (this.lanesSettling = !1);
+        const d = this.measurementsCache.slice(0, c), v = new Array(r).fill(
+          void 0
+        );
+        for (let u = 0; u < c; u++) {
+          const b = d[u];
+          b && (v[b.lane] = u);
+        }
+        for (let u = c; u < e; u++) {
+          const b = i(u), w = this.laneAssignments.get(u);
+          let p, y;
+          if (w !== void 0 && this.options.lanes > 1) {
+            p = w;
+            const m = v[p], x = m !== void 0 ? d[m] : void 0;
+            y = x ? x.end + this.options.gap : s + t;
+          } else {
+            const m = this.options.lanes === 1 ? d[u - 1] : this.getFurthestMeasurement(d, u);
+            y = m ? m.end + this.options.gap : s + t, p = m ? m.lane : u % this.options.lanes, this.options.lanes > 1 && this.laneAssignments.set(u, p);
+          }
+          const E = a.get(b), f = typeof E == "number" ? E : this.options.estimateSize(u), g = y + f;
+          d[u] = {
+            index: u,
+            start: y,
+            size: f,
+            end: g,
+            key: b,
+            lane: p
+          }, v[p] = u;
+        }
+        return this.measurementsCache = d, d;
+      },
+      {
+        key: process.env.NODE_ENV !== "production" && "getMeasurements",
+        debug: () => this.options.debug
+      }
+    ), this.calculateRange = N(
+      () => [
+        this.getMeasurements(),
+        this.getSize(),
+        this.getScrollOffset(),
+        this.options.lanes
+      ],
+      (e, s, t, i) => this.range = e.length > 0 && s > 0 ? Se({
+        measurements: e,
+        outerSize: s,
+        scrollOffset: t,
+        lanes: i
+      }) : null,
+      {
+        key: process.env.NODE_ENV !== "production" && "calculateRange",
+        debug: () => this.options.debug
+      }
+    ), this.getVirtualIndexes = N(
+      () => {
+        let e = null, s = null;
+        const t = this.calculateRange();
+        return t && (e = t.startIndex, s = t.endIndex), this.maybeNotify.updateDeps([this.isScrolling, e, s]), [
+          this.options.rangeExtractor,
+          this.options.overscan,
+          this.options.count,
+          e,
+          s
+        ];
+      },
+      (e, s, t, i, o) => i === null || o === null ? [] : e({
+        startIndex: i,
+        endIndex: o,
+        overscan: s,
+        count: t
+      }),
+      {
+        key: process.env.NODE_ENV !== "production" && "getVirtualIndexes",
+        debug: () => this.options.debug
+      }
+    ), this.indexFromElement = (e) => {
+      const s = this.options.indexAttribute, t = e.getAttribute(s);
+      return t ? parseInt(t, 10) : (console.warn(
+        `Missing attribute name '${s}={index}' on measured element.`
+      ), -1);
+    }, this._measureElement = (e, s) => {
+      const t = this.indexFromElement(e), i = this.measurementsCache[t];
+      if (!i)
+        return;
+      const o = i.key, r = this.elementsCache.get(o);
+      r !== e && (r && this.observer.unobserve(r), this.observer.observe(e), this.elementsCache.set(o, e)), e.isConnected && this.resizeItem(t, this.options.measureElement(e, s, this));
+    }, this.resizeItem = (e, s) => {
+      const t = this.measurementsCache[e];
+      if (!t)
+        return;
+      const i = this.itemSizeCache.get(t.key) ?? t.size, o = s - i;
+      o !== 0 && ((this.shouldAdjustScrollPositionOnItemSizeChange !== void 0 ? this.shouldAdjustScrollPositionOnItemSizeChange(t, o, this) : t.start < this.getScrollOffset() + this.scrollAdjustments) && (process.env.NODE_ENV !== "production" && this.options.debug && console.info("correction", o), this._scrollToOffset(this.getScrollOffset(), {
+        adjustments: this.scrollAdjustments += o,
+        behavior: void 0
+      })), this.pendingMeasuredCacheIndexes.push(t.index), this.itemSizeCache = new Map(this.itemSizeCache.set(t.key, s)), this.notify(!1));
+    }, this.measureElement = (e) => {
+      if (!e) {
+        this.elementsCache.forEach((s, t) => {
+          s.isConnected || (this.observer.unobserve(s), this.elementsCache.delete(t));
+        });
+        return;
+      }
+      this._measureElement(e, void 0);
+    }, this.getVirtualItems = N(
+      () => [this.getVirtualIndexes(), this.getMeasurements()],
+      (e, s) => {
+        const t = [];
+        for (let i = 0, o = e.length; i < o; i++) {
+          const r = e[i], a = s[r];
+          t.push(a);
+        }
+        return t;
+      },
+      {
+        key: process.env.NODE_ENV !== "production" && "getVirtualItems",
+        debug: () => this.options.debug
+      }
+    ), this.getVirtualItemForOffset = (e) => {
+      const s = this.getMeasurements();
+      if (s.length !== 0)
+        return B(
+          s[Y(
+            0,
+            s.length - 1,
+            (t) => B(s[t]).start,
+            e
+          )]
+        );
+    }, this.getMaxScrollOffset = () => {
+      if (!this.scrollElement) return 0;
+      if ("scrollHeight" in this.scrollElement)
+        return this.options.horizontal ? this.scrollElement.scrollWidth - this.scrollElement.clientWidth : this.scrollElement.scrollHeight - this.scrollElement.clientHeight;
+      {
+        const e = this.scrollElement.document.documentElement;
+        return this.options.horizontal ? e.scrollWidth - this.scrollElement.innerWidth : e.scrollHeight - this.scrollElement.innerHeight;
+      }
+    }, this.getOffsetForAlignment = (e, s, t = 0) => {
+      if (!this.scrollElement) return 0;
+      const i = this.getSize(), o = this.getScrollOffset();
+      s === "auto" && (s = e >= o + i ? "end" : "start"), s === "center" ? e += (t - i) / 2 : s === "end" && (e -= i);
+      const r = this.getMaxScrollOffset();
+      return Math.max(Math.min(r, e), 0);
+    }, this.getOffsetForIndex = (e, s = "auto") => {
+      e = Math.max(0, Math.min(e, this.options.count - 1));
+      const t = this.measurementsCache[e];
+      if (!t)
+        return;
+      const i = this.getSize(), o = this.getScrollOffset();
+      if (s === "auto")
+        if (t.end >= o + i - this.options.scrollPaddingEnd)
+          s = "end";
+        else if (t.start <= o + this.options.scrollPaddingStart)
+          s = "start";
+        else
+          return [o, s];
+      if (s === "end" && e === this.options.count - 1)
+        return [this.getMaxScrollOffset(), s];
+      const r = s === "end" ? t.end + this.options.scrollPaddingEnd : t.start - this.options.scrollPaddingStart;
+      return [
+        this.getOffsetForAlignment(r, s, t.size),
+        s
+      ];
+    }, this.isDynamicMode = () => this.elementsCache.size > 0, this.scrollToOffset = (e, { align: s = "start", behavior: t } = {}) => {
+      t === "smooth" && this.isDynamicMode() && console.warn(
+        "The `smooth` scroll behavior is not fully supported with dynamic size."
+      ), this._scrollToOffset(this.getOffsetForAlignment(e, s), {
+        adjustments: void 0,
+        behavior: t
+      });
+    }, this.scrollToIndex = (e, { align: s = "auto", behavior: t } = {}) => {
+      t === "smooth" && this.isDynamicMode() && console.warn(
+        "The `smooth` scroll behavior is not fully supported with dynamic size."
+      ), e = Math.max(0, Math.min(e, this.options.count - 1)), this.currentScrollToIndex = e;
+      let i = 0;
+      const o = 10, r = (c) => {
+        if (!this.targetWindow) return;
+        const d = this.getOffsetForIndex(e, c);
+        if (!d) {
+          console.warn("Failed to get offset for index:", e);
+          return;
+        }
+        const [v, u] = d;
+        this._scrollToOffset(v, { adjustments: void 0, behavior: t }), this.targetWindow.requestAnimationFrame(() => {
+          const b = () => {
+            if (this.currentScrollToIndex !== e) return;
+            const w = this.getScrollOffset(), p = this.getOffsetForIndex(e, u);
+            if (!p) {
+              console.warn("Failed to get offset for index:", e);
+              return;
+            }
+            me(p[0], w) || a(u);
+          };
+          this.isDynamicMode() ? this.targetWindow.requestAnimationFrame(b) : b();
+        });
+      }, a = (c) => {
+        this.targetWindow && this.currentScrollToIndex === e && (i++, i < o ? (process.env.NODE_ENV !== "production" && this.options.debug && console.info("Schedule retry", i, o), this.targetWindow.requestAnimationFrame(() => r(c))) : console.warn(
+          `Failed to scroll to index ${e} after ${o} attempts.`
+        ));
+      };
+      r(s);
+    }, this.scrollBy = (e, { behavior: s } = {}) => {
+      s === "smooth" && this.isDynamicMode() && console.warn(
+        "The `smooth` scroll behavior is not fully supported with dynamic size."
+      ), this._scrollToOffset(this.getScrollOffset() + e, {
+        adjustments: void 0,
+        behavior: s
+      });
+    }, this.getTotalSize = () => {
+      var e;
+      const s = this.getMeasurements();
+      let t;
+      if (s.length === 0)
+        t = this.options.paddingStart;
+      else if (this.options.lanes === 1)
+        t = ((e = s[s.length - 1]) == null ? void 0 : e.end) ?? 0;
+      else {
+        const i = Array(this.options.lanes).fill(null);
+        let o = s.length - 1;
+        for (; o >= 0 && i.some((r) => r === null); ) {
+          const r = s[o];
+          i[r.lane] === null && (i[r.lane] = r.end), o--;
+        }
+        t = Math.max(...i.filter((r) => r !== null));
+      }
+      return Math.max(
+        t - this.options.scrollMargin + this.options.paddingEnd,
+        0
+      );
+    }, this._scrollToOffset = (e, {
+      adjustments: s,
+      behavior: t
+    }) => {
+      this.options.scrollToFn(e, { behavior: t, adjustments: s }, this);
+    }, this.measure = () => {
+      this.itemSizeCache = /* @__PURE__ */ new Map(), this.laneAssignments = /* @__PURE__ */ new Map(), this.notify(!1);
+    }, this.setOptions(l);
+  }
+}
+const Y = (n, l, e, s) => {
+  for (; n <= l; ) {
+    const t = (n + l) / 2 | 0, i = e(t);
+    if (i < s)
+      n = t + 1;
+    else if (i > s)
+      l = t - 1;
+    else
+      return t;
+  }
+  return n > 0 ? n - 1 : 0;
+};
+function Se({
+  measurements: n,
+  outerSize: l,
+  scrollOffset: e,
+  lanes: s
+}) {
+  const t = n.length - 1, i = (a) => n[a].start;
+  if (n.length <= s)
+    return {
+      startIndex: 0,
+      endIndex: t
+    };
+  let o = Y(
+    0,
+    t,
+    i,
+    e
+  ), r = o;
+  if (s === 1)
+    for (; r < t && n[r].end < e + l; )
+      r++;
+  else if (s > 1) {
+    const a = Array(s).fill(0);
+    for (; r < t && a.some((d) => d < e + l); ) {
+      const d = n[r];
+      a[d.lane] = d.end, r++;
+    }
+    const c = Array(s).fill(e + l);
+    for (; o >= 0 && c.some((d) => d >= e); ) {
+      const d = n[o];
+      c[d.lane] = d.start, o--;
+    }
+    o = Math.max(0, o - o % s), r = Math.min(t, r + (s - 1 - r % s));
+  }
+  return { startIndex: o, endIndex: r };
+}
+const q = typeof document < "u" ? C.useLayoutEffect : C.useEffect;
+function Ee({
+  useFlushSync: n = !0,
+  ...l
+}) {
+  const e = C.useReducer(() => ({}), {})[1], s = {
+    ...l,
+    onChange: (i, o) => {
+      var r;
+      n && o ? J(e) : e(), (r = l.onChange) == null || r.call(l, i, o);
+    }
+  }, [t] = C.useState(
+    () => new ye(s)
+  );
+  return t.setOptions(s), q(() => t._didMount(), []), q(() => t._willUpdate()), t;
+}
+function Me(n) {
+  return Ee({
+    observeElementRect: xe,
+    observeElementOffset: be,
+    scrollToFn: we,
+    ...n
+  });
+}
+const G = (...n) => n.filter((l, e, s) => !!l && l.trim() !== "" && s.indexOf(l) === e).join(" ").trim();
+const Oe = (n) => n.replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase();
+const ze = (n) => n.replace(
+  /^([A-Z])|[\s-_]+(\w)/g,
+  (l, e, s) => s ? s.toUpperCase() : e.toLowerCase()
+);
+const U = (n) => {
+  const l = ze(n);
+  return l.charAt(0).toUpperCase() + l.slice(1);
+};
+var Ie = {
+  xmlns: "http://www.w3.org/2000/svg",
+  width: 24,
+  height: 24,
+  viewBox: "0 0 24 24",
+  fill: "none",
+  stroke: "currentColor",
+  strokeWidth: 2,
+  strokeLinecap: "round",
+  strokeLinejoin: "round"
+};
+const je = (n) => {
+  for (const l in n)
+    if (l.startsWith("aria-") || l === "role" || l === "title")
+      return !0;
+  return !1;
+};
+const Ne = K(
+  ({
+    color: n = "currentColor",
+    size: l = 24,
+    strokeWidth: e = 2,
+    absoluteStrokeWidth: s,
+    className: t = "",
+    children: i,
+    iconNode: o,
+    ...r
+  }, a) => R(
+    "svg",
+    {
+      ref: a,
+      ...Ie,
+      width: l,
+      height: l,
+      stroke: n,
+      strokeWidth: s ? Number(e) * 24 / Number(l) : e,
+      className: G("lucide", t),
+      ...!i && !je(r) && { "aria-hidden": "true" },
+      ...r
+    },
+    [
+      ...o.map(([c, d]) => R(c, d)),
+      ...Array.isArray(i) ? i : [i]
+    ]
+  )
+);
+const L = (n, l) => {
+  const e = K(
+    ({ className: s, ...t }, i) => R(Ne, {
+      ref: i,
+      iconNode: l,
+      className: G(
+        `lucide-${Oe(U(n))}`,
+        `lucide-${n}`,
+        s
+      ),
+      ...t
+    })
+  );
+  return e.displayName = U(n), e;
+};
+const Ae = [["path", { d: "m6 9 6 6 6-6", key: "qrunsl" }]], ke = L("chevron-down", Ae);
+const _e = [["path", { d: "m9 18 6-6-6-6", key: "mthhwq" }]], De = L("chevron-right", _e);
+const Re = [
+  [
+    "path",
+    {
+      d: "m21.73 18-8-14a2 2 0 0 0-3.48 0l-8 14A2 2 0 0 0 4 21h16a2 2 0 0 0 1.73-3",
+      key: "wmoenq"
+    }
+  ],
+  ["path", { d: "M12 9v4", key: "juzpu7" }],
+  ["path", { d: "M12 17h.01", key: "p32p05" }]
+], Fe = L("triangle-alert", Re), T = (...n) => n.filter(Boolean).join(" ");
+function W({ card: n }) {
+  const {
+    attributes: l,
+    listeners: e,
+    setNodeRef: s,
+    transform: t,
+    transition: i,
+    isDragging: o
+  } = Z({ id: n.id }), r = {
+    transform: le.Transform.toString(t),
+    transition: i,
+    opacity: o ? 0.5 : void 0
+  };
+  return /* @__PURE__ */ h.jsx("div", { ref: s, style: r, ...l, ...e, children: /* @__PURE__ */ h.jsxs(ce, { className: "mb-2 cursor-grab active:cursor-grabbing border-border bg-card/60 hover:border-primary/40 hover:shadow-lg hover:shadow-primary/10 transition-all duration-300 group", children: [
+    /* @__PURE__ */ h.jsxs(he, { className: "p-4", children: [
+      /* @__PURE__ */ h.jsx(de, { className: "text-sm font-medium font-mono tracking-tight text-foreground group-hover:text-primary transition-colors", children: n.title }),
+      n.description && /* @__PURE__ */ h.jsx(ue, { className: "text-xs text-muted-foreground font-mono", children: n.description })
+    ] }),
+    n.badges && n.badges.length > 0 && /* @__PURE__ */ h.jsx(fe, { className: "p-4 pt-0", children: /* @__PURE__ */ h.jsx("div", { className: "flex flex-wrap gap-1", children: n.badges.map((a, c) => /* @__PURE__ */ h.jsx(F, { variant: a.variant || "default", className: "text-xs", children: a.label }, c)) }) })
+  ] }) });
+}
+function Te({ cards: n, parentRef: l }) {
+  const e = Me({
+    count: n.length,
+    getScrollElement: () => l.current,
+    estimateSize: () => 120,
+    overscan: 5
+  });
+  return /* @__PURE__ */ h.jsx(
+    "div",
+    {
+      style: {
+        height: `${e.getTotalSize()}px`,
+        width: "100%",
+        position: "relative"
+      },
+      children: e.getVirtualItems().map((s) => {
+        const t = n[s.index];
+        return /* @__PURE__ */ h.jsx(
+          "div",
+          {
+            style: {
+              position: "absolute",
+              top: 0,
+              left: 0,
+              width: "100%",
+              transform: `translateY(${s.start}px)`
+            },
+            children: /* @__PURE__ */ h.jsx(W, { card: t })
+          },
+          t.id
+        );
+      })
+    }
+  );
+}
+function Le({
+  column: n,
+  cards: l,
+  onToggle: e,
+  enableVirtual: s
+}) {
+  const t = l || [], i = C.useRef(null), { setNodeRef: o } = Z({
+    id: n.id,
+    data: {
+      type: "column"
+    }
+  }), r = n.limit && t.length >= n.limit, a = n.limit && t.length >= n.limit * 0.8;
+  return /* @__PURE__ */ h.jsxs(
+    "div",
+    {
+      ref: o,
+      className: T(
+        "flex flex-col flex-shrink-0 rounded-lg border border-border bg-card/20 backdrop-blur-sm shadow-xl transition-all",
+        n.collapsed ? "w-16" : "w-80",
+        n.className
+      ),
+      children: [
+        /* @__PURE__ */ h.jsxs("div", { className: "p-4 border-b border-border/50 bg-muted/20 flex items-center justify-between", children: [
+          /* @__PURE__ */ h.jsxs("div", { className: "flex items-center gap-2 flex-1 min-w-0", children: [
+            /* @__PURE__ */ h.jsx(
+              ae,
+              {
+                variant: "ghost",
+                size: "sm",
+                className: "h-6 w-6 p-0",
+                onClick: () => e(!n.collapsed),
+                children: n.collapsed ? /* @__PURE__ */ h.jsx(De, { className: "h-4 w-4" }) : /* @__PURE__ */ h.jsx(ke, { className: "h-4 w-4" })
+              }
+            ),
+            !n.collapsed && /* @__PURE__ */ h.jsxs(h.Fragment, { children: [
+              /* @__PURE__ */ h.jsx("h3", { className: "font-mono text-sm font-semibold tracking-wider text-primary/90 uppercase truncate", children: n.title }),
+              /* @__PURE__ */ h.jsxs("div", { className: "flex items-center gap-2", children: [
+                /* @__PURE__ */ h.jsxs("span", { className: T(
+                  "font-mono text-xs",
+                  r ? "text-destructive" : a ? "text-yellow-500" : "text-muted-foreground"
+                ), children: [
+                  t.length,
+                  n.limit && ` / ${n.limit}`
+                ] }),
+                r && /* @__PURE__ */ h.jsx(F, { variant: "destructive", className: "text-xs", children: "Full" }),
+                a && !r && /* @__PURE__ */ h.jsx(Fe, { className: "h-3 w-3 text-yellow-500" })
+              ] })
+            ] })
+          ] }),
+          n.collapsed && /* @__PURE__ */ h.jsxs("div", { className: "flex flex-col items-center gap-1", children: [
+            /* @__PURE__ */ h.jsx("span", { className: "font-mono text-xs font-bold text-primary/90 [writing-mode:vertical-rl] rotate-180", children: n.title }),
+            /* @__PURE__ */ h.jsx(F, { variant: "secondary", className: "text-xs", children: t.length })
+          ] })
+        ] }),
+        !n.collapsed && /* @__PURE__ */ h.jsx("div", { ref: i, className: "flex-1 p-4 overflow-y-auto", style: { maxHeight: "600px" }, children: /* @__PURE__ */ h.jsx(
+          re,
+          {
+            items: t.map((c) => c.id),
+            strategy: oe,
+            children: s ? /* @__PURE__ */ h.jsx(Te, { cards: t, parentRef: i }) : /* @__PURE__ */ h.jsx("div", { className: "space-y-2", children: t.map((c) => /* @__PURE__ */ h.jsx(W, { card: c }, c.id)) })
+          }
+        ) })
+      ]
+    }
+  );
+}
+function He({
+  columns: n,
+  onCardMove: l,
+  onColumnToggle: e,
+  enableVirtualScrolling: s = !1,
+  virtualScrollThreshold: t = 50,
+  className: i
+}) {
+  const [o, r] = C.useState(null), a = C.useMemo(() => (n || []).map((f) => ({
+    ...f,
+    cards: f.cards || []
+  })), [n]), [c, d] = C.useState(a);
+  C.useEffect(() => {
+    d(a);
+  }, [a]);
+  const v = Q(
+    X(ee, {
+      activationConstraint: {
+        distance: 8
+      }
+    })
+  ), u = (f) => {
+    const { active: g } = f, m = w(g.id);
+    r(m);
+  }, b = (f) => {
+    const { active: g, over: m } = f;
+    if (r(null), !m) return;
+    const x = g.id, z = m.id;
+    if (x === z) return;
+    const M = p(x), I = p(z) || y(z);
+    if (!(!M || !I))
+      if (M.id === I.id) {
+        const O = [...M.cards], j = O.findIndex((S) => S.id === x), D = O.findIndex((S) => S.id === z), V = ie(O, j, D);
+        d(
+          (S) => S.map(
+            (A) => A.id === M.id ? { ...A, cards: V } : A
+          )
+        );
+      } else {
+        const O = [...M.cards], j = [...I.cards], D = O.findIndex((k) => k.id === x), S = z === I.id ? j.length : j.findIndex((k) => k.id === z), [A] = O.splice(D, 1);
+        j.splice(S, 0, A), d(
+          (k) => k.map((_) => _.id === M.id ? { ..._, cards: O } : _.id === I.id ? { ..._, cards: j } : _)
+        ), l && l(x, M.id, I.id, S);
+      }
+  }, w = C.useCallback(
+    (f) => {
+      for (const g of c) {
+        const m = g.cards.find((x) => x.id === f);
+        if (m) return m;
+      }
+      return null;
+    },
+    [c]
+  ), p = C.useCallback(
+    (f) => c.find((g) => g.cards.some((m) => m.id === f)) || null,
+    [c]
+  ), y = C.useCallback(
+    (f) => c.find((g) => g.id === f) || null,
+    [c]
+  ), E = C.useCallback((f, g) => {
+    d(
+      (m) => m.map((x) => x.id === f ? { ...x, collapsed: g } : x)
+    ), e?.(f, g);
+  }, [e]);
+  return /* @__PURE__ */ h.jsxs(
+    te,
+    {
+      sensors: v,
+      collisionDetection: se,
+      onDragStart: u,
+      onDragEnd: b,
+      children: [
+        /* @__PURE__ */ h.jsx("div", { className: T("flex gap-4 overflow-x-auto p-4", i), children: c.map((f) => {
+          const g = s && f.cards.length > t;
+          return /* @__PURE__ */ h.jsx(
+            Le,
+            {
+              column: f,
+              cards: f.cards,
+              onToggle: (m) => E(f.id, m),
+              enableVirtual: g
+            },
+            f.id
+          );
+        }) }),
+        /* @__PURE__ */ h.jsx(ne, { children: o ? /* @__PURE__ */ h.jsx(W, { card: o }) : null })
+      ]
+    }
+  );
+}
+export {
+  He as KanbanEnhanced,
+  He as default
+};