impact-nova 2.0.9 → 2.1.0-alpha.10

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

@@ -1,253 +0,0 @@
-import { useCallback as S } from "react";
-import { useSensors as Z, useSensor as V, MouseSensor as $, TouchSensor as E, closestCenter as p } from "@dnd-kit/core";
-import { arrayMove as A } 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 nn = (h) => {
-  const u = p(h), d = u.filter(
-    (x) => !y.has(x.id)
-  );
-  return d.length > 0 ? d : u;
-};
-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 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 rn = ({
-  items: h,
-  onDragEnd: u,
-  collapsedItems: d = {},
-  canDrag: x
-}) => {
-  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;
-    },
-    []
-  ), 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;
-    },
-    []
-  ), G = 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 (n !== -1 && l !== -1) {
-          const i = A(r.children, n, l);
-          return {
-            ...r,
-            children: i
-          };
-        }
-        return {
-          ...r,
-          children: G(r.children, e, o)
-        };
-      }
-      return r;
-    }),
-    []
-  ), 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 (n !== -1 && l !== -1) {
-        const i = A(
-          t,
-          l,
-          n
-        );
-        return u?.(e, r), i;
-      }
-      return null;
-    },
-    [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 = A(t, r, n);
-        return u?.(e, o), l;
-      }
-      return null;
-    },
-    [u]
-  ), z = S(
-    (t, e, o) => {
-      const r = G(t, e, o);
-      return u?.(e, o), r;
-    },
-    [G, u]
-  ), N = 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, w = f && R && !M && r, g = (s) => {
-        for (let c = 0; c < s.length; c++) {
-          if (s[c].id === o)
-            if (w) {
-              const L = {
-                ...s[c],
-                children: [n, ...s[c].children || []]
-              }, a = [...s];
-              return a[c] = L, { nodes: a, inserted: !0 };
-            } else {
-              const L = [...s], a = r ? c + 1 : c;
-              return L.splice(a, 0, n), { nodes: L, 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: s, inserted: !1 };
-      }, P = l(t), { nodes: O, inserted: Y } = g(P);
-      return Y ? (u?.(e, o), O) : null;
-    },
-    [u, d]
-  ), _ = 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 u?.(e, o), l;
-    },
-    [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, l, f);
-        const R = C(n, l), M = C(n, i), w = T(n, l), g = T(n, i);
-        if (y.has(i) && R !== null && R > 0)
-          return _(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 && w !== 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 N(n, l, i, H) || n;
-          }
-          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 N(n, l, i, c) || n;
-        }
-        return R === 0 ? k(n, l, i) || n : z(n, l, i);
-      });
-    },
-    [
-      C,
-      T,
-      B,
-      k,
-      z,
-      N,
-      _,
-      x
-    ]
-  ), K = S(
-    (t, e) => {
-      if (!t || !e || t === e)
-        return !1;
-      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;
-    },
-    [h, C, x]
-  );
-  return {
-    sensors: q,
-    handleDragEnd: J,
-    isValidDrop: K,
-    findItemLevel: C,
-    findParentId: T
-  };
-};
-export {
-  nn as customCollisionDetection,
-  rn as useNestedListDragDrop
-};

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

@@ -1,42 +0,0 @@
-import { NestedListItem, SelectionMode } from '../../types/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/ui/nested-list/hooks/useNestedListHandlers.js

@@ -1,185 +0,0 @@
-import { useCallback as _ } from "react";
-import { SelectionMode as D } from "../../types/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/ui/nested-list/hooks/useNestedListSelectAll.d.ts

@@ -1,16 +0,0 @@
-import { NestedListItem } from '../../types/nested-list.types';
-interface UseNestedListSelectAllProps {
-    findItemById: (items: NestedListItem[], id: string) => NestedListItem | null;
-    getCategory?: (item: NestedListItem) => string | undefined;
-}
-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: (items: NestedListItem[], visibleItemIds: Set<string>, checked: boolean) => NestedListItem[];
-};
-export {};

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

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

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

@@ -1,74 +0,0 @@
-import { NestedListItem } from '../../types/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;
-    setActiveId: import('react').Dispatch<import('react').SetStateAction<string>>;
-    overId: string;
-    setOverId: import('react').Dispatch<import('react').SetStateAction<string>>;
-    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/ui/nested-list/index.d.ts

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

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

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

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

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