@ram_28/kf-ai-sdk 1.0.12 → 1.0.13

package/dist/kanban.mjs

@@ -1,44 +1,410 @@
-import { useState as G, useRef as k, useCallback as h, useEffect as rt, useMemo as ot, createContext as qt, useContext as Qt } from "react";
-import { useQueryClient as At, useQueries as Tt, keepPreviousData as kt, useQuery as Pt, useMutation as j } from "@tanstack/react-query";
-import { a as F } from "./client-CfvLiGfP.js";
-import { u as Et } from "./useFilter-CXFqEHyI.js";
-const ct = 50, dt = 5, ut = 5;
-function Ft({
-  onCardMove: i,
-  onError: c,
-  columns: d,
-  announceMove: a
+var $t = (a) => {
+  throw TypeError(a);
+};
+var St = (a, e, s) => e.has(a) || $t("Cannot " + s);
+var l = (a, e, s) => (St(a, e, "read from private field"), s ? s.call(a) : e.get(a)), R = (a, e, s) => e.has(a) ? $t("Cannot add the same private member more than once") : e instanceof WeakSet ? e.add(a) : e.set(a, s), v = (a, e, s, t) => (St(a, e, "write to private field"), t ? t.call(a, s) : e.set(a, s), s), F = (a, e, s) => (St(a, e, "access private method"), s);
+import * as B from "react";
+import { useState as yt, useRef as G, useCallback as _, useEffect as _t, useMemo as Ht, createContext as ge, useContext as fe } from "react";
+import { S as Vt, s as Gt, h as It, n as ct, r as pe, Q as Wt, a as kt, b as ye, c as me, e as be, d as Ce, f as De, g as Zt, i as Ut, j as jt, w as we, k as Oe, l as Se, m as _e, u as Qe } from "./useQuery-KpZFg80c.js";
+import { a as M } from "./client-CfvLiGfP.js";
+import { u as Ee } from "./useFilter-CXFqEHyI.js";
+function ve() {
+  return {
+    context: void 0,
+    data: void 0,
+    error: null,
+    failureCount: 0,
+    failureReason: null,
+    isPaused: !1,
+    status: "idle",
+    variables: void 0,
+    submittedAt: 0
+  };
+}
+var z, W, $, N, Y, mt, Qt, Yt, Ke = (Yt = class extends Vt {
+  constructor(e, s) {
+    super();
+    R(this, Y);
+    R(this, z);
+    R(this, W);
+    R(this, $);
+    R(this, N);
+    v(this, z, e), this.setOptions(s), this.bindMethods(), F(this, Y, mt).call(this);
+  }
+  bindMethods() {
+    this.mutate = this.mutate.bind(this), this.reset = this.reset.bind(this);
+  }
+  setOptions(e) {
+    var t;
+    const s = this.options;
+    this.options = l(this, z).defaultMutationOptions(e), Gt(this.options, s) || l(this, z).getMutationCache().notify({
+      type: "observerOptionsUpdated",
+      mutation: l(this, $),
+      observer: this
+    }), s != null && s.mutationKey && this.options.mutationKey && It(s.mutationKey) !== It(this.options.mutationKey) ? this.reset() : ((t = l(this, $)) == null ? void 0 : t.state.status) === "pending" && l(this, $).setOptions(this.options);
+  }
+  onUnsubscribe() {
+    var e;
+    this.hasListeners() || (e = l(this, $)) == null || e.removeObserver(this);
+  }
+  onMutationUpdate(e) {
+    F(this, Y, mt).call(this), F(this, Y, Qt).call(this, e);
+  }
+  getCurrentResult() {
+    return l(this, W);
+  }
+  reset() {
+    var e;
+    (e = l(this, $)) == null || e.removeObserver(this), v(this, $, void 0), F(this, Y, mt).call(this), F(this, Y, Qt).call(this);
+  }
+  mutate(e, s) {
+    var t;
+    return v(this, N, s), (t = l(this, $)) == null || t.removeObserver(this), v(this, $, l(this, z).getMutationCache().build(l(this, z), this.options)), l(this, $).addObserver(this), l(this, $).execute(e);
+  }
+}, z = new WeakMap(), W = new WeakMap(), $ = new WeakMap(), N = new WeakMap(), Y = new WeakSet(), mt = function() {
+  var s;
+  const e = ((s = l(this, $)) == null ? void 0 : s.state) ?? ve();
+  v(this, W, {
+    ...e,
+    isPending: e.status === "pending",
+    isSuccess: e.status === "success",
+    isError: e.status === "error",
+    isIdle: e.status === "idle",
+    mutate: this.mutate,
+    reset: this.reset
+  });
+}, Qt = function(e) {
+  ct.batch(() => {
+    var s, t, i, d, f, y, Q, E;
+    if (l(this, N) && this.hasListeners()) {
+      const C = l(this, W).variables, O = l(this, W).context, K = {
+        client: l(this, z),
+        meta: this.options.meta,
+        mutationKey: this.options.mutationKey
+      };
+      if ((e == null ? void 0 : e.type) === "success") {
+        try {
+          (t = (s = l(this, N)).onSuccess) == null || t.call(
+            s,
+            e.data,
+            C,
+            O,
+            K
+          );
+        } catch (q) {
+          Promise.reject(q);
+        }
+        try {
+          (d = (i = l(this, N)).onSettled) == null || d.call(
+            i,
+            e.data,
+            null,
+            C,
+            O,
+            K
+          );
+        } catch (q) {
+          Promise.reject(q);
+        }
+      } else if ((e == null ? void 0 : e.type) === "error") {
+        try {
+          (y = (f = l(this, N)).onError) == null || y.call(
+            f,
+            e.error,
+            C,
+            O,
+            K
+          );
+        } catch (q) {
+          Promise.reject(q);
+        }
+        try {
+          (E = (Q = l(this, N)).onSettled) == null || E.call(
+            Q,
+            void 0,
+            e.error,
+            C,
+            O,
+            K
+          );
+        } catch (q) {
+          Promise.reject(q);
+        }
+      }
+    }
+    this.listeners.forEach((C) => {
+      C(l(this, W));
+    });
+  });
+}, Yt);
+function Bt(a, e) {
+  const s = new Set(e);
+  return a.filter((t) => !s.has(t));
+}
+function qe(a, e, s) {
+  const t = a.slice(0);
+  return t[e] = s, t;
+}
+var tt, H, it, at, I, Z, lt, dt, ht, T, Et, vt, Kt, qt, Pt, Jt, Pe = (Jt = class extends Vt {
+  constructor(e, s, t) {
+    super();
+    R(this, T);
+    R(this, tt);
+    R(this, H);
+    R(this, it);
+    R(this, at);
+    R(this, I);
+    R(this, Z);
+    R(this, lt);
+    R(this, dt);
+    R(this, ht, []);
+    v(this, tt, e), v(this, at, t), v(this, it, []), v(this, I, []), v(this, H, []), this.setQueries(s);
+  }
+  onSubscribe() {
+    this.listeners.size === 1 && l(this, I).forEach((e) => {
+      e.subscribe((s) => {
+        F(this, T, qt).call(this, e, s);
+      });
+    });
+  }
+  onUnsubscribe() {
+    this.listeners.size || this.destroy();
+  }
+  destroy() {
+    this.listeners = /* @__PURE__ */ new Set(), l(this, I).forEach((e) => {
+      e.destroy();
+    });
+  }
+  setQueries(e, s) {
+    if (v(this, it, e), v(this, at, s), process.env.NODE_ENV !== "production") {
+      const t = e.map(
+        (i) => l(this, tt).defaultQueryOptions(i).queryHash
+      );
+      new Set(t).size !== t.length && console.warn(
+        "[QueriesObserver]: Duplicate Queries found. This might result in unexpected behavior."
+      );
+    }
+    ct.batch(() => {
+      const t = l(this, I), i = F(this, T, Kt).call(this, l(this, it));
+      i.forEach(
+        (O) => O.observer.setOptions(O.defaultedQueryOptions)
+      );
+      const d = i.map((O) => O.observer), f = d.map(
+        (O) => O.getCurrentResult()
+      ), y = t.length !== d.length, Q = d.some(
+        (O, K) => O !== t[K]
+      ), E = y || Q, C = E ? !0 : f.some((O, K) => {
+        const q = l(this, H)[K];
+        return !q || !Gt(O, q);
+      });
+      !E && !C || (E && (v(this, ht, i), v(this, I, d)), v(this, H, f), this.hasListeners() && (E && (Bt(t, d).forEach((O) => {
+        O.destroy();
+      }), Bt(d, t).forEach((O) => {
+        O.subscribe((K) => {
+          F(this, T, qt).call(this, O, K);
+        });
+      })), F(this, T, Pt).call(this)));
+    });
+  }
+  getCurrentResult() {
+    return l(this, H);
+  }
+  getQueries() {
+    return l(this, I).map((e) => e.getCurrentQuery());
+  }
+  getObservers() {
+    return l(this, I);
+  }
+  getOptimisticResult(e, s) {
+    const t = F(this, T, Kt).call(this, e), i = t.map(
+      (d) => d.observer.getOptimisticResult(d.defaultedQueryOptions)
+    );
+    return [
+      i,
+      (d) => F(this, T, vt).call(this, d ?? i, s),
+      () => F(this, T, Et).call(this, i, t)
+    ];
+  }
+}, tt = new WeakMap(), H = new WeakMap(), it = new WeakMap(), at = new WeakMap(), I = new WeakMap(), Z = new WeakMap(), lt = new WeakMap(), dt = new WeakMap(), ht = new WeakMap(), T = new WeakSet(), Et = function(e, s) {
+  return s.map((t, i) => {
+    const d = e[i];
+    return t.defaultedQueryOptions.notifyOnChangeProps ? d : t.observer.trackResult(d, (f) => {
+      s.forEach((y) => {
+        y.observer.trackProp(f);
+      });
+    });
+  });
+}, vt = function(e, s) {
+  return s ? ((!l(this, Z) || l(this, H) !== l(this, dt) || s !== l(this, lt)) && (v(this, lt, s), v(this, dt, l(this, H)), v(this, Z, pe(
+    l(this, Z),
+    s(e)
+  ))), l(this, Z)) : e;
+}, Kt = function(e) {
+  const s = /* @__PURE__ */ new Map();
+  l(this, I).forEach((i) => {
+    const d = i.options.queryHash;
+    if (!d) return;
+    const f = s.get(d);
+    f ? f.push(i) : s.set(d, [i]);
+  });
+  const t = [];
+  return e.forEach((i) => {
+    var Q;
+    const d = l(this, tt).defaultQueryOptions(i), y = ((Q = s.get(d.queryHash)) == null ? void 0 : Q.shift()) ?? new Wt(l(this, tt), d);
+    t.push({
+      defaultedQueryOptions: d,
+      observer: y
+    });
+  }), t;
+}, qt = function(e, s) {
+  const t = l(this, I).indexOf(e);
+  t !== -1 && (v(this, H, qe(l(this, H), t, s)), F(this, T, Pt).call(this));
+}, Pt = function() {
+  var e;
+  if (this.hasListeners()) {
+    const s = l(this, Z), t = F(this, T, Et).call(this, l(this, H), l(this, ht)), i = F(this, T, vt).call(this, t, (e = l(this, at)) == null ? void 0 : e.combine);
+    s !== i && ct.batch(() => {
+      this.listeners.forEach((d) => {
+        d(l(this, H));
+      });
+    });
+  }
+}, Jt);
+function ke({
+  queries: a,
+  ...e
+}, s) {
+  const t = kt(), i = ye(), d = me(), f = B.useMemo(
+    () => a.map((g) => {
+      const P = t.defaultQueryOptions(
+        g
+      );
+      return P._optimisticResults = i ? "isRestoring" : "optimistic", P;
+    }),
+    [a, t, i]
+  );
+  f.forEach((g) => {
+    be(g);
+    const P = t.getQueryCache().get(g.queryHash);
+    Ce(g, d, P);
+  }), De(d);
+  const [y] = B.useState(
+    () => new Pe(
+      t,
+      f,
+      e
+    )
+  ), [Q, E, C] = y.getOptimisticResult(
+    f,
+    e.combine
+  ), O = !i && e.subscribed !== !1;
+  B.useSyncExternalStore(
+    B.useCallback(
+      (g) => O ? y.subscribe(ct.batchCalls(g)) : Zt,
+      [y, O]
+    ),
+    () => y.getCurrentResult(),
+    () => y.getCurrentResult()
+  ), B.useEffect(() => {
+    y.setQueries(
+      f,
+      e
+    );
+  }, [f, e, y]);
+  const q = Q.some(
+    (g, P) => Ut(f[P], g)
+  ) ? Q.flatMap((g, P) => {
+    const k = f[P];
+    if (k) {
+      const X = new Wt(t, k);
+      if (Ut(k, g))
+        return jt(k, X, d);
+      we(g, i) && jt(k, X, d);
+    }
+    return [];
+  }) : [];
+  if (q.length > 0)
+    throw Promise.all(q);
+  const J = Q.find(
+    (g, P) => {
+      const k = f[P];
+      return k && Oe({
+        result: g,
+        errorResetBoundary: d,
+        throwOnError: k.throwOnError,
+        query: t.getQueryCache().get(k.queryHash),
+        suspense: k.suspense
+      });
+    }
+  );
+  if (J != null && J.error)
+    throw J.error;
+  return E(C());
+}
+function ut(a, e) {
+  const s = kt(), [t] = B.useState(
+    () => new Ke(
+      s,
+      a
+    )
+  );
+  B.useEffect(() => {
+    t.setOptions(a);
+  }, [t, a]);
+  const i = B.useSyncExternalStore(
+    B.useCallback(
+      (f) => t.subscribe(ct.batchCalls(f)),
+      [t]
+    ),
+    () => t.getCurrentResult(),
+    () => t.getCurrentResult()
+  ), d = B.useCallback(
+    (f, y) => {
+      t.mutate(f, y).catch(Zt);
+    },
+    [t]
+  );
+  if (i.error && Se(t.options.throwOnError, [i.error]))
+    throw i.error;
+  return { ...i, mutate: d, mutateAsync: i.mutate };
+}
+const Xt = 50, zt = 5, Nt = 5;
+function Ae({
+  onCardMove: a,
+  onError: e,
+  columns: s,
+  announceMove: t
 }) {
-  const [s, O] = G({
+  const [i, d] = yt({
     isDragging: !1,
     draggedCard: null,
     dragOverColumn: null,
     dragOverPosition: null,
     dragSourceColumn: null
-  }), q = k(null), _ = k(null), K = k(null), b = h(() => {
-    O({
+  }), f = G(null), y = G(null), Q = G(null), E = _(() => {
+    d({
       isDragging: !1,
       draggedCard: null,
       dragOverColumn: null,
       dragOverPosition: null,
       dragSourceColumn: null
-    }), _.current && (clearTimeout(_.current), _.current = null);
-  }, []), D = h((u) => d.find((o) => o._id === u) || null, [d]), Y = h((u) => {
-    for (const o of d) {
-      const g = o.cards.find((m) => m._id === u);
-      if (g)
-        return { card: g, column: o };
+    }), y.current && (clearTimeout(y.current), y.current = null);
+  }, []), C = _((h) => s.find((c) => c._id === h) || null, [s]), O = _((h) => {
+    for (const c of s) {
+      const m = c.cards.find((D) => D._id === h);
+      if (m)
+        return { card: m, column: c };
     }
     return null;
-  }, [d]), P = h((u, o) => {
-    var g, m;
+  }, [s]), K = _((h, c) => {
+    var m, D;
     try {
-      const l = u.target, y = D(o.columnId);
-      if (!y)
+      const p = h.target, b = C(c.columnId);
+      if (!b)
         throw new Error("Source column not found");
-      (g = u.dataTransfer) == null || g.setData("text/plain", o._id), (m = u.dataTransfer) == null || m.setData("application/json", JSON.stringify(o));
-      const S = l.cloneNode(!0);
-      S.style.cssText = `
+      (m = h.dataTransfer) == null || m.setData("text/plain", c._id), (D = h.dataTransfer) == null || D.setData("application/json", JSON.stringify(c));
+      const L = p.cloneNode(!0);
+      L.style.cssText = `
         position: fixed;
         top: -1000px;
         left: -1000px;
@@ -50,645 +416,645 @@ function Ft({
         max-width: 300px;
         background: white;
         border-radius: 8px;
-      `, document.body.appendChild(S), q.current = S, u.dataTransfer && u.dataTransfer.setDragImage(S, u.offsetX || 50, u.offsetY || 20), O({
+      `, document.body.appendChild(L), f.current = L, h.dataTransfer && h.dataTransfer.setDragImage(L, h.offsetX || 50, h.offsetY || 20), d({
         isDragging: !0,
-        draggedCard: o,
+        draggedCard: c,
         dragOverColumn: null,
         dragOverPosition: null,
-        dragSourceColumn: y._id
-      }), a == null || a(o, y.title, "being moved");
-    } catch (l) {
-      c == null || c(l instanceof Error ? l : new Error("Drag start failed")), b();
+        dragSourceColumn: b._id
+      }), t == null || t(c, b.title, "being moved");
+    } catch (p) {
+      e == null || e(p instanceof Error ? p : new Error("Drag start failed")), E();
     }
-  }, [D, c, b, a]), z = h((u, o) => {
-    if (u.preventDefault(), !s.isDragging || !s.draggedCard) return;
-    const g = o ? D(o) : null;
-    O((m) => ({
-      ...m,
-      dragOverColumn: (g == null ? void 0 : g._id) || null,
+  }, [C, e, E, t]), q = _((h, c) => {
+    if (h.preventDefault(), !i.isDragging || !i.draggedCard) return;
+    const m = c ? C(c) : null;
+    d((D) => ({
+      ...D,
+      dragOverColumn: (m == null ? void 0 : m._id) || null,
       dragOverPosition: null
       // Will be calculated based on mouse position
-    })), $(u);
-  }, [s.isDragging, s.draggedCard, D]), V = h((u, o) => {
-    if (u.preventDefault(), !(!s.isDragging || !s.draggedCard))
+    })), P(h);
+  }, [i.isDragging, i.draggedCard, C]), J = _((h, c) => {
+    if (h.preventDefault(), !(!i.isDragging || !i.draggedCard))
       try {
-        const g = s.draggedCard, m = s.dragSourceColumn, l = D(o), y = D(m);
-        if (!l || !y)
+        const m = i.draggedCard, D = i.dragSourceColumn, p = C(c), b = C(D);
+        if (!p || !b)
           throw new Error("Target or source column not found");
-        if (m === o) {
-          b();
+        if (D === c) {
+          E();
           return;
         }
-        if (l.limit && l.cards.length >= l.limit)
-          throw new Error(`Column "${l.title}" has reached its limit of ${l.limit} cards`);
-        i == null || i(g, m, o), a == null || a(g, y.title, l.title);
-      } catch (g) {
-        c == null || c(g instanceof Error ? g : new Error("Drop failed"));
+        if (p.limit && p.cards.length >= p.limit)
+          throw new Error(`Column "${p.title}" has reached its limit of ${p.limit} cards`);
+        a == null || a(m, D, c), t == null || t(m, b.title, p.title);
+      } catch (m) {
+        e == null || e(m instanceof Error ? m : new Error("Drop failed"));
       } finally {
-        b();
+        E();
       }
-  }, [s, D, i, c, b, a]), C = h(() => {
-    q.current && (document.body.removeChild(q.current), q.current = null), b();
-  }, [b]), $ = h((u) => {
-    const o = u.target.closest(".kanban-container");
-    if (!o) return;
-    const g = o.getBoundingClientRect(), m = u.clientX - g.left, l = g.width;
-    let y = 0;
-    if (m < ct ? y = -dt : m > l - ct && (y = dt), y !== 0) {
-      _.current && clearTimeout(_.current);
-      const S = () => {
-        o.scrollLeft += y, _.current = setTimeout(S, 16);
+  }, [i, C, a, e, E, t]), g = _(() => {
+    f.current && (document.body.removeChild(f.current), f.current = null), E();
+  }, [E]), P = _((h) => {
+    const c = h.target.closest(".kanban-container");
+    if (!c) return;
+    const m = c.getBoundingClientRect(), D = h.clientX - m.left, p = m.width;
+    let b = 0;
+    if (D < Xt ? b = -zt : D > p - Xt && (b = zt), b !== 0) {
+      y.current && clearTimeout(y.current);
+      const L = () => {
+        c.scrollLeft += b, y.current = setTimeout(L, 16);
       };
-      _.current = setTimeout(S, 100);
+      y.current = setTimeout(L, 100);
     } else
-      _.current && (clearTimeout(_.current), _.current = null);
-  }, []), L = h((u, o) => {
-    if (!["ArrowLeft", "ArrowRight", "ArrowUp", "ArrowDown", "Enter", "Space", "Escape"].includes(u.key))
+      y.current && (clearTimeout(y.current), y.current = null);
+  }, []), k = _((h, c) => {
+    if (!["ArrowLeft", "ArrowRight", "ArrowUp", "ArrowDown", "Enter", "Space", "Escape"].includes(h.key))
       return;
-    u.preventDefault();
-    const g = Y(o._id);
-    if (!g) return;
-    const { column: m } = g, l = d.findIndex((y) => y._id === m._id);
+    h.preventDefault();
+    const m = O(c._id);
+    if (!m) return;
+    const { column: D } = m, p = s.findIndex((b) => b._id === D._id);
     try {
-      switch (u.key) {
+      switch (h.key) {
         case "ArrowLeft":
-          if (l > 0) {
-            const y = d[l - 1];
-            i == null || i(o, m._id, y._id), a == null || a(o, m.title, y.title);
+          if (p > 0) {
+            const b = s[p - 1];
+            a == null || a(c, D._id, b._id), t == null || t(c, D.title, b.title);
           }
           break;
         case "ArrowRight":
-          if (l < d.length - 1) {
-            const y = d[l + 1];
-            i == null || i(o, m._id, y._id), a == null || a(o, m.title, y.title);
+          if (p < s.length - 1) {
+            const b = s[p + 1];
+            a == null || a(c, D._id, b._id), t == null || t(c, D.title, b.title);
           }
           break;
         case "ArrowUp":
-          a == null || a(o, "current position", "position above");
+          t == null || t(c, "current position", "position above");
           break;
         case "ArrowDown":
-          a == null || a(o, "current position", "position below");
+          t == null || t(c, "current position", "position below");
           break;
         case "Enter":
         case "Space":
-          a == null || a(o, m.title, "drag mode");
+          t == null || t(c, D.title, "drag mode");
           break;
         case "Escape":
-          a == null || a(o, "drag mode", "cancelled");
+          t == null || t(c, "drag mode", "cancelled");
           break;
       }
-    } catch (y) {
-      c == null || c(y instanceof Error ? y : new Error("Keyboard navigation failed"));
+    } catch (b) {
+      e == null || e(b instanceof Error ? b : new Error("Keyboard navigation failed"));
     }
-  }, [Y, d, i, c, a]), I = h((u, o) => {
-    const g = u.touches[0];
-    K.current = {
-      x: g.clientX,
-      y: g.clientY,
-      card: o
+  }, [O, s, a, e, t]), X = _((h, c) => {
+    const m = h.touches[0];
+    Q.current = {
+      x: m.clientX,
+      y: m.clientY,
+      card: c
     };
-  }, []), H = h((u) => {
-    if (!K.current) return;
-    const o = u.touches[0], g = Math.abs(o.clientX - K.current.x), m = Math.abs(o.clientY - K.current.y);
-    if (g > ut || m > ut) {
-      const l = K.current.card, y = D(l.columnId);
-      if (!y) return;
-      O({
+  }, []), et = _((h) => {
+    if (!Q.current) return;
+    const c = h.touches[0], m = Math.abs(c.clientX - Q.current.x), D = Math.abs(c.clientY - Q.current.y);
+    if (m > Nt || D > Nt) {
+      const p = Q.current.card, b = C(p.columnId);
+      if (!b) return;
+      d({
         isDragging: !0,
-        draggedCard: l,
+        draggedCard: p,
         dragOverColumn: null,
         dragOverPosition: null,
-        dragSourceColumn: y._id
-      }), a == null || a(l, y.title, "being moved");
+        dragSourceColumn: b._id
+      }), t == null || t(p, b.title, "being moved");
     }
-  }, [D, a]), p = h((u) => {
-    if (!s.isDragging || !s.draggedCard || !K.current) {
-      K.current = null;
+  }, [C, t]), S = _((h) => {
+    if (!i.isDragging || !i.draggedCard || !Q.current) {
+      Q.current = null;
       return;
     }
     try {
-      const o = u.changedTouches[0], g = document.elementFromPoint(o.clientX, o.clientY), m = g == null ? void 0 : g.closest("[data-column-id]");
-      if (m) {
-        const l = m.dataset.columnId, y = s.draggedCard, S = s.dragSourceColumn, Q = D(l), J = D(S);
-        if (Q && J && S !== l) {
-          if (Q.limit && Q.cards.length >= Q.limit)
-            throw new Error(`Column "${Q.title}" has reached its limit of ${Q.limit} cards`);
-          i == null || i(y, S, l), a == null || a(y, J.title, Q.title);
+      const c = h.changedTouches[0], m = document.elementFromPoint(c.clientX, c.clientY), D = m == null ? void 0 : m.closest("[data-column-id]");
+      if (D) {
+        const p = D.dataset.columnId, b = i.draggedCard, L = i.dragSourceColumn, U = C(p), gt = C(L);
+        if (U && gt && L !== p) {
+          if (U.limit && U.cards.length >= U.limit)
+            throw new Error(`Column "${U.title}" has reached its limit of ${U.limit} cards`);
+          a == null || a(b, L, p), t == null || t(b, gt.title, U.title);
         }
       }
-    } catch (o) {
-      c == null || c(o instanceof Error ? o : new Error("Touch drop failed"));
+    } catch (c) {
+      e == null || e(c instanceof Error ? c : new Error("Touch drop failed"));
     } finally {
-      K.current = null, b();
+      Q.current = null, E();
     }
-  }, [s, D, i, c, b, a]), T = h((u, o, g) => {
-    const m = `Moved "${u.title}" from ${o} to ${g}`, l = document.createElement("div");
-    l.setAttribute("aria-live", "polite"), l.setAttribute("aria-atomic", "true"), l.className = "sr-only", l.textContent = m, document.body.appendChild(l), setTimeout(() => {
-      document.body.removeChild(l);
-    }, 1e3), console.log(`Kanban: ${m}`);
+  }, [i, C, a, e, E, t]), V = _((h, c, m) => {
+    const D = `Moved "${h.title}" from ${c} to ${m}`, p = document.createElement("div");
+    p.setAttribute("aria-live", "polite"), p.setAttribute("aria-atomic", "true"), p.className = "sr-only", p.textContent = D, document.body.appendChild(p), setTimeout(() => {
+      document.body.removeChild(p);
+    }, 1e3), console.log(`Kanban: ${D}`);
   }, []);
-  return rt(() => () => {
-    _.current && clearTimeout(_.current), q.current && document.body.contains(q.current) && document.body.removeChild(q.current);
+  return _t(() => () => {
+    y.current && clearTimeout(y.current), f.current && document.body.contains(f.current) && document.body.removeChild(f.current);
   }, []), {
     // State
-    isDragging: s.isDragging,
-    draggedCard: s.draggedCard,
-    dragOverColumn: s.dragOverColumn,
-    dragOverPosition: s.dragOverPosition,
-    dragSourceColumn: s.dragSourceColumn,
+    isDragging: i.isDragging,
+    draggedCard: i.draggedCard,
+    dragOverColumn: i.dragOverColumn,
+    dragOverPosition: i.dragOverPosition,
+    dragSourceColumn: i.dragSourceColumn,
     // Handlers
-    handleDragStart: P,
-    handleDragOver: z,
-    handleDrop: V,
-    handleDragEnd: C,
-    handleKeyDown: L,
-    handleTouchStart: I,
-    handleTouchMove: H,
-    handleTouchEnd: p,
+    handleDragStart: K,
+    handleDragOver: q,
+    handleDrop: J,
+    handleDragEnd: g,
+    handleKeyDown: k,
+    handleTouchStart: X,
+    handleTouchMove: et,
+    handleTouchEnd: S,
     // Utilities
-    announceMove: a || T,
-    reset: b
+    announceMove: t || V,
+    reset: E
   };
 }
-function Xt(i) {
-  var at, nt, it;
+function Ie(a) {
+  var Tt, Rt, Ft;
   const {
-    columns: c,
-    source: d,
-    enableDragDrop: a = !0,
-    initialState: s,
-    onCardMove: O,
-    onCardCreate: q,
-    onCardUpdate: _,
-    onCardDelete: K,
-    onError: b
-  } = i, [D, Y] = G({
-    query: (s == null ? void 0 : s.search) || ""
-  }), [P] = G({
-    field: ((at = s == null ? void 0 : s.sorting) == null ? void 0 : at.field) || null,
-    direction: ((nt = s == null ? void 0 : s.sorting) == null ? void 0 : nt.direction) || null
-  }), [z, V] = G(() => {
-    const t = {};
-    return c.forEach((e) => {
-      t[e.id] = 10;
-    }), t;
-  }), C = k(b), $ = k(O), L = k(q), I = k(_), H = k(K);
-  rt(() => {
-    C.current = b, $.current = O, L.current = q, I.current = _, H.current = K;
-  }, [b, O, q, _, K]);
-  const p = At(), T = Et({
-    initialConditions: s == null ? void 0 : s.filters,
-    initialOperator: (s == null ? void 0 : s.filterOperator) || "And"
-  }), u = h((t) => {
-    const e = {
+    columns: e,
+    source: s,
+    enableDragDrop: t = !0,
+    initialState: i,
+    onCardMove: d,
+    onCardCreate: f,
+    onCardUpdate: y,
+    onCardDelete: Q,
+    onError: E
+  } = a, [C, O] = yt({
+    query: (i == null ? void 0 : i.search) || ""
+  }), [K] = yt({
+    field: ((Tt = i == null ? void 0 : i.sorting) == null ? void 0 : Tt.field) || null,
+    direction: ((Rt = i == null ? void 0 : i.sorting) == null ? void 0 : Rt.direction) || null
+  }), [q, J] = yt(() => {
+    const r = {};
+    return e.forEach((o) => {
+      r[o.id] = 10;
+    }), r;
+  }), g = G(E), P = G(d), k = G(f), X = G(y), et = G(Q);
+  _t(() => {
+    g.current = E, P.current = d, k.current = f, X.current = y, et.current = Q;
+  }, [E, d, f, y, Q]);
+  const S = kt(), V = Ee({
+    initialConditions: i == null ? void 0 : i.filters,
+    initialOperator: (i == null ? void 0 : i.filterOperator) || "And"
+  }), h = _((r) => {
+    const o = {
       LHSField: "columnId",
       Operator: "EQ",
-      RHSValue: t,
+      RHSValue: r,
       RHSType: "Constant"
-    }, r = T.payload;
-    let n;
-    r ? r.Operator === "And" ? n = {
-      ...r,
-      Condition: [...r.Condition || [], e]
-    } : n = {
+    }, n = V.payload;
+    let u;
+    n ? n.Operator === "And" ? u = {
+      ...n,
+      Condition: [...n.Condition || [], o]
+    } : u = {
       Operator: "And",
-      Condition: [r, e]
-    } : n = {
+      Condition: [n, o]
+    } : u = {
       Operator: "And",
-      Condition: [e]
+      Condition: [o]
     };
-    const f = {
+    const w = {
       Page: 1,
       // Always page 1 due to expanding PageSize strategy
-      PageSize: z[t] || 10,
-      Filter: n
+      PageSize: q[r] || 10,
+      Filter: u
     };
-    return P.field && P.direction ? f.Sort = [
-      { [String(P.field)]: P.direction === "asc" ? "ASC" : "DESC" },
+    return K.field && K.direction ? w.Sort = [
+      { [String(K.field)]: K.direction === "asc" ? "ASC" : "DESC" },
       { position: "ASC" }
-    ] : f.Sort = [
+    ] : w.Sort = [
       { columnId: "ASC" },
       { position: "ASC" }
-    ], D.query && (f.Search = D.query), f;
-  }, [T.payload, z, P, D.query]), o = Tt({
-    queries: c.map((t) => {
-      const e = u(t.id);
+    ], C.query && (w.Search = C.query), w;
+  }, [V.payload, q, K, C.query]), c = ke({
+    queries: e.map((r) => {
+      const o = h(r.id);
       return {
-        queryKey: ["kanban-cards", d, t.id, e],
+        queryKey: ["kanban-cards", s, r.id, o],
         queryFn: async () => {
           try {
-            return await F(d).list(e);
-          } catch (r) {
-            throw r;
+            return await M(s).list(o);
+          } catch (n) {
+            throw n;
           }
         },
-        placeholderData: kt,
+        placeholderData: _e,
         staleTime: 30 * 1e3
       };
     })
-  }), g = o.some((t) => t.isLoading), m = o.some((t) => t.isFetching), l = ((it = o.find((t) => t.error)) == null ? void 0 : it.error) || null, y = async () => {
-    await Promise.all(o.map((t) => t.refetch()));
-  }, S = ot(() => {
-    const t = {};
-    return D.query && (t.Search = D.query), T.payload && (t.Filter = T.payload), t;
-  }, [D.query, T.payload]), {
-    data: Q,
-    isLoading: J,
-    error: lt
-  } = Pt({
-    queryKey: ["kanban-count", d, S],
+  }), m = c.some((r) => r.isLoading), D = c.some((r) => r.isFetching), p = ((Ft = c.find((r) => r.error)) == null ? void 0 : Ft.error) || null, b = async () => {
+    await Promise.all(c.map((r) => r.refetch()));
+  }, L = Ht(() => {
+    const r = {};
+    return C.query && (r.Search = C.query), V.payload && (r.Filter = V.payload), r;
+  }, [C.query, V.payload]), {
+    data: U,
+    isLoading: gt,
+    error: xt
+  } = Qe({
+    queryKey: ["kanban-count", s, L],
     queryFn: async () => {
       try {
-        return await F(d).count(S);
-      } catch (t) {
-        throw C.current && C.current(t), t;
+        return await M(s).count(L);
+      } catch (r) {
+        throw g.current && g.current(r), r;
       }
     },
     staleTime: 30 * 1e3,
     gcTime: 60 * 1e3
-  }), et = j({
-    mutationFn: async (t) => {
-      const e = t.position ?? 999999;
-      return (await F(d).create({ ...t, position: e }))._id;
+  }), At = ut({
+    mutationFn: async (r) => {
+      const o = r.position ?? 999999;
+      return (await M(s).create({ ...r, position: o }))._id;
     },
-    onMutate: async (t) => {
-      const e = t.columnId, r = u(e), n = ["kanban-cards", d, e, r];
-      await p.cancelQueries({ queryKey: n });
-      const f = p.getQueryData(n);
-      if (f) {
-        const U = f.Data, A = t.position ?? U.length, X = `temp-${Date.now()}`, E = {
-          ...t,
-          _id: X,
-          position: A,
+    onMutate: async (r) => {
+      const o = r.columnId, n = h(o), u = ["kanban-cards", s, o, n];
+      await S.cancelQueries({ queryKey: u });
+      const w = S.getQueryData(u);
+      if (w) {
+        const rt = w.Data, j = r.position ?? rt.length, st = `temp-${Date.now()}`, x = {
+          ...r,
+          _id: st,
+          position: j,
           _created_at: /* @__PURE__ */ new Date(),
           _modified_at: /* @__PURE__ */ new Date()
         };
-        p.setQueryData(n, {
-          ...f,
-          Data: [...f.Data, E]
+        S.setQueryData(u, {
+          ...w,
+          Data: [...w.Data, x]
         });
       }
-      return { previousCards: f, queryKey: n };
+      return { previousCards: w, queryKey: u };
     },
-    onSuccess: async (t, e, r) => {
-      var n;
-      r != null && r.queryKey && await p.invalidateQueries({ queryKey: r.queryKey }), (n = L.current) == null || n.call(L, {
-        _id: t,
-        ...e
+    onSuccess: async (r, o, n) => {
+      var u;
+      n != null && n.queryKey && await S.invalidateQueries({ queryKey: n.queryKey }), (u = k.current) == null || u.call(k, {
+        _id: r,
+        ...o
       });
     },
-    onError: (t, e, r) => {
-      var n;
-      r != null && r.previousCards && (r != null && r.queryKey) && p.setQueryData(r.queryKey, r.previousCards), (n = C.current) == null || n.call(C, t);
+    onError: (r, o, n) => {
+      var u;
+      n != null && n.previousCards && (n != null && n.queryKey) && S.setQueryData(n.queryKey, n.previousCards), (u = g.current) == null || u.call(g, r);
     },
-    onSettled: (t, e, r) => {
-      const n = r.columnId, f = u(n);
-      p.invalidateQueries({ queryKey: ["kanban-cards", d, n, f] });
+    onSettled: (r, o, n) => {
+      const u = n.columnId, w = h(u);
+      S.invalidateQueries({ queryKey: ["kanban-cards", s, u, w] });
     }
-  }), Z = j({
-    mutationFn: async ({ id: t, updates: e }) => (await F(d).update(t, e), { id: t, updates: e }),
-    onMutate: async () => (await p.cancelQueries({ queryKey: ["kanban-cards", d] }), {}),
-    onSuccess: async (t) => {
-      var e;
-      (e = I.current) == null || e.call(I, { _id: t.id, ...t.updates });
+  }), bt = ut({
+    mutationFn: async ({ id: r, updates: o }) => (await M(s).update(r, o), { id: r, updates: o }),
+    onMutate: async () => (await S.cancelQueries({ queryKey: ["kanban-cards", s] }), {}),
+    onSuccess: async (r) => {
+      var o;
+      (o = X.current) == null || o.call(X, { _id: r.id, ...r.updates });
     },
-    onError: (t, e, r) => {
-      var n;
-      (n = C.current) == null || n.call(C, t);
+    onError: (r, o, n) => {
+      var u;
+      (u = g.current) == null || u.call(g, r);
     },
     onSettled: () => {
-      p.invalidateQueries({ queryKey: ["kanban-cards", d] });
+      S.invalidateQueries({ queryKey: ["kanban-cards", s] });
     }
-  }), v = j({
-    mutationFn: async (t) => (await F(d).delete(t), t),
-    onMutate: async () => (await p.cancelQueries({ queryKey: ["kanban-cards", d] }), {}),
-    onSuccess: async (t) => {
-      var e;
-      (e = H.current) == null || e.call(H, t);
+  }), Ct = ut({
+    mutationFn: async (r) => (await M(s).delete(r), r),
+    onMutate: async () => (await S.cancelQueries({ queryKey: ["kanban-cards", s] }), {}),
+    onSuccess: async (r) => {
+      var o;
+      (o = et.current) == null || o.call(et, r);
     },
-    onError: (t, e, r) => {
-      var n;
-      (n = C.current) == null || n.call(C, t);
+    onError: (r, o, n) => {
+      var u;
+      (u = g.current) == null || u.call(g, r);
     },
     onSettled: () => {
-      p.invalidateQueries({ queryKey: ["kanban-cards", d] });
+      S.invalidateQueries({ queryKey: ["kanban-cards", s] });
     }
-  }), B = j({
-    mutationFn: async ({ cardId: t, fromColumnId: e, toColumnId: r, position: n }) => {
-      const f = { columnId: r, ...n !== void 0 && { position: n } };
-      return await F(d).update(t, f), { cardId: t, fromColumnId: e, toColumnId: r, position: n };
+  }), nt = ut({
+    mutationFn: async ({ cardId: r, fromColumnId: o, toColumnId: n, position: u }) => {
+      const w = { columnId: n, ...u !== void 0 && { position: u } };
+      return await M(s).update(r, w), { cardId: r, fromColumnId: o, toColumnId: n, position: u };
     },
-    onMutate: async ({ cardId: t, fromColumnId: e, toColumnId: r, position: n }) => {
-      const f = u(e), U = u(r), A = ["kanban-cards", d, e, f], X = ["kanban-cards", d, r, U];
-      await p.cancelQueries({ queryKey: A }), await p.cancelQueries({ queryKey: X });
-      const E = p.getQueryData(A), N = p.getQueryData(X);
-      if (E && N) {
-        const st = E.Data.find((M) => M._id === t);
-        if (st) {
-          const M = {
-            ...E,
-            Data: E.Data.filter((tt) => tt._id !== t)
-          }, St = {
-            ...st,
-            columnId: r,
-            position: n ?? N.Data.length,
+    onMutate: async ({ cardId: r, fromColumnId: o, toColumnId: n, position: u }) => {
+      const w = h(o), rt = h(n), j = ["kanban-cards", s, o, w], st = ["kanban-cards", s, n, rt];
+      await S.cancelQueries({ queryKey: j }), await S.cancelQueries({ queryKey: st });
+      const x = S.getQueryData(j), ot = S.getQueryData(st);
+      if (x && ot) {
+        const Lt = x.Data.find((wt) => wt._id === r);
+        if (Lt) {
+          const wt = {
+            ...x,
+            Data: x.Data.filter((Ot) => Ot._id !== r)
+          }, le = {
+            ...Lt,
+            columnId: n,
+            position: u ?? ot.Data.length,
             _modified_at: /* @__PURE__ */ new Date()
-          }, Ot = {
-            ...N,
-            Data: [...N.Data, St].sort((tt, Kt) => tt.position - Kt.position)
+          }, de = {
+            ...ot,
+            Data: [...ot.Data, le].sort((Ot, he) => Ot.position - he.position)
           };
-          p.setQueryData(A, M), p.setQueryData(X, Ot);
+          S.setQueryData(j, wt), S.setQueryData(st, de);
         }
       }
       return {
-        previousFromData: E,
-        previousToData: N,
-        fromQueryKey: A,
-        toQueryKey: X,
-        fromColumnId: e,
-        toColumnId: r
+        previousFromData: x,
+        previousToData: ot,
+        fromQueryKey: j,
+        toQueryKey: st,
+        fromColumnId: o,
+        toColumnId: n
       };
     },
-    onSuccess: async (t) => {
-      var e;
-      (e = $.current) == null || e.call(
-        $,
-        { _id: t.cardId },
-        t.fromColumnId,
-        t.toColumnId
+    onSuccess: async (r) => {
+      var o;
+      (o = P.current) == null || o.call(
+        P,
+        { _id: r.cardId },
+        r.fromColumnId,
+        r.toColumnId
       );
     },
-    onError: (t, e, r) => {
-      var n;
-      r != null && r.previousFromData && (r != null && r.fromQueryKey) && p.setQueryData(r.fromQueryKey, r.previousFromData), r != null && r.previousToData && (r != null && r.toQueryKey) && p.setQueryData(r.toQueryKey, r.previousToData), (n = C.current) == null || n.call(C, t);
+    onError: (r, o, n) => {
+      var u;
+      n != null && n.previousFromData && (n != null && n.fromQueryKey) && S.setQueryData(n.fromQueryKey, n.previousFromData), n != null && n.previousToData && (n != null && n.toQueryKey) && S.setQueryData(n.toQueryKey, n.previousToData), (u = g.current) == null || u.call(g, r);
     },
-    onSettled: (t, e, r) => {
-      const n = u(r.fromColumnId), f = u(r.toColumnId);
-      p.invalidateQueries({ queryKey: ["kanban-cards", d, r.fromColumnId, n] }), p.invalidateQueries({ queryKey: ["kanban-cards", d, r.toColumnId, f] });
+    onSettled: (r, o, n) => {
+      const u = h(n.fromColumnId), w = h(n.toColumnId);
+      S.invalidateQueries({ queryKey: ["kanban-cards", s, n.fromColumnId, u] }), S.invalidateQueries({ queryKey: ["kanban-cards", s, n.toColumnId, w] });
     }
-  }), x = j({
-    mutationFn: async ({ cardIds: t, columnId: e }) => {
-      const r = t.map((n, f) => ({ id: n, position: f, columnId: e }));
+  }), Dt = ut({
+    mutationFn: async ({ cardIds: r, columnId: o }) => {
+      const n = r.map((u, w) => ({ id: u, position: w, columnId: o }));
       await Promise.all(
-        r.map(
-          (n) => F(d).update(n.id, { position: n.position, columnId: n.columnId })
+        n.map(
+          (u) => M(s).update(u.id, { position: u.position, columnId: u.columnId })
         )
       );
     },
-    onMutate: async ({ columnId: t }) => {
-      const e = u(t), r = ["kanban-cards", d, t, e];
-      return await p.cancelQueries({ queryKey: r }), {};
+    onMutate: async ({ columnId: r }) => {
+      const o = h(r), n = ["kanban-cards", s, r, o];
+      return await S.cancelQueries({ queryKey: n }), {};
     },
     onSuccess: () => {
     },
-    onError: (t, e, r) => {
-      var n;
-      (n = C.current) == null || n.call(C, t);
+    onError: (r, o, n) => {
+      var u;
+      (u = g.current) == null || u.call(g, r);
     },
-    onSettled: (t, e, r) => {
-      const n = u(r.columnId);
-      p.invalidateQueries({ queryKey: ["kanban-cards", d, r.columnId, n] });
+    onSettled: (r, o, n) => {
+      const u = h(n.columnId);
+      S.invalidateQueries({ queryKey: ["kanban-cards", s, n.columnId, u] });
     }
-  }), gt = h(
-    async (t, e, r) => {
+  }), Mt = _(
+    async (r, o, n) => {
       try {
-        await B.mutateAsync({
-          cardId: t._id,
-          fromColumnId: e,
-          toColumnId: r,
+        await nt.mutateAsync({
+          cardId: r._id,
+          fromColumnId: o,
+          toColumnId: n,
           position: void 0
         });
       } catch {
       }
     },
-    [B]
-  ), R = ot(() => c.sort((t, e) => t.position - e.position).map((t, e) => {
-    var f;
-    const n = ((f = o[e].data) == null ? void 0 : f.Data) || [];
+    [nt]
+  ), ft = Ht(() => e.sort((r, o) => r.position - o.position).map((r, o) => {
+    var w;
+    const u = ((w = c[o].data) == null ? void 0 : w.Data) || [];
     return {
-      _id: t.id,
-      title: t.title,
-      position: t.position,
-      color: t.color,
-      limit: t.limit,
-      cards: n.sort((U, A) => U.position - A.position),
+      _id: r.id,
+      title: r.title,
+      position: r.position,
+      color: r.color,
+      limit: r.limit,
+      cards: u.sort((rt, j) => rt.position - j.position),
       _created_at: /* @__PURE__ */ new Date(),
       _modified_at: /* @__PURE__ */ new Date()
     };
-  }), [c, o]), w = Ft({
-    onCardMove: gt,
-    onError: C.current,
-    columns: R,
-    announceMove: (t, e, r) => {
+  }), [e, c]), A = Ae({
+    onCardMove: Mt,
+    onError: g.current,
+    columns: ft,
+    announceMove: (r, o, n) => {
       console.log(
-        `Kanban: Moved "${t.title}" from ${e} to ${r}`
+        `Kanban: Moved "${r.title}" from ${o} to ${n}`
       );
     }
-  }), yt = h(
-    (t) => {
-      var e, r;
+  }), te = _(
+    (r) => {
+      var o, n;
       return {
         draggable: !0,
         role: "option",
-        "aria-selected": a && ((e = w.draggedCard) == null ? void 0 : e._id) === t._id,
-        "aria-grabbed": a && ((r = w.draggedCard) == null ? void 0 : r._id) === t._id,
-        onDragStart: (n) => {
-          if (!a) return;
-          n.dataTransfer.setData("text/plain", JSON.stringify(t));
-          const f = n.nativeEvent || n;
-          w.handleDragStart(f, t);
+        "aria-selected": t && ((o = A.draggedCard) == null ? void 0 : o._id) === r._id,
+        "aria-grabbed": t && ((n = A.draggedCard) == null ? void 0 : n._id) === r._id,
+        onDragStart: (u) => {
+          if (!t) return;
+          u.dataTransfer.setData("text/plain", JSON.stringify(r));
+          const w = u.nativeEvent || u;
+          A.handleDragStart(w, r);
         },
-        onDragEnd: w.handleDragEnd,
-        onKeyDown: (n) => {
-          if (!a) return;
-          const f = n.nativeEvent || n;
-          w.handleKeyDown(f, t);
+        onDragEnd: A.handleDragEnd,
+        onKeyDown: (u) => {
+          if (!t) return;
+          const w = u.nativeEvent || u;
+          A.handleKeyDown(w, r);
         }
       };
     },
-    [a, w]
-  ), mt = h(
-    (t) => ({
-      "data-column-id": t,
+    [t, A]
+  ), ee = _(
+    (r) => ({
+      "data-column-id": r,
       role: "listbox",
-      onDragOver: (e) => {
-        if (!a) return;
-        const r = e.nativeEvent || e;
-        w.handleDragOver(r, t);
+      onDragOver: (o) => {
+        if (!t) return;
+        const n = o.nativeEvent || o;
+        A.handleDragOver(n, r);
       },
-      onDrop: (e) => {
-        if (!a) return;
-        const r = e.nativeEvent || e;
-        w.handleDrop(r, t);
+      onDrop: (o) => {
+        if (!t) return;
+        const n = o.nativeEvent || o;
+        A.handleDrop(n, r);
       }
     }),
-    [a, w]
-  ), ft = h((t) => {
-    Y({ query: t });
-  }, []), pt = h(() => {
-    Y({ query: "" });
-  }, []), ht = (Q == null ? void 0 : Q.Count) || 0, Ct = g || J, Dt = m, wt = et.isPending || Z.isPending || v.isPending || B.isPending || x.isPending, W = l || lt, _t = h(async () => {
-    await y();
-  }, [y]), bt = h(async () => {
-    await p.invalidateQueries({
-      predicate: (t) => t.queryKey[0] === "kanban-cards" || t.queryKey[0] === "kanban-count"
+    [t, A]
+  ), re = _((r) => {
+    O({ query: r });
+  }, []), se = _(() => {
+    O({ query: "" });
+  }, []), ie = (U == null ? void 0 : U.Count) || 0, ae = m || gt, ne = D, oe = At.isPending || bt.isPending || Ct.isPending || nt.isPending || Dt.isPending, pt = p || xt, ue = _(async () => {
+    await b();
+  }, [b]), ce = _(async () => {
+    await S.invalidateQueries({
+      predicate: (r) => r.queryKey[0] === "kanban-cards" || r.queryKey[0] === "kanban-count"
     });
-  }, [p]);
-  return rt(() => {
-    W && C.current && C.current(W);
-  }, [W]), {
+  }, [S]);
+  return _t(() => {
+    pt && g.current && g.current(pt);
+  }, [pt]), {
     // Data
-    columns: R,
-    totalCards: ht,
+    columns: ft,
+    totalCards: ie,
     // Loading States
-    isLoading: Ct,
-    isFetching: Dt,
-    isUpdating: wt,
+    isLoading: ae,
+    isFetching: ne,
+    isUpdating: oe,
     // Error Handling
-    error: W,
+    error: pt,
     // Card Operations (Flat Access)
-    createCard: et.mutateAsync,
-    updateCard: h(
-      async (t, e) => {
-        await Z.mutateAsync({ id: t, updates: e });
+    createCard: At.mutateAsync,
+    updateCard: _(
+      async (r, o) => {
+        await bt.mutateAsync({ id: r, updates: o });
       },
-      [Z]
+      [bt]
     ),
-    deleteCard: h(
-      async (t) => {
-        await v.mutateAsync(t);
+    deleteCard: _(
+      async (r) => {
+        await Ct.mutateAsync(r);
       },
-      [v]
+      [Ct]
     ),
-    moveCard: h(
-      async (t, e, r, n) => {
-        if (!n) {
-          for (const f of R)
-            if (f.cards.find((A) => A._id === t)) {
-              n = f._id;
+    moveCard: _(
+      async (r, o, n, u) => {
+        if (!u) {
+          for (const w of ft)
+            if (w.cards.find((j) => j._id === r)) {
+              u = w._id;
               break;
             }
-          if (!n)
-            throw new Error(`Card ${t} not found in any column`);
+          if (!u)
+            throw new Error(`Card ${r} not found in any column`);
         }
-        await B.mutateAsync({ cardId: t, fromColumnId: n, toColumnId: e, position: r });
+        await nt.mutateAsync({ cardId: r, fromColumnId: u, toColumnId: o, position: n });
       },
-      [B, R]
+      [nt, ft]
     ),
-    reorderCards: h(
-      async (t, e) => {
-        await x.mutateAsync({ cardIds: t, columnId: e });
+    reorderCards: _(
+      async (r, o) => {
+        await Dt.mutateAsync({ cardIds: r, columnId: o });
       },
-      [x]
+      [Dt]
     ),
     // Search (Flat Access)
-    searchQuery: D.query,
-    setSearchQuery: ft,
-    clearSearch: pt,
+    searchQuery: C.query,
+    setSearchQuery: re,
+    clearSearch: se,
     // Filter (Simplified chainable API)
-    filter: T,
+    filter: V,
     // Drag Drop (Flat Access)
-    isDragging: a ? w.isDragging : !1,
-    draggedCard: a ? w.draggedCard : null,
-    dragOverColumn: a ? w.dragOverColumn : null,
-    handleDragStart: a ? w.handleDragStart : () => {
+    isDragging: t ? A.isDragging : !1,
+    draggedCard: t ? A.draggedCard : null,
+    dragOverColumn: t ? A.dragOverColumn : null,
+    handleDragStart: t ? A.handleDragStart : () => {
     },
-    handleDragOver: a ? w.handleDragOver : () => {
+    handleDragOver: t ? A.handleDragOver : () => {
     },
-    handleDrop: a ? w.handleDrop : () => {
+    handleDrop: t ? A.handleDrop : () => {
     },
-    handleDragEnd: a ? w.handleDragEnd : () => {
+    handleDragEnd: t ? A.handleDragEnd : () => {
     },
-    handleKeyDown: a ? w.handleKeyDown : () => {
+    handleKeyDown: t ? A.handleKeyDown : () => {
     },
     // Prop Getters
-    getCardProps: a ? yt : (t) => ({}),
-    getColumnProps: a ? mt : (t) => ({}),
+    getCardProps: t ? te : (r) => ({}),
+    getColumnProps: t ? ee : (r) => ({}),
     // Load More (Per Column)
-    loadMore: h((t) => {
-      V((e) => ({
-        ...e,
-        [t]: (e[t] || 10) + 10
+    loadMore: _((r) => {
+      J((o) => ({
+        ...o,
+        [r]: (o[r] || 10) + 10
       }));
     }, []),
     // Utilities
-    refetch: _t,
-    refresh: bt
+    refetch: ue,
+    refresh: ce
   };
 }
-const $t = qt(null);
-function Yt() {
-  const i = Qt($t);
-  if (!i)
+const Te = ge(null);
+function Ue() {
+  const a = fe(Te);
+  if (!a)
     throw new Error(
       "Kanban components must be used within a KanbanBoard component"
     );
-  return i;
+  return a;
 }
-function Bt(i, c) {
-  const d = c.reduce((a, s) => (a[s.columnId] || (a[s.columnId] = []), a[s.columnId].push(s), a), {});
-  return i.map((a) => ({
-    ...a,
-    cards: (d[a._id] || []).sort((s, O) => s.position - O.position)
+function je(a, e) {
+  const s = e.reduce((t, i) => (t[i.columnId] || (t[i.columnId] = []), t[i.columnId].push(i), t), {});
+  return a.map((t) => ({
+    ...t,
+    cards: (s[t._id] || []).sort((i, d) => i.position - d.position)
   }));
 }
-function Nt(i, c) {
-  if (i.cards.length === 0)
+function Be(a, e) {
+  if (a.cards.length === 0)
     return 0;
-  if (c === void 0 || c >= i.cards.length)
-    return i.cards[i.cards.length - 1].position + 1;
-  if (c === 0) {
-    const s = i.cards[0];
-    return Math.max(0, s.position - 1);
+  if (e === void 0 || e >= a.cards.length)
+    return a.cards[a.cards.length - 1].position + 1;
+  if (e === 0) {
+    const i = a.cards[0];
+    return Math.max(0, i.position - 1);
   }
-  const d = i.cards[c - 1], a = i.cards[c];
-  return Math.floor((d.position + a.position) / 2);
+  const s = a.cards[e - 1], t = a.cards[e];
+  return Math.floor((s.position + t.position) / 2);
 }
-function jt(i, c) {
-  if (i.length === 0)
+function Xe(a, e) {
+  if (a.length === 0)
     return 0;
-  if (c === void 0 || c >= i.length)
-    return i[i.length - 1].position + 1;
-  if (c === 0) {
-    const s = i[0];
-    return Math.max(0, s.position - 1);
+  if (e === void 0 || e >= a.length)
+    return a[a.length - 1].position + 1;
+  if (e === 0) {
+    const i = a[0];
+    return Math.max(0, i.position - 1);
   }
-  const d = i[c - 1], a = i[c];
-  return Math.floor((d.position + a.position) / 2);
+  const s = a[e - 1], t = a[e];
+  return Math.floor((s.position + t.position) / 2);
 }
-function zt(i) {
-  return i.sort((c, d) => c.position - d.position).map((c, d) => ({
-    ...c,
-    position: d
+function ze(a) {
+  return a.sort((e, s) => e.position - s.position).map((e, s) => ({
+    ...e,
+    position: s
   }));
 }
-function Jt(i, c, d, a) {
-  const s = `Failed to ${c} ${d}`, O = a ? ` (ID: ${a})` : "";
-  return i instanceof Error ? new Error(`${s}${O}: ${i.message}`) : new Error(`${s}${O}: Unknown error`);
+function Ne(a, e, s, t) {
+  const i = `Failed to ${e} ${s}`, d = t ? ` (ID: ${t})` : "";
+  return a instanceof Error ? new Error(`${i}${d}: ${a.message}`) : new Error(`${i}${d}: Unknown error`);
 }
-function Rt(i, c) {
-  switch (c) {
+function Ye(a, e) {
+  switch (e) {
     case "list":
-      return i && Array.isArray(i.Data);
+      return a && Array.isArray(a.Data);
     case "single":
-      return i && typeof i == "object";
+      return a && typeof a == "object";
     case "create":
-      return i && typeof i._id == "string";
+      return a && typeof a._id == "string";
     case "delete":
-      return i && i.status === "success";
+      return a && a.status === "success";
     default:
       return !1;
   }
 }
 export {
-  $t as KanbanContext,
-  Nt as calculateCardPosition,
-  jt as calculateColumnPosition,
-  Jt as handleKanbanApiError,
-  Bt as mergeCardsIntoColumns,
-  zt as normalizePositions,
-  Ft as useDragDropManager,
-  Xt as useKanban,
-  Yt as useKanbanContext,
-  Rt as validateApiResponse
+  Te as KanbanContext,
+  Be as calculateCardPosition,
+  Xe as calculateColumnPosition,
+  Ne as handleKanbanApiError,
+  je as mergeCardsIntoColumns,
+  ze as normalizePositions,
+  Ae as useDragDropManager,
+  Ie as useKanban,
+  Ue as useKanbanContext,
+  Ye as validateApiResponse
 };