impact-nova 2.0.9 → 2.1.0-alpha.1

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

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

package/dist/components/data/nested-list/hooks/useNestedListHandlers.d.ts

@@ -0,0 +1,42 @@
+import { NestedListItem, SelectionMode } from '../nested-list.types';
+import { NormalizedItems } from './useNestedListState';
+/**
+ * Toggle item and children using normalized state (O(1) per item)
+ * Returns a Map of updates to apply
+ */
+declare function toggleItemAndChildrenNormalized(normalized: NormalizedItems, itemId: string, checked: boolean, selectionMode: SelectionMode): Map<string, Partial<NestedListItem>>;
+/**
+ * Update parent states based on children (O(depth) operation)
+ */
+declare function updateParentsNormalized(normalized: NormalizedItems, updates: Map<string, Partial<NestedListItem>>, targetItemId: string, selectionMode: SelectionMode): void;
+/**
+ * Apply normalized updates to tree state
+ */
+declare function applyUpdatesToTree(items: NestedListItem[], updates: Map<string, Partial<NestedListItem>>): NestedListItem[];
+interface UseNestedListHandlersProps {
+    setItems: React.Dispatch<React.SetStateAction<NestedListItem[]>>;
+    findItemById: (items: NestedListItem[], id: string) => NestedListItem | null;
+    updateParentsUpward: (items: NestedListItem[], targetItemId: string) => NestedListItem[];
+    onChange: (items: NestedListItem[]) => void;
+    onItemToggle?: (changes: Array<{
+        itemId: string;
+        checked: boolean;
+        category?: string;
+    }>) => void;
+    getCategory?: (item: NestedListItem) => string | undefined;
+    setCollapsedItems: React.Dispatch<React.SetStateAction<Record<string, boolean>>>;
+    setIsListCollapsed: React.Dispatch<React.SetStateAction<boolean>>;
+    setSelectedCategories: React.Dispatch<React.SetStateAction<Set<string>>>;
+    isUserChangeRef: React.MutableRefObject<boolean>;
+    selectionMode: SelectionMode;
+    isNormalized?: boolean;
+    normalizedState?: NormalizedItems;
+    batchUpdateItems?: (updates: Map<string, Partial<NestedListItem>>) => void;
+}
+export declare const useNestedListHandlers: ({ setItems, findItemById, updateParentsUpward, onChange, onItemToggle, getCategory, setCollapsedItems, setIsListCollapsed, setSelectedCategories, isUserChangeRef, selectionMode, isNormalized, normalizedState, batchUpdateItems, }: UseNestedListHandlersProps) => {
+    handleToggle: (itemId: string) => void;
+    handleToggleCollapse: (itemId: string) => void;
+    handleCollapseAll: () => void;
+    handleToggleCategory: (category: string) => void;
+};
+export { toggleItemAndChildrenNormalized, updateParentsNormalized, applyUpdatesToTree, };

package/dist/components/data/nested-list/hooks/useNestedListHandlers.js

@@ -0,0 +1,185 @@
+import { useCallback as _ } from "react";
+import { SelectionMode as D } from "../nested-list.types.js";
+const v = (l, t, r) => l.map((n) => n.id === t ? r(n) : n.children ? {
+  ...n,
+  children: v(n.children, t, r)
+} : n), q = (l, t, r, n) => {
+  const s = (c, e) => c.map((h) => ({
+    ...h,
+    checked: e,
+    children: h.children ? s(h.children, e) : void 0
+  }));
+  return v(l, t, (c) => {
+    const e = { ...c, checked: r };
+    return c.children && (n === D.INDEPENDENT ? e.children = [...c.children] : n === D.CASCADE_DOWN ? e.children = s(c.children, r) : n === D.CASCADE_UP_DOWN && (r ? e.children = [...c.children] : e.children = s(c.children, !1))), e;
+  });
+};
+function G(l, t, r, n) {
+  const s = /* @__PURE__ */ new Map();
+  s.set(t, { checked: r });
+  const c = (e) => {
+    const h = [];
+    return (l.childrenById.get(e) || []).forEach((i) => {
+      h.push(i), h.push(...c(i));
+    }), h;
+  };
+  return n === D.CASCADE_DOWN ? c(t).forEach((h) => {
+    s.set(h, { checked: r });
+  }) : n === D.CASCADE_UP_DOWN && !r && c(t).forEach((h) => {
+    s.set(h, { checked: !1 });
+  }), s;
+}
+function J(l, t, r, n) {
+  if (n === D.INDEPENDENT) return;
+  ((e) => {
+    const h = [];
+    let f = l.parentById.get(e) || null;
+    for (; f !== null; )
+      h.push(f), f = l.parentById.get(f) || null;
+    return h;
+  })(r).forEach((e) => {
+    const f = (l.childrenById.get(e) || []).map((o) => {
+      const y = t.get(o);
+      return y?.checked !== void 0 ? y.checked : l.byId.get(o)?.checked ?? !1;
+    });
+    let i;
+    n === D.CASCADE_UP_DOWN ? i = f.some((o) => o) : i = f.every((o) => o), t.set(e, { checked: i });
+  });
+}
+function B(l, t) {
+  return l.map((r) => {
+    const n = t.get(r.id), s = n ? { ...r, ...n } : r;
+    return r.children ? {
+      ...s,
+      children: B(r.children, t)
+    } : s;
+  });
+}
+const Q = ({
+  setItems: l,
+  findItemById: t,
+  updateParentsUpward: r,
+  onChange: n,
+  onItemToggle: s,
+  getCategory: c,
+  setCollapsedItems: e,
+  setIsListCollapsed: h,
+  setSelectedCategories: f,
+  isUserChangeRef: i,
+  selectionMode: o,
+  // Normalized state helpers
+  isNormalized: y = !1,
+  normalizedState: E,
+  batchUpdateItems: P
+}) => {
+  const W = _(
+    (d) => {
+      if (!E || !P) return;
+      i.current = !0;
+      const p = E.byId.get(d);
+      if (!p) return;
+      const u = !p.checked, a = G(
+        E,
+        d,
+        u,
+        o
+      );
+      J(E, a, d, o), P(a), l((T) => {
+        const w = B(T, a);
+        if (n(w), s) {
+          const k = [];
+          a.forEach((N, A) => {
+            if (N.checked !== void 0) {
+              const C = E.byId.get(A), O = C ? c ? c(C) : C.category : void 0;
+              k.push({ itemId: A, checked: N.checked, category: O });
+            }
+          }), s(k);
+        }
+        return w;
+      });
+    },
+    [
+      E,
+      P,
+      i,
+      o,
+      l,
+      n,
+      s,
+      c
+    ]
+  ), g = _(
+    (d) => {
+      i.current = !0, l((p) => {
+        const u = t(p, d), a = u ? !u.checked : !1, T = q(
+          p,
+          d,
+          a,
+          o
+        ), w = r(T, d);
+        if (n(w), s && u) {
+          const k = [];
+          if (o === D.INDEPENDENT) {
+            const N = c ? c(u) : u.category;
+            k.push({ itemId: u.id, checked: a, category: N });
+          } else {
+            const N = (A, C, O) => {
+              const b = c ? c(A) : A.category;
+              O.push({ itemId: A.id, checked: C, category: b }), A.children && A.children.forEach((j) => {
+                N(j, C, O);
+              });
+            };
+            N(u, a, k);
+          }
+          s(k);
+        }
+        return w;
+      });
+    },
+    [
+      t,
+      n,
+      s,
+      r,
+      c,
+      i,
+      l,
+      o
+    ]
+  ), x = _(
+    (d) => {
+      y && E && P ? W(d) : g(d);
+    },
+    [y, E, P, W, g]
+  ), F = _(
+    (d) => {
+      e((p) => ({
+        ...p,
+        [d]: !p[d]
+      }));
+    },
+    [e]
+  ), H = _(() => {
+    h((d) => !d);
+  }, [h]), S = _(
+    (d) => {
+      f((p) => {
+        const u = new Set(p);
+        return u.has(d) ? u.delete(d) : u.add(d), u;
+      });
+    },
+    [f]
+  );
+  return {
+    handleToggle: x,
+    handleToggleCollapse: F,
+    handleCollapseAll: H,
+    handleToggleCategory: S
+  };
+};
+export {
+  B as applyUpdatesToTree,
+  G as toggleItemAndChildrenNormalized,
+  J as updateParentsNormalized,
+  Q as useNestedListHandlers
+};

package/dist/components/data/nested-list/hooks/useNestedListSelectAll.d.ts

@@ -0,0 +1,17 @@
+import { NestedListItem } from '../nested-list.types';
+interface UseNestedListSelectAllProps {
+    findItemById: (items: NestedListItem[], id: string) => NestedListItem | null;
+    getCategory?: (item: NestedListItem) => string | undefined;
+}
+declare function updateVisibleItems(items: NestedListItem[], visibleItemIds: Set<string>, checked: boolean): NestedListItem[];
+export declare const useNestedListSelectAll: ({ findItemById, getCategory, }: UseNestedListSelectAllProps) => {
+    collectVisibleItemIds: (items: NestedListItem[]) => Set<string>;
+    findItemsNotSelected: (filtered: NestedListItem[], original: NestedListItem[], visibleItemIds: Set<string>) => Set<string>;
+    collectVisibleItemsForCallback: (items: NestedListItem[], visibleItemIds: Set<string>, checked: boolean) => Array<{
+        itemId: string;
+        checked: boolean;
+        category?: string;
+    }>;
+    updateVisibleItems: typeof updateVisibleItems;
+};
+export {};

package/dist/components/data/nested-list/hooks/useNestedListSelectAll.js

@@ -0,0 +1,62 @@
+import { useCallback as u } from "react";
+function f(d, r, i) {
+  return d.map((s) => {
+    const a = r.has(s.id), n = {
+      ...s,
+      checked: a ? i : s.checked
+    };
+    return s.children && (n.children = f(
+      s.children,
+      r,
+      i
+    )), n;
+  });
+}
+const S = ({
+  findItemById: d,
+  getCategory: r
+}) => {
+  const i = u(
+    (n) => {
+      const t = /* @__PURE__ */ new Set(), l = (o) => {
+        o.forEach((c) => {
+          t.add(c.id), c.children && l(c.children);
+        });
+      };
+      return l(n), t;
+    },
+    []
+  ), s = u(
+    (n, t, l) => {
+      const o = /* @__PURE__ */ new Set();
+      return n.forEach((c) => {
+        const h = d(t, c.id);
+        h?.children?.length && l.has(c.id) && !h.children.some((e) => l.has(e.id)) && o.add(c.id);
+      }), o;
+    },
+    [d]
+  ), a = u(
+    (n, t, l) => {
+      const o = [], c = (h) => {
+        h.forEach((e) => {
+          if (t.has(e.id)) {
+            const p = r ? r(e) : e.category;
+            o.push({ itemId: e.id, checked: l, category: p });
+          }
+          e.children && c(e.children);
+        });
+      };
+      return c(n), o;
+    },
+    [r]
+  );
+  return {
+    collectVisibleItemIds: i,
+    findItemsNotSelected: s,
+    collectVisibleItemsForCallback: a,
+    updateVisibleItems: f
+  };
+};
+export {
+  S as useNestedListSelectAll
+};

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

@@ -0,0 +1,74 @@
+import { NestedListItem } from '../nested-list.types';
+export interface NormalizedItems {
+    byId: Map<string, NestedListItem>;
+    childrenById: Map<string, string[]>;
+    parentById: Map<string, string | null>;
+    rootIds: string[];
+}
+interface UseNestedListStateProps {
+    initialItems: NestedListItem[];
+    enableApplyDiscard: boolean;
+    enableNormalizedState?: boolean;
+    initialCollapsedItems?: Record<string, boolean>;
+}
+/**
+ * Build normalized state from nested tree structure
+ * Creates Maps for O(1) lookups instead of O(n) tree traversal
+ */
+declare function normalizeItems(items: NestedListItem[]): NormalizedItems;
+/**
+ * Reconstruct tree from normalized state
+ */
+declare function denormalizeItems(normalized: NormalizedItems): NestedListItem[];
+/**
+ * Update a single item in normalized state (O(1) operation)
+ */
+declare function updateNormalizedItem(normalized: NormalizedItems, itemId: string, updates: Partial<NestedListItem>): NormalizedItems;
+/**
+ * Get item by ID (O(1) lookup)
+ */
+declare function getItemById(normalized: NormalizedItems, id: string): NestedListItem | null;
+/**
+ * Get all ancestor IDs for an item (for parent updates)
+ */
+declare function getAncestorIds(normalized: NormalizedItems, itemId: string): string[];
+/**
+ * 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, initialCollapsedItems, }: UseNestedListStateProps) => {
+    findItemByIdFast: (id: string) => NestedListItem | null;
+    updateItemFast: (itemId: string, updates: Partial<NestedListItem>) => void;
+    getAncestors: (itemId: string) => string[];
+    getDescendants: (itemId: string) => string[];
+    batchUpdateItems: (updates: Map<string, Partial<NestedListItem>>) => void;
+    syncToTreeState: () => void;
+    syncToNormalizedState: () => void;
+    isNormalized: boolean;
+    normalizedState: NormalizedItems;
+    setNormalizedState: import('react').Dispatch<import('react').SetStateAction<NormalizedItems>>;
+    savedNormalizedState: NormalizedItems;
+    setSavedNormalizedState: import('react').Dispatch<import('react').SetStateAction<NormalizedItems>>;
+    items: NestedListItem[];
+    setItems: import('react').Dispatch<import('react').SetStateAction<NestedListItem[]>>;
+    savedItems: NestedListItem[];
+    setSavedItems: import('react').Dispatch<import('react').SetStateAction<NestedListItem[]>>;
+    isUserChangeRef: {
+        current: boolean;
+    };
+    searchText: string;
+    setSearchText: import('react').Dispatch<import('react').SetStateAction<string>>;
+    collapsedItems: Record<string, boolean>;
+    setCollapsedItems: import('react').Dispatch<import('react').SetStateAction<Record<string, boolean>>>;
+    isListCollapsed: boolean;
+    setIsListCollapsed: import('react').Dispatch<import('react').SetStateAction<boolean>>;
+    activeId: string | null;
+    setActiveId: import('react').Dispatch<import('react').SetStateAction<string | null>>;
+    overId: string | null;
+    setOverId: import('react').Dispatch<import('react').SetStateAction<string | null>>;
+    selectedCategories: Set<string>;
+    setSelectedCategories: import('react').Dispatch<import('react').SetStateAction<Set<string>>>;
+    itemsToBlink: Set<string>;
+    setItemsToBlink: import('react').Dispatch<import('react').SetStateAction<Set<string>>>;
+};
+export { normalizeItems, denormalizeItems, updateNormalizedItem, getItemById, getAncestorIds, getDescendantIds, };

package/dist/components/data/nested-list/index.d.ts

@@ -0,0 +1,2 @@
+export * from './nested-list';
+export * from './nested-list.types';

package/dist/components/data/nested-list/index.js

@@ -0,0 +1,6 @@
+import { NestedList as t } from "./nested-list.js";
+import { SelectionMode as d } from "./nested-list.types.js";
+export {
+  t as NestedList,
+  d as SelectionMode
+};

package/dist/components/data/nested-list/nested-list.d.ts

@@ -0,0 +1,3 @@
+import { default as React } from 'react';
+import { NestedListProps } from './nested-list.types';
+export declare const NestedList: React.FC<NestedListProps>;