impact-nova 1.7.29 → 1.7.31

package/dist/components/ui/nested-list/hooks/useNestedListDragDrop.js

@@ -1,239 +1,253 @@
 import { useCallback as S } from "react";
-import { useSensors as K, useSensor as H, MouseSensor as Q, TouchSensor as U, closestCenter as Z } from "@dnd-kit/core";
-import { arrayMove as _ } from "@dnd-kit/sortable";
-const V = "droppable-", b = /* @__PURE__ */ new Set(["root-frozen", "root-scrollable"]);
-function W(a) {
-  if (a.startsWith(V)) {
-    const s = a.slice(V.length);
-    if (b.has(s)) return s;
+import { useSensors as Z, useSensor as V, MouseSensor as $, TouchSensor as E, closestCenter as p } from "@dnd-kit/core";
+import { arrayMove as w } from "@dnd-kit/sortable";
+const W = "droppable-", y = /* @__PURE__ */ new Set(["root-frozen", "root-scrollable"]);
+function X(h) {
+  if (h.startsWith(W)) {
+    const u = h.slice(W.length);
+    if (y.has(u)) return u;
   }
   return null;
 }
-const m = (a) => {
-  const s = Z(a), f = s.filter(
-    (h) => !b.has(h.id)
+const nn = (h) => {
+  const u = p(h), d = u.filter(
+    (x) => !y.has(x.id)
   );
-  return f.length > 0 ? f : s;
+  return d.length > 0 ? d : u;
 };
-function F(a, s) {
-  for (const f of a) {
-    if (f.id === s) return f;
-    if (f.children) {
-      const h = F(f.children, s);
-      if (h) return h;
+function F(h, u) {
+  for (const d of h) {
+    if (d.id === u) return d;
+    if (d.children) {
+      const x = F(d.children, u);
+      if (x) return x;
     }
   }
 }
-function X(a, s) {
-  for (const f of a) {
-    if (f.id === s) return null;
-    if (f.children && F(f.children, s))
-      return f.id;
+function j(h, u) {
+  for (const d of h) {
+    if (d.id === u) return null;
+    if (d.children && F(d.children, u))
+      return d.id;
   }
   return null;
 }
-const I = ({
-  items: a,
-  onDragEnd: s
+const rn = ({
+  items: h,
+  onDragEnd: u,
+  collapsedItems: d = {},
+  canDrag: x
 }) => {
-  const f = K(
-    H(Q),
-    H(U)
-  ), h = S(
-    (i, e, o = 0) => {
-      for (const n of i) {
-        if (n.id === e) return o;
-        if (n.children) {
-          const r = h(n.children, e, o + 1);
-          if (r !== null) return r;
+  const q = Z(
+    V($),
+    V(E)
+  ), C = S(
+    (t, e, o = 0) => {
+      for (const r of t) {
+        if (r.id === e) return o;
+        if (r.children) {
+          const n = C(r.children, e, o + 1);
+          if (n !== null) return n;
         }
       }
       return null;
     },
     []
-  ), R = S(
-    (i, e, o = null) => {
-      for (const n of i) {
-        if (n.id === e) return o;
-        if (n.children) {
-          const r = R(n.children, e, n.id);
-          if (r !== null) return r;
+  ), T = S(
+    (t, e, o = null) => {
+      for (const r of t) {
+        if (r.id === e) return o;
+        if (r.children) {
+          const n = T(r.children, e, r.id);
+          if (n !== null) return n;
         }
       }
       return null;
     },
     []
-  ), y = S(
-    (i, e, o) => i.map((n) => {
-      if (n.children && n.children.length > 0) {
-        const r = n.children.findIndex(
-          (t) => t.id === e
-        ), c = n.children.findIndex(
-          (t) => t.id === o
+  ), A = S(
+    (t, e, o) => t.map((r) => {
+      if (r.children && r.children.length > 0) {
+        const n = r.children.findIndex(
+          (i) => i.id === e
+        ), l = r.children.findIndex(
+          (i) => i.id === o
         );
-        if (r !== -1 && c !== -1) {
-          const t = _(n.children, r, c);
+        if (n !== -1 && l !== -1) {
+          const i = w(r.children, n, l);
           return {
-            ...n,
-            children: t
+            ...r,
+            children: i
           };
         }
         return {
-          ...n,
-          children: y(n.children, e, o)
+          ...r,
+          children: A(r.children, e, o)
         };
       }
-      return n;
+      return r;
     }),
     []
-  ), w = S(
-    (i, e, o) => {
-      const n = R(i, o);
-      if (!n) return null;
-      const r = i.findIndex(
-        (t) => t.id === n
-      ), c = i.findIndex(
-        (t) => t.id === e
+  ), B = S(
+    (t, e, o) => {
+      const r = T(t, o);
+      if (!r) return null;
+      const n = t.findIndex(
+        (i) => i.id === r
+      ), l = t.findIndex(
+        (i) => i.id === e
       );
-      if (r !== -1 && c !== -1) {
-        const t = _(
-          i,
-          c,
-          r
+      if (n !== -1 && l !== -1) {
+        const i = w(
+          t,
+          l,
+          n
         );
-        return s?.(e, n), t;
+        return u?.(e, r), i;
       }
       return null;
     },
-    [R, s]
-  ), B = S(
-    (i, e, o) => {
-      const n = i.findIndex((c) => c.id === e), r = i.findIndex((c) => c.id === o);
-      if (n !== -1 && r !== -1) {
-        const c = _(i, n, r);
-        return s?.(e, o), c;
+    [T, u]
+  ), k = S(
+    (t, e, o) => {
+      const r = t.findIndex((l) => l.id === e), n = t.findIndex((l) => l.id === o);
+      if (r !== -1 && n !== -1) {
+        const l = w(t, r, n);
+        return u?.(e, o), l;
       }
       return null;
     },
-    [s]
-  ), k = S(
-    (i, e, o) => {
-      const n = y(i, e, o);
-      return s?.(e, o), n;
+    [u]
+  ), z = S(
+    (t, e, o) => {
+      const r = A(t, e, o);
+      return u?.(e, o), r;
     },
-    [y, s]
-  ), A = S(
-    (i, e, o, n = !1) => {
-      const r = F(i, e);
-      if (!r) return null;
-      const c = (u) => u.filter((l) => l.id !== e).map(
-        (l) => l.children ? { ...l, children: c(l.children) } : l
-      ).filter((l) => !(l.children && l.children.length === 0 && l.category === "group")), t = F(i, o), d = !r.children || r.children.length === 0, C = t?.children && t.children.length > 0, T = d && C, M = (u) => {
-        for (let l = 0; l < u.length; l++) {
-          if (u[l].id === o)
-            if (T) {
-              const x = {
-                ...u[l],
-                children: [r, ...u[l].children || []]
-              }, P = [...u];
-              return P[l] = x, { nodes: P, inserted: !0 };
+    [A, u]
+  ), G = S(
+    (t, e, o, r = !1) => {
+      const n = F(t, e);
+      if (!n) return null;
+      const l = (s) => s.filter((c) => c.id !== e).map(
+        (c) => c.children ? { ...c, children: l(c.children) } : c
+      ).filter((c) => !(c.children && c.children.length === 0 && c.category === "group")), i = F(t, o), f = !n.children || n.children.length === 0, R = i?.children && i.children.length > 0, M = d[o] === !0, _ = f && R && !M, g = (s) => {
+        for (let c = 0; c < s.length; c++) {
+          if (s[c].id === o)
+            if (_) {
+              const L = {
+                ...s[c],
+                children: [n, ...s[c].children || []]
+              }, a = [...s];
+              return a[c] = L, { nodes: a, inserted: !0 };
             } else {
-              const x = [...u], P = n ? l + 1 : l;
-              return x.splice(P, 0, r), { nodes: x, inserted: !0 };
+              const L = [...s], a = r ? c + 1 : c;
+              return L.splice(a, 0, n), { nodes: L, inserted: !0 };
             }
-          if (u[l].children) {
-            const x = M(u[l].children);
-            if (x.inserted) {
-              const P = [...u];
-              return P[l] = { ...u[l], children: x.nodes }, { nodes: P, inserted: !0 };
+          if (s[c].children) {
+            const L = g(s[c].children);
+            if (L.inserted) {
+              const a = [...s];
+              return a[c] = { ...s[c], children: L.nodes }, { nodes: a, inserted: !0 };
             }
           }
         }
-        return { nodes: u, inserted: !1 };
-      }, N = c(i), { nodes: g, inserted: Y } = M(N);
-      return Y ? (s?.(e, o), g) : null;
+        return { nodes: s, inserted: !1 };
+      }, P = l(t), { nodes: O, inserted: Y } = g(P);
+      return Y ? (u?.(e, o), O) : null;
     },
-    [s]
-  ), G = S(
-    (i, e, o) => {
-      const n = F(i, e);
-      if (!n) return i;
-      const r = (t) => t.filter((d) => d.id !== e).map(
-        (d) => d.children ? { ...d, children: r(d.children) } : d
-      ), c = i.map((t) => {
-        let d = t.children ? r(t.children) : [];
-        return t.id === o && (d = [n, ...d]), { ...t, children: d };
+    [u, d]
+  ), N = S(
+    (t, e, o) => {
+      const r = F(t, e);
+      if (!r) return t;
+      const n = (i) => i.filter((f) => f.id !== e).map(
+        (f) => f.children ? { ...f, children: n(f.children) } : f
+      ), l = t.map((i) => {
+        let f = i.children ? n(i.children) : [];
+        return i.id === o && (f = [r, ...f]), { ...i, children: f };
       });
-      return s?.(e, o), c;
+      return u?.(e, o), l;
     },
-    [s]
-  ), j = S(
-    (i, e) => {
-      const { active: o, over: n } = i;
-      !n || o.id === n.id || e((r) => {
-        const c = o.id, t = n.id, d = W(t);
-        if (d)
-          return G(r, c, d);
-        const C = h(r, c), T = h(r, t), M = R(r, c), N = R(r, t);
-        if (b.has(t) && C !== null && C > 0)
-          return G(r, c, t);
-        if (C === 0 && T !== null && T > 0)
-          return w(
-            r,
-            c,
-            t
-          ) || r;
-        if (C === null || T === null)
-          return r;
-        if (C > 0 && T > 0 && M !== N) {
-          const g = X(r, c), Y = X(r, t);
-          if (g && Y && g !== Y) {
-            const L = o.rect.current.translated, O = n.rect;
-            let z = !1;
-            if (L && O) {
-              const D = L.top + L.height / 2, J = O.top + O.height / 2;
-              z = D > J;
+    [u]
+  ), J = S(
+    (t, e) => {
+      const { active: o, over: r } = t;
+      !r || o.id === r.id || e((n) => {
+        const l = o.id, i = r.id;
+        if (x) {
+          const P = F(n, l), O = C(n, l);
+          if (P && O !== null && !x(P, O))
+            return n;
+        }
+        const f = X(i);
+        if (f)
+          return N(n, l, f);
+        const R = C(n, l), M = C(n, i), _ = T(n, l), g = T(n, i);
+        if (y.has(i) && R !== null && R > 0)
+          return N(n, l, i);
+        if (R === 0 && M !== null && M > 0)
+          return B(
+            n,
+            l,
+            i
+          ) || n;
+        if (R === null || M === null)
+          return n;
+        if (R > 0 && M > 0 && _ !== g) {
+          const P = j(n, l), O = j(n, i);
+          if (P && O && P !== O) {
+            const a = o.rect.current.translated, b = r.rect;
+            let H = !1;
+            if (a && b) {
+              const Q = a.top + a.height / 2, U = b.top + b.height / 2;
+              H = Q > U;
             }
-            return A(r, c, t, z) || r;
+            return G(n, l, i, H) || n;
           }
-          const u = o.rect.current.translated, l = n.rect;
-          let x = !1;
-          if (u && l) {
-            const L = u.top + u.height / 2, O = l.top + l.height / 2;
-            x = L > O;
+          const Y = o.rect.current.translated, s = r.rect;
+          let c = !1;
+          if (Y && s) {
+            const a = Y.top + Y.height / 2, b = s.top + s.height / 2;
+            c = a > b;
           }
-          return A(r, c, t, x) || r;
+          return G(n, l, i, c) || n;
         }
-        return C === 0 ? B(r, c, t) || r : k(r, c, t);
+        return R === 0 ? k(n, l, i) || n : z(n, l, i);
       });
     },
     [
-      h,
-      R,
-      w,
+      C,
+      T,
       B,
       k,
-      A,
-      G
+      z,
+      G,
+      N,
+      x
     ]
-  ), q = S(
-    (i, e) => {
-      if (!i || !e || i === e)
+  ), K = S(
+    (t, e) => {
+      if (!t || !e || t === e)
         return !1;
-      const o = i ? h(a, i) : null, n = e ? h(a, e) : null;
-      return W(e) !== null || b.has(e) ? !0 : o === null || n === null ? !1 : o === 0 && n > 0 || o === n || o > 0 && n > 0;
+      if (x) {
+        const n = F(h, t), l = C(h, t);
+        if (n && l !== null && !x(n, l))
+          return !1;
+      }
+      const o = t ? C(h, t) : null, r = e ? C(h, e) : null;
+      return X(e) !== null || y.has(e) ? !0 : o === null || r === null ? !1 : o === 0 && r > 0 || o === r || o > 0 && r > 0;
     },
-    [a, h]
+    [h, C, x]
   );
   return {
-    sensors: f,
-    handleDragEnd: j,
-    isValidDrop: q,
-    findItemLevel: h,
-    findParentId: R
+    sensors: q,
+    handleDragEnd: J,
+    isValidDrop: K,
+    findItemLevel: C,
+    findParentId: T
   };
 };
 export {
-  m as customCollisionDetection,
-  I as useNestedListDragDrop
+  nn as customCollisionDetection,
+  rn as useNestedListDragDrop
 };

package/dist/components/ui/nested-list/hooks/useNestedListState.d.ts

@@ -9,6 +9,7 @@ interface UseNestedListStateProps {
     initialItems: NestedListItem[];
     enableApplyDiscard: boolean;
     enableNormalizedState?: boolean;
+    initialCollapsedItems?: Record<string, boolean>;
 }
 /**
  * Build normalized state from nested tree structure
@@ -35,7 +36,7 @@ declare function getAncestorIds(normalized: NormalizedItems, itemId: string): st
  * Get all descendant IDs for an item (for cascade operations)
  */
 declare function getDescendantIds(normalized: NormalizedItems, itemId: string): string[];
-export declare const useNestedListState: ({ initialItems, enableApplyDiscard, enableNormalizedState, }: UseNestedListStateProps) => {
+export declare const useNestedListState: ({ initialItems, enableApplyDiscard, enableNormalizedState, initialCollapsedItems, }: UseNestedListStateProps) => {
     findItemByIdFast: (id: string) => NestedListItem | null;
     updateItemFast: (itemId: string, updates: Partial<NestedListItem>) => void;
     getAncestors: (itemId: string) => string[];