@ram_28/kf-ai-sdk 1.0.10 → 1.0.12

package/dist/kanban.mjs

@@ -0,0 +1,694 @@
+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
+}) {
+  const [s, O] = G({
+    isDragging: !1,
+    draggedCard: null,
+    dragOverColumn: null,
+    dragOverPosition: null,
+    dragSourceColumn: null
+  }), q = k(null), _ = k(null), K = k(null), b = h(() => {
+    O({
+      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 };
+    }
+    return null;
+  }, [d]), P = h((u, o) => {
+    var g, m;
+    try {
+      const l = u.target, y = D(o.columnId);
+      if (!y)
+        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 = `
+        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(S), q.current = S, u.dataTransfer && u.dataTransfer.setDragImage(S, u.offsetX || 50, u.offsetY || 20), O({
+        isDragging: !0,
+        draggedCard: o,
+        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();
+    }
+  }, [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,
+      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))
+      try {
+        const g = s.draggedCard, m = s.dragSourceColumn, l = D(o), y = D(m);
+        if (!l || !y)
+          throw new Error("Target or source column not found");
+        if (m === o) {
+          b();
+          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"));
+      } finally {
+        b();
+      }
+  }, [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);
+      };
+      _.current = setTimeout(S, 100);
+    } else
+      _.current && (clearTimeout(_.current), _.current = null);
+  }, []), L = h((u, o) => {
+    if (!["ArrowLeft", "ArrowRight", "ArrowUp", "ArrowDown", "Enter", "Space", "Escape"].includes(u.key))
+      return;
+    u.preventDefault();
+    const g = Y(o._id);
+    if (!g) return;
+    const { column: m } = g, l = d.findIndex((y) => y._id === m._id);
+    try {
+      switch (u.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);
+          }
+          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);
+          }
+          break;
+        case "ArrowUp":
+          a == null || a(o, "current position", "position above");
+          break;
+        case "ArrowDown":
+          a == null || a(o, "current position", "position below");
+          break;
+        case "Enter":
+        case "Space":
+          a == null || a(o, m.title, "drag mode");
+          break;
+        case "Escape":
+          a == null || a(o, "drag mode", "cancelled");
+          break;
+      }
+    } catch (y) {
+      c == null || c(y instanceof Error ? y : 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
+    };
+  }, []), 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({
+        isDragging: !0,
+        draggedCard: l,
+        dragOverColumn: null,
+        dragOverPosition: null,
+        dragSourceColumn: y._id
+      }), a == null || a(l, y.title, "being moved");
+    }
+  }, [D, a]), p = h((u) => {
+    if (!s.isDragging || !s.draggedCard || !K.current) {
+      K.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);
+        }
+      }
+    } catch (o) {
+      c == null || c(o instanceof Error ? o : new Error("Touch drop failed"));
+    } finally {
+      K.current = null, b();
+    }
+  }, [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}`);
+  }, []);
+  return rt(() => () => {
+    _.current && clearTimeout(_.current), q.current && document.body.contains(q.current) && document.body.removeChild(q.current);
+  }, []), {
+    // State
+    isDragging: s.isDragging,
+    draggedCard: s.draggedCard,
+    dragOverColumn: s.dragOverColumn,
+    dragOverPosition: s.dragOverPosition,
+    dragSourceColumn: s.dragSourceColumn,
+    // Handlers
+    handleDragStart: P,
+    handleDragOver: z,
+    handleDrop: V,
+    handleDragEnd: C,
+    handleKeyDown: L,
+    handleTouchStart: I,
+    handleTouchMove: H,
+    handleTouchEnd: p,
+    // Utilities
+    announceMove: a || T,
+    reset: b
+  };
+}
+function Xt(i) {
+  var at, nt, it;
+  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 = {
+      LHSField: "columnId",
+      Operator: "EQ",
+      RHSValue: t,
+      RHSType: "Constant"
+    }, r = T.payload;
+    let n;
+    r ? r.Operator === "And" ? n = {
+      ...r,
+      Condition: [...r.Condition || [], e]
+    } : n = {
+      Operator: "And",
+      Condition: [r, e]
+    } : n = {
+      Operator: "And",
+      Condition: [e]
+    };
+    const f = {
+      Page: 1,
+      // Always page 1 due to expanding PageSize strategy
+      PageSize: z[t] || 10,
+      Filter: n
+    };
+    return P.field && P.direction ? f.Sort = [
+      { [String(P.field)]: P.direction === "asc" ? "ASC" : "DESC" },
+      { position: "ASC" }
+    ] : f.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);
+      return {
+        queryKey: ["kanban-cards", d, t.id, e],
+        queryFn: async () => {
+          try {
+            return await F(d).list(e);
+          } catch (r) {
+            throw r;
+          }
+        },
+        placeholderData: kt,
+        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],
+    queryFn: async () => {
+      try {
+        return await F(d).count(S);
+      } catch (t) {
+        throw C.current && C.current(t), t;
+      }
+    },
+    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;
+    },
+    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,
+          _created_at: /* @__PURE__ */ new Date(),
+          _modified_at: /* @__PURE__ */ new Date()
+        };
+        p.setQueryData(n, {
+          ...f,
+          Data: [...f.Data, E]
+        });
+      }
+      return { previousCards: f, queryKey: n };
+    },
+    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
+      });
+    },
+    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);
+    },
+    onSettled: (t, e, r) => {
+      const n = r.columnId, f = u(n);
+      p.invalidateQueries({ queryKey: ["kanban-cards", d, n, f] });
+    }
+  }), 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 });
+    },
+    onError: (t, e, r) => {
+      var n;
+      (n = C.current) == null || n.call(C, t);
+    },
+    onSettled: () => {
+      p.invalidateQueries({ queryKey: ["kanban-cards", d] });
+    }
+  }), 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);
+    },
+    onError: (t, e, r) => {
+      var n;
+      (n = C.current) == null || n.call(C, t);
+    },
+    onSettled: () => {
+      p.invalidateQueries({ queryKey: ["kanban-cards", d] });
+    }
+  }), 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 };
+    },
+    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,
+            _modified_at: /* @__PURE__ */ new Date()
+          }, Ot = {
+            ...N,
+            Data: [...N.Data, St].sort((tt, Kt) => tt.position - Kt.position)
+          };
+          p.setQueryData(A, M), p.setQueryData(X, Ot);
+        }
+      }
+      return {
+        previousFromData: E,
+        previousToData: N,
+        fromQueryKey: A,
+        toQueryKey: X,
+        fromColumnId: e,
+        toColumnId: r
+      };
+    },
+    onSuccess: async (t) => {
+      var e;
+      (e = $.current) == null || e.call(
+        $,
+        { _id: t.cardId },
+        t.fromColumnId,
+        t.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);
+    },
+    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] });
+    }
+  }), x = j({
+    mutationFn: async ({ cardIds: t, columnId: e }) => {
+      const r = t.map((n, f) => ({ id: n, position: f, columnId: e }));
+      await Promise.all(
+        r.map(
+          (n) => F(d).update(n.id, { position: n.position, columnId: n.columnId })
+        )
+      );
+    },
+    onMutate: async ({ columnId: t }) => {
+      const e = u(t), r = ["kanban-cards", d, t, e];
+      return await p.cancelQueries({ queryKey: r }), {};
+    },
+    onSuccess: () => {
+    },
+    onError: (t, e, r) => {
+      var n;
+      (n = C.current) == null || n.call(C, t);
+    },
+    onSettled: (t, e, r) => {
+      const n = u(r.columnId);
+      p.invalidateQueries({ queryKey: ["kanban-cards", d, r.columnId, n] });
+    }
+  }), gt = h(
+    async (t, e, r) => {
+      try {
+        await B.mutateAsync({
+          cardId: t._id,
+          fromColumnId: e,
+          toColumnId: r,
+          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) || [];
+    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),
+      _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) => {
+      console.log(
+        `Kanban: Moved "${t.title}" from ${e} to ${r}`
+      );
+    }
+  }), yt = h(
+    (t) => {
+      var e, r;
+      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);
+        },
+        onDragEnd: w.handleDragEnd,
+        onKeyDown: (n) => {
+          if (!a) return;
+          const f = n.nativeEvent || n;
+          w.handleKeyDown(f, t);
+        }
+      };
+    },
+    [a, w]
+  ), mt = h(
+    (t) => ({
+      "data-column-id": t,
+      role: "listbox",
+      onDragOver: (e) => {
+        if (!a) return;
+        const r = e.nativeEvent || e;
+        w.handleDragOver(r, t);
+      },
+      onDrop: (e) => {
+        if (!a) return;
+        const r = e.nativeEvent || e;
+        w.handleDrop(r, t);
+      }
+    }),
+    [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"
+    });
+  }, [p]);
+  return rt(() => {
+    W && C.current && C.current(W);
+  }, [W]), {
+    // Data
+    columns: R,
+    totalCards: ht,
+    // Loading States
+    isLoading: Ct,
+    isFetching: Dt,
+    isUpdating: wt,
+    // Error Handling
+    error: W,
+    // Card Operations (Flat Access)
+    createCard: et.mutateAsync,
+    updateCard: h(
+      async (t, e) => {
+        await Z.mutateAsync({ id: t, updates: e });
+      },
+      [Z]
+    ),
+    deleteCard: h(
+      async (t) => {
+        await v.mutateAsync(t);
+      },
+      [v]
+    ),
+    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;
+              break;
+            }
+          if (!n)
+            throw new Error(`Card ${t} not found in any column`);
+        }
+        await B.mutateAsync({ cardId: t, fromColumnId: n, toColumnId: e, position: r });
+      },
+      [B, R]
+    ),
+    reorderCards: h(
+      async (t, e) => {
+        await x.mutateAsync({ cardIds: t, columnId: e });
+      },
+      [x]
+    ),
+    // Search (Flat Access)
+    searchQuery: D.query,
+    setSearchQuery: ft,
+    clearSearch: pt,
+    // Filter (Simplified chainable API)
+    filter: T,
+    // Drag Drop (Flat Access)
+    isDragging: a ? w.isDragging : !1,
+    draggedCard: a ? w.draggedCard : null,
+    dragOverColumn: a ? w.dragOverColumn : null,
+    handleDragStart: a ? w.handleDragStart : () => {
+    },
+    handleDragOver: a ? w.handleDragOver : () => {
+    },
+    handleDrop: a ? w.handleDrop : () => {
+    },
+    handleDragEnd: a ? w.handleDragEnd : () => {
+    },
+    handleKeyDown: a ? w.handleKeyDown : () => {
+    },
+    // Prop Getters
+    getCardProps: a ? yt : (t) => ({}),
+    getColumnProps: a ? mt : (t) => ({}),
+    // Load More (Per Column)
+    loadMore: h((t) => {
+      V((e) => ({
+        ...e,
+        [t]: (e[t] || 10) + 10
+      }));
+    }, []),
+    // Utilities
+    refetch: _t,
+    refresh: bt
+  };
+}
+const $t = qt(null);
+function Yt() {
+  const i = Qt($t);
+  if (!i)
+    throw new Error(
+      "Kanban components must be used within a KanbanBoard component"
+    );
+  return i;
+}
+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 Nt(i, c) {
+  if (i.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);
+  }
+  const d = i.cards[c - 1], a = i.cards[c];
+  return Math.floor((d.position + a.position) / 2);
+}
+function jt(i, c) {
+  if (i.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);
+  }
+  const d = i[c - 1], a = i[c];
+  return Math.floor((d.position + a.position) / 2);
+}
+function zt(i) {
+  return i.sort((c, d) => c.position - d.position).map((c, d) => ({
+    ...c,
+    position: d
+  }));
+}
+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 Rt(i, c) {
+  switch (c) {
+    case "list":
+      return i && Array.isArray(i.Data);
+    case "single":
+      return i && typeof i == "object";
+    case "create":
+      return i && typeof i._id == "string";
+    case "delete":
+      return i && i.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
+};

package/dist/kanban.types.cjs

@@ -0,0 +1 @@
+"use strict";

package/dist/kanban.types.d.ts

@@ -0,0 +1,2 @@
+export type { UseKanbanOptionsType, UseKanbanReturnType, KanbanCardType, KanbanColumnType, ColumnConfigType, ColumnDefinitionType, BaseKanbanCardType, KanbanCardWithDataType, CardOperationsType, SearchOperationsType, DragDropStateType, DragDropHandlersType, DragDropManagerType, CardApiResponseType, ColumnApiResponseType, MoveCardRequestType, ReorderRequestType, BulkCardUpdateRequestType, BulkColumnUpdateRequestType, ValidationResultType, CardValidationContextType, ColumnValidationContextType, KanbanEventTypeType, KanbanEventType, ExtractCardTypeType, PartialByType, CreateCardInputType, CreateColumnInputType, } from './components/hooks/useKanban/types';
+//# sourceMappingURL=kanban.types.d.ts.map

package/dist/kanban.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"kanban.types.d.ts","sourceRoot":"","sources":["../sdk/kanban.types.ts"],"names":[],"mappings":"AAKA,YAAY,EAEV,oBAAoB,EACpB,mBAAmB,EAGnB,cAAc,EACd,gBAAgB,EAChB,gBAAgB,EAChB,oBAAoB,EACpB,kBAAkB,EAClB,sBAAsB,EAGtB,kBAAkB,EAClB,oBAAoB,EAGpB,iBAAiB,EACjB,oBAAoB,EACpB,mBAAmB,EAGnB,mBAAmB,EACnB,qBAAqB,EACrB,mBAAmB,EACnB,kBAAkB,EAClB,yBAAyB,EACzB,2BAA2B,EAG3B,oBAAoB,EACpB,yBAAyB,EACzB,2BAA2B,EAG3B,mBAAmB,EACnB,eAAe,EAGf,mBAAmB,EACnB,aAAa,EACb,mBAAmB,EACnB,qBAAqB,GACtB,MAAM,oCAAoC,CAAC"}

package/dist/kanban.types.mjs

@@ -0,0 +1 @@
+