@ram_28/kf-ai-sdk 1.0.11 → 1.0.13

package/dist/kanban.mjs

@@ -0,0 +1,1060 @@
+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 [i, d] = yt({
+    isDragging: !1,
+    draggedCard: null,
+    dragOverColumn: null,
+    dragOverPosition: null,
+    dragSourceColumn: null
+  }), f = G(null), y = G(null), Q = G(null), E = _(() => {
+    d({
+      isDragging: !1,
+      draggedCard: null,
+      dragOverColumn: null,
+      dragOverPosition: null,
+      dragSourceColumn: null
+    }), 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;
+  }, [s]), K = _((h, c) => {
+    var m, D;
+    try {
+      const p = h.target, b = C(c.columnId);
+      if (!b)
+        throw new Error("Source column not found");
+      (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;
+        opacity: 0.9;
+        transform: rotate(-2deg) scale(0.95);
+        box-shadow: 0 10px 25px rgba(0,0,0,0.2);
+        pointer-events: none;
+        z-index: 9999;
+        max-width: 300px;
+        background: white;
+        border-radius: 8px;
+      `, document.body.appendChild(L), f.current = L, h.dataTransfer && h.dataTransfer.setDragImage(L, h.offsetX || 50, h.offsetY || 20), d({
+        isDragging: !0,
+        draggedCard: c,
+        dragOverColumn: null,
+        dragOverPosition: null,
+        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();
+    }
+  }, [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
+    })), P(h);
+  }, [i.isDragging, i.draggedCard, C]), J = _((h, c) => {
+    if (h.preventDefault(), !(!i.isDragging || !i.draggedCard))
+      try {
+        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 (D === c) {
+          E();
+          return;
+        }
+        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 {
+        E();
+      }
+  }, [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);
+      };
+      y.current = setTimeout(L, 100);
+    } else
+      y.current && (clearTimeout(y.current), y.current = null);
+  }, []), k = _((h, c) => {
+    if (!["ArrowLeft", "ArrowRight", "ArrowUp", "ArrowDown", "Enter", "Space", "Escape"].includes(h.key))
+      return;
+    h.preventDefault();
+    const m = O(c._id);
+    if (!m) return;
+    const { column: D } = m, p = s.findIndex((b) => b._id === D._id);
+    try {
+      switch (h.key) {
+        case "ArrowLeft":
+          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 (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":
+          t == null || t(c, "current position", "position above");
+          break;
+        case "ArrowDown":
+          t == null || t(c, "current position", "position below");
+          break;
+        case "Enter":
+        case "Space":
+          t == null || t(c, D.title, "drag mode");
+          break;
+        case "Escape":
+          t == null || t(c, "drag mode", "cancelled");
+          break;
+      }
+    } catch (b) {
+      e == null || e(b instanceof Error ? b : new Error("Keyboard navigation failed"));
+    }
+  }, [O, s, a, e, t]), X = _((h, c) => {
+    const m = h.touches[0];
+    Q.current = {
+      x: m.clientX,
+      y: m.clientY,
+      card: c
+    };
+  }, []), 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: p,
+        dragOverColumn: null,
+        dragOverPosition: null,
+        dragSourceColumn: b._id
+      }), t == null || t(p, b.title, "being moved");
+    }
+  }, [C, t]), S = _((h) => {
+    if (!i.isDragging || !i.draggedCard || !Q.current) {
+      Q.current = null;
+      return;
+    }
+    try {
+      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 (c) {
+      e == null || e(c instanceof Error ? c : new Error("Touch drop failed"));
+    } finally {
+      Q.current = null, E();
+    }
+  }, [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 _t(() => () => {
+    y.current && clearTimeout(y.current), f.current && document.body.contains(f.current) && document.body.removeChild(f.current);
+  }, []), {
+    // State
+    isDragging: i.isDragging,
+    draggedCard: i.draggedCard,
+    dragOverColumn: i.dragOverColumn,
+    dragOverPosition: i.dragOverPosition,
+    dragSourceColumn: i.dragSourceColumn,
+    // Handlers
+    handleDragStart: K,
+    handleDragOver: q,
+    handleDrop: J,
+    handleDragEnd: g,
+    handleKeyDown: k,
+    handleTouchStart: X,
+    handleTouchMove: et,
+    handleTouchEnd: S,
+    // Utilities
+    announceMove: t || V,
+    reset: E
+  };
+}
+function Ie(a) {
+  var Tt, Rt, Ft;
+  const {
+    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: r,
+      RHSType: "Constant"
+    }, n = V.payload;
+    let u;
+    n ? n.Operator === "And" ? u = {
+      ...n,
+      Condition: [...n.Condition || [], o]
+    } : u = {
+      Operator: "And",
+      Condition: [n, o]
+    } : u = {
+      Operator: "And",
+      Condition: [o]
+    };
+    const w = {
+      Page: 1,
+      // Always page 1 due to expanding PageSize strategy
+      PageSize: q[r] || 10,
+      Filter: u
+    };
+    return K.field && K.direction ? w.Sort = [
+      { [String(K.field)]: K.direction === "asc" ? "ASC" : "DESC" },
+      { position: "ASC" }
+    ] : w.Sort = [
+      { columnId: "ASC" },
+      { position: "ASC" }
+    ], 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", s, r.id, o],
+        queryFn: async () => {
+          try {
+            return await M(s).list(o);
+          } catch (n) {
+            throw n;
+          }
+        },
+        placeholderData: _e,
+        staleTime: 30 * 1e3
+      };
+    })
+  }), 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 M(s).count(L);
+      } catch (r) {
+        throw g.current && g.current(r), r;
+      }
+    },
+    staleTime: 30 * 1e3,
+    gcTime: 60 * 1e3
+  }), At = ut({
+    mutationFn: async (r) => {
+      const o = r.position ?? 999999;
+      return (await M(s).create({ ...r, position: o }))._id;
+    },
+    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()
+        };
+        S.setQueryData(u, {
+          ...w,
+          Data: [...w.Data, x]
+        });
+      }
+      return { previousCards: w, queryKey: u };
+    },
+    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: (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: (r, o, n) => {
+      const u = n.columnId, w = h(u);
+      S.invalidateQueries({ queryKey: ["kanban-cards", s, u, w] });
+    }
+  }), 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: (r, o, n) => {
+      var u;
+      (u = g.current) == null || u.call(g, r);
+    },
+    onSettled: () => {
+      S.invalidateQueries({ queryKey: ["kanban-cards", s] });
+    }
+  }), 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: (r, o, n) => {
+      var u;
+      (u = g.current) == null || u.call(g, r);
+    },
+    onSettled: () => {
+      S.invalidateQueries({ queryKey: ["kanban-cards", s] });
+    }
+  }), 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: 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()
+          }, de = {
+            ...ot,
+            Data: [...ot.Data, le].sort((Ot, he) => Ot.position - he.position)
+          };
+          S.setQueryData(j, wt), S.setQueryData(st, de);
+        }
+      }
+      return {
+        previousFromData: x,
+        previousToData: ot,
+        fromQueryKey: j,
+        toQueryKey: st,
+        fromColumnId: o,
+        toColumnId: n
+      };
+    },
+    onSuccess: async (r) => {
+      var o;
+      (o = P.current) == null || o.call(
+        P,
+        { _id: r.cardId },
+        r.fromColumnId,
+        r.toColumnId
+      );
+    },
+    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: (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] });
+    }
+  }), Dt = ut({
+    mutationFn: async ({ cardIds: r, columnId: o }) => {
+      const n = r.map((u, w) => ({ id: u, position: w, columnId: o }));
+      await Promise.all(
+        n.map(
+          (u) => M(s).update(u.id, { position: u.position, columnId: u.columnId })
+        )
+      );
+    },
+    onMutate: async ({ columnId: r }) => {
+      const o = h(r), n = ["kanban-cards", s, r, o];
+      return await S.cancelQueries({ queryKey: n }), {};
+    },
+    onSuccess: () => {
+    },
+    onError: (r, o, n) => {
+      var u;
+      (u = g.current) == null || u.call(g, r);
+    },
+    onSettled: (r, o, n) => {
+      const u = h(n.columnId);
+      S.invalidateQueries({ queryKey: ["kanban-cards", s, n.columnId, u] });
+    }
+  }), Mt = _(
+    async (r, o, n) => {
+      try {
+        await nt.mutateAsync({
+          cardId: r._id,
+          fromColumnId: o,
+          toColumnId: n,
+          position: void 0
+        });
+      } catch {
+      }
+    },
+    [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: 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()
+    };
+  }), [e, c]), A = Ae({
+    onCardMove: Mt,
+    onError: g.current,
+    columns: ft,
+    announceMove: (r, o, n) => {
+      console.log(
+        `Kanban: Moved "${r.title}" from ${o} to ${n}`
+      );
+    }
+  }), te = _(
+    (r) => {
+      var o, n;
+      return {
+        draggable: !0,
+        role: "option",
+        "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: A.handleDragEnd,
+        onKeyDown: (u) => {
+          if (!t) return;
+          const w = u.nativeEvent || u;
+          A.handleKeyDown(w, r);
+        }
+      };
+    },
+    [t, A]
+  ), ee = _(
+    (r) => ({
+      "data-column-id": r,
+      role: "listbox",
+      onDragOver: (o) => {
+        if (!t) return;
+        const n = o.nativeEvent || o;
+        A.handleDragOver(n, r);
+      },
+      onDrop: (o) => {
+        if (!t) return;
+        const n = o.nativeEvent || o;
+        A.handleDrop(n, r);
+      }
+    }),
+    [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"
+    });
+  }, [S]);
+  return _t(() => {
+    pt && g.current && g.current(pt);
+  }, [pt]), {
+    // Data
+    columns: ft,
+    totalCards: ie,
+    // Loading States
+    isLoading: ae,
+    isFetching: ne,
+    isUpdating: oe,
+    // Error Handling
+    error: pt,
+    // Card Operations (Flat Access)
+    createCard: At.mutateAsync,
+    updateCard: _(
+      async (r, o) => {
+        await bt.mutateAsync({ id: r, updates: o });
+      },
+      [bt]
+    ),
+    deleteCard: _(
+      async (r) => {
+        await Ct.mutateAsync(r);
+      },
+      [Ct]
+    ),
+    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 (!u)
+            throw new Error(`Card ${r} not found in any column`);
+        }
+        await nt.mutateAsync({ cardId: r, fromColumnId: u, toColumnId: o, position: n });
+      },
+      [nt, ft]
+    ),
+    reorderCards: _(
+      async (r, o) => {
+        await Dt.mutateAsync({ cardIds: r, columnId: o });
+      },
+      [Dt]
+    ),
+    // Search (Flat Access)
+    searchQuery: C.query,
+    setSearchQuery: re,
+    clearSearch: se,
+    // Filter (Simplified chainable API)
+    filter: V,
+    // Drag Drop (Flat Access)
+    isDragging: t ? A.isDragging : !1,
+    draggedCard: t ? A.draggedCard : null,
+    dragOverColumn: t ? A.dragOverColumn : null,
+    handleDragStart: t ? A.handleDragStart : () => {
+    },
+    handleDragOver: t ? A.handleDragOver : () => {
+    },
+    handleDrop: t ? A.handleDrop : () => {
+    },
+    handleDragEnd: t ? A.handleDragEnd : () => {
+    },
+    handleKeyDown: t ? A.handleKeyDown : () => {
+    },
+    // Prop Getters
+    getCardProps: t ? te : (r) => ({}),
+    getColumnProps: t ? ee : (r) => ({}),
+    // Load More (Per Column)
+    loadMore: _((r) => {
+      J((o) => ({
+        ...o,
+        [r]: (o[r] || 10) + 10
+      }));
+    }, []),
+    // Utilities
+    refetch: ue,
+    refresh: ce
+  };
+}
+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 a;
+}
+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 Be(a, e) {
+  if (a.cards.length === 0)
+    return 0;
+  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 s = a.cards[e - 1], t = a.cards[e];
+  return Math.floor((s.position + t.position) / 2);
+}
+function Xe(a, e) {
+  if (a.length === 0)
+    return 0;
+  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 s = a[e - 1], t = a[e];
+  return Math.floor((s.position + t.position) / 2);
+}
+function ze(a) {
+  return a.sort((e, s) => e.position - s.position).map((e, s) => ({
+    ...e,
+    position: s
+  }));
+}
+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 Ye(a, e) {
+  switch (e) {
+    case "list":
+      return a && Array.isArray(a.Data);
+    case "single":
+      return a && typeof a == "object";
+    case "create":
+      return a && typeof a._id == "string";
+    case "delete":
+      return a && a.status === "success";
+    default:
+      return !1;
+  }
+}
+export {
+  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
+};