impact-nova 2.5.13 → 2.5.15

package/dist/components/data/data-table/use-data-table-column-list-sync.js

@@ -1,128 +1,129 @@
-import { useState as M, useRef as h, useEffect as v, useCallback as c, useLayoutEffect as A } from "react";
-import { mergePartialOrderedColumnState as B } from "./data-table-column-state.js";
-import { afterSynchronousColumnApply as U, alignColumnTreePinMetadata as w, readGridColumnPinned as W, EXTERNAL_SYNC_DEBOUNCE_MS as tt } from "./data-table-column-apply.js";
-import { isColumnRuntimeStateGuardUpdating as D } from "./column-runtime-state-guard.js";
-import { resolveColumnTreeFromCacheOrGrid as et, peekColumnListSyncWouldSkip as rt, writeColumnTreeAuthorityCache as nt } from "./data-table-column-tree-cache.js";
-import { buildColumnStateFromAuthority as ot, toggleColumnsVisibility as ut, toggleColumnVisibility as lt, updateColumnPin as ct, toggleAllColumnsVisibility as st } from "./column-picker-authority.js";
-import { NESTED_LIST_ROOT_FROZEN_ID as q, NESTED_LIST_ROOT_SCROLLABLE_ID as at } from "../nested-list/nested-list-constants.js";
-import { buildAuthorityFlatShellItems as V, buildFlatColumnVirtualRowModel as it, applyFlatVirtualDropToAuthority as mt } from "./data-table-flat-column-virtual-rows.js";
-import { subscribeGridApiEvent as ft } from "../ag-grid-react/grid-api-event-subscription.js";
-import { subscribeColumnIndicatorSync as dt } from "../ag-grid-react/column-indicator-sync-bus.js";
-import { commitRebuiltColumnTreeFromGrid as ht } from "./reconcile-column-tree-from-grid.js";
-import { applyTreeColumnChanges as yt } from "./data-table-column-list-tree-apply.js";
-function z(e, p, b) {
+import { useState as W, useRef as p, useEffect as j, useCallback as f, useLayoutEffect as $ } from "react";
+import { mergePartialOrderedColumnState as q } from "./data-table-column-state.js";
+import { afterSynchronousColumnApply as k, normalizeColumnPinned as z, GRID_AUTO_UNPIN_WAIT_MS as A, alignColumnTreePinMetadata as V, EXTERNAL_SYNC_DEBOUNCE_MS as ee, readGridColumnPinned as ne } from "./data-table-column-apply.js";
+import { buildColumnStateFromTree as te } from "./build-column-state-from-tree.js";
+import { isColumnRuntimeStateGuardUpdating as g } from "./column-runtime-state-guard.js";
+import { computeColumnListSyncFingerprints as re } from "./data-table-column-list-sync.js";
+import { writeColumnTreeCache as B, resolveColumnTreeFromCacheOrGrid as oe, peekColumnListSyncWouldSkip as ue, readColumnTreeCache as se, isGridColumnSetDifferentFromCachedLeaves as ce } from "./data-table-column-tree-cache.js";
+import { patchColumnTreeIndicatorsFromGrid as le } from "./patch-column-tree-indicators-from-grid.js";
+import { subscribeGridApiEvent as X } from "../ag-grid-react/grid-api-event-subscription.js";
+import { subscribeColumnIndicatorSync as ae } from "../ag-grid-react/column-indicator-sync-bus.js";
+function Y(e, C, h) {
   return {
     layout: e.current,
-    visibility: p.current,
-    indicators: b.current
+    visibility: C.current,
+    indicators: h.current
   };
 }
-function Ct(e, p, b, a) {
-  p.current = e.layout, b.current = e.visibility, a.current = e.indicators;
+function w(e, C, h, c) {
+  C.current = e.layout, h.current = e.visibility, c.current = e.indicators;
 }
-function Gt({
+function Re({
   gridApi: e,
-  frozenColumnsLabel: p,
-  scrollableColumnsLabel: b,
-  isSyncActive: a = !0
+  frozenColumnsLabel: C,
+  scrollableColumnsLabel: h,
+  isSyncActive: c = !0
 }) {
-  const [T, y] = M([]), [I, E] = M(null), [O, X] = M("tree"), [Y, F] = M(!1), o = h(!1), Z = h(null), x = h(T), S = h(I), G = h(""), _ = h(""), L = h(""), P = h(a);
-  v(() => {
-    x.current = T;
-  }, [T]), v(() => {
-    S.current = I;
-  }, [I]);
-  const l = c(
+  const [R, F] = W([]), [H, M] = W(!1), l = p(!1), J = p(null), x = p(R), S = p(""), I = p(""), b = p(""), N = p(c);
+  j(() => {
+    x.current = R;
+  }, [R]);
+  const E = f(
     () => ({
-      frozenColumns: p,
-      scrollableColumns: b
+      frozenColumns: C,
+      scrollableColumns: h
     }),
-    [p, b]
-  ), f = c((t) => {
-    Ct(
-      t,
-      G,
-      _,
-      L
-    );
-  }, []), d = c(
-    (t, r) => {
+    [C, h]
+  ), y = f(
+    (n) => {
+      w(
+        re(n),
+        S,
+        I,
+        b
+      );
+    },
+    []
+  ), T = f(
+    (n) => {
       if (!e) {
-        r?.();
+        l.current = !1;
         return;
       }
-      const n = ot(t), u = B(
-        e.getColumnState(),
-        n
-      );
-      e.applyColumnState({ state: u, applyOrder: !0 }), U(() => {
-        const m = nt(e, t);
-        f(m), E(t), y(V(t, l())), r?.();
-      });
+      l.current = !1, B(e, n), y(n);
     },
-    [e, l, f]
-  ), k = c(() => {
-    if (!e) {
-      o.current = !1;
-      return;
-    }
-    o.current = !1;
-    const t = ht({
-      gridApi: e,
-      labels: l()
-    });
-    t && (y(t.tree), f(t.fingerprints));
-  }, [e, l, f]), i = c(() => {
-    if (!e || o.current || D(e))
+    [e, y]
+  ), a = f(() => {
+    if (!e || l.current || g(e))
       return;
-    const t = et({
+    const n = oe({
       gridApi: e,
-      labels: l(),
-      previousFingerprints: z(
-        G,
-        _,
-        L
+      labels: E(),
+      previousFingerprints: Y(
+        S,
+        I,
+        b
       )
     });
-    if (X(t.pickerMode), t.syncMode === "skip") {
-      f(t.fingerprints), t.pickerMode === "authority-flat" && t.authority && (E(t.authority), y(V(t.authority, l()))), F(!0);
+    if (n.syncMode === "skip" || !n.rootItems) {
+      n.syncMode !== "skip" && M(!0);
       return;
     }
-    if (t.pickerMode === "authority-flat" && t.authority) {
-      f(t.fingerprints), E(t.authority), y(
-        t.rootItems ?? V(t.authority, l())
-      ), F(!0);
-      return;
-    }
-    if (E(null), !t.rootItems) {
-      F(!0);
-      return;
-    }
-    f(t.fingerprints), y(t.rootItems), F(!0);
-  }, [e, l, f]);
-  A(() => {
-    const t = a && !P.current;
-    if (P.current = a, !e || !a) return;
-    const r = l(), n = z(
-      G,
-      _,
-      L
+    w(
+      n.fingerprints,
+      S,
+      I,
+      b
+    ), F(n.rootItems), M(!0);
+  }, [e, E]);
+  $(() => {
+    const n = c && !N.current;
+    if (N.current = c, !e || !c) return;
+    const t = E(), r = Y(
+      S,
+      I,
+      b
     );
-    !t && n.layout !== "" && rt({
+    if (!(!n && r.layout !== "" && ue({
       gridApi: e,
-      labels: r,
-      previousFingerprints: n
-    }) || queueMicrotask(() => {
-      i();
-    });
+      labels: t,
+      previousFingerprints: r
+    }))) {
+      if (n) {
+        queueMicrotask(() => {
+          const o = se(e, t);
+          if (o && !ce(
+            e,
+            o.leafColumnIds
+          )) {
+            const i = le(
+              o.items,
+              e
+            );
+            w(
+              B(e, i),
+              S,
+              I,
+              b
+            ), F(i), M(!0);
+            return;
+          }
+          a();
+        });
+        return;
+      }
+      queueMicrotask(() => {
+        a();
+      });
+    }
   }, [
     e,
-    a,
-    l,
-    i
-  ]), v(() => {
-    if (!e || !a) return;
-    const t = [
+    c,
+    E,
+    a
+  ]), j(() => {
+    if (!e || !c) return;
+    const n = [
       "columnVisible",
       "columnPinned",
       "columnMoved",
@@ -138,175 +139,120 @@ function Gt({
       "filterChanged",
       "newColumnsLoaded"
     ];
-    let r = null;
-    const n = () => {
-      o.current || D(e) || (r && clearTimeout(r), r = setTimeout(() => {
-        r = null, !(o.current || D(e) || e.isDestroyed()) && i();
-      }, tt));
-    }, u = t.map(
-      (s) => ft(e, s, () => {
-        n();
+    let t = null;
+    const r = () => {
+      l.current || g(e) || (t && clearTimeout(t), t = setTimeout(() => {
+        t = null, !(l.current || g(e) || e.isDestroyed()) && a();
+      }, ee));
+    }, o = n.map(
+      (m) => X(e, m, () => {
+        r();
       })
-    ), m = dt(() => {
-      n();
+    ), i = ae(() => {
+      r();
     });
     return () => {
-      r && clearTimeout(r), u.forEach((s) => s()), m();
+      t && clearTimeout(t), o.forEach((m) => m()), i();
     };
-  }, [e, a, i]);
-  const j = c(
-    (t) => {
-      const r = S.current;
-      if (!e || !r || t.length === 0)
+  }, [e, c, a]);
+  const v = f(
+    (n) => {
+      if (!e) return;
+      l.current = !0;
+      const t = te(n);
+      if (t.length === 0) {
+        k(() => {
+          T(n);
+        });
         return;
-      o.current = !0;
-      let n = r;
-      for (const u of t) {
-        if (u.itemId === q || u.itemId === at) {
-          const m = n.orderedColumnIds.filter((s) => {
-            const R = !!n.pinByColumnId.get(s);
-            return u.itemId === q ? R : !R;
-          });
-          n = ut(
-            n,
-            m,
-            u.checked
-          );
-          continue;
-        }
-        n = lt(
-          n,
-          u.itemId,
-          u.checked
-        );
       }
-      d(n, () => {
-        o.current = !1;
-      });
-    },
-    [e, d]
-  ), H = c(
-    (t, r, n) => {
-      const u = S.current;
-      if (!e || !u)
+      const r = e.getColumnState(), o = q(r, t), i = new Set(
+        r.filter((s) => z(s.pinned)).map((s) => s.colId)
+      ), m = o.filter(
+        (s) => z(s.pinned) && !i.has(s.colId)
+      ), P = new Set(m.map((s) => s.colId));
+      e.applyColumnState({ state: o, applyOrder: !0 });
+      const u = () => {
+        T(n);
+      };
+      if (P.size === 0) {
+        k(u);
         return;
-      const m = it(
-        u,
-        l()
-      ), s = mt(
-        u,
-        m,
-        {
-          draggedColumnId: t,
-          overId: r,
-          insertAfter: n
-        }
-      );
-      s && (o.current = !0, d(s, () => {
-        o.current = !1;
-      }));
-    },
-    [e, l, d]
-  ), g = c(
-    (t) => {
-      e && yt({
-        gridApi: e,
-        newItems: t,
-        releaseLockAndRebuildTreeFromGrid: k,
-        applyExternalGridSync: i,
-        setIsUpdating: (r) => {
-          o.current = r;
+      }
+      let O = !1, U = null, L = null;
+      L = X(e, "columnPinned", () => {
+        if (O || e.isDestroyed()) return;
+        const s = e.getColumnState();
+        if (m.filter((G) => {
+          const d = s.find((_) => _.colId === G.colId);
+          return d && !d.pinned;
+        }).length > 0) {
+          O = !0, U && clearTimeout(U), L?.();
+          const G = o.filter(
+            (d) => d.pinned && !P.has(d.colId)
+          );
+          if (G.length > 0) {
+            const d = G[0], _ = o.map(
+              (D) => D.colId === d.colId ? { ...D, pinned: null } : D
+            );
+            e.applyColumnState({ state: _, applyOrder: !0 });
+          }
+          k(() => {
+            l.current = !1, a();
+          });
         }
-      });
+      }), U = setTimeout(() => {
+        L?.(), O || u();
+      }, A);
     },
-    [e, k, i]
-  ), J = c(
-    (t) => {
-      g(w(t));
+    [e, T, a]
+  ), K = f(
+    (n) => {
+      v(V(n));
     },
-    [g]
-  ), K = c(
-    (t, r) => {
-      const n = w(t);
-      if (!r) {
-        g(n);
-        return;
-      }
-      y(n);
+    [v]
+  ), Q = f(
+    (n, t) => {
+      const r = V(n);
+      t || v(r), F(r), y(r);
     },
-    [g]
-  ), Q = c(
-    (t, r) => {
-      const n = S.current;
-      if (O === "authority-flat" && n && e) {
-        o.current = !0;
-        const R = ct(n, t, r);
-        d(R, () => {
-          if (W(e, t) !== r) {
-            o.current = !1, i();
-            return;
-          }
-          o.current = !1;
-        });
-        return;
-      }
-      const u = (R) => R.map((C) => C.id === t ? {
-        ...C,
+    [v, y]
+  ), Z = f(
+    (n, t) => {
+      const r = (P) => P.map((u) => u.id === n ? {
+        ...u,
         data: {
-          ...C.data,
-          pinned: r
+          ...u.data,
+          pinned: t
         }
-      } : C.children ? {
-        ...C,
-        children: u(C.children)
-      } : C), m = u(x.current);
-      if (y(m), !e) return;
-      o.current = !0;
-      const s = e.getColumnState(), N = B(s, [
-        { colId: t, pinned: r }
+      } : u.children ? {
+        ...u,
+        children: r(u.children)
+      } : u), o = r(x.current);
+      if (F(o), y(o), !e) return;
+      l.current = !0;
+      const i = e.getColumnState(), m = q(i, [
+        { colId: n, pinned: t }
       ]);
-      e.applyColumnState({ state: N, applyOrder: !0 }), U(() => {
-        if (W(e, t) !== r) {
-          o.current = !1, i();
+      e.applyColumnState({ state: m, applyOrder: !0 }), k(() => {
+        if (ne(e, n) !== t) {
+          l.current = !1, a();
           return;
         }
-        k();
-      });
-    },
-    [
-      e,
-      O,
-      d,
-      k,
-      i
-    ]
-  ), $ = c(
-    (t) => {
-      const r = S.current;
-      if (!e || !r)
-        return;
-      o.current = !0;
-      const n = st(r, t);
-      d(n, () => {
-        o.current = !1;
+        T(o);
       });
     },
-    [e, d]
+    [e, y, T, a]
   );
   return {
-    items: T,
-    columnPickerAuthority: I,
-    pickerMode: O,
-    isReady: Y,
-    listWrapperRef: Z,
-    handleChange: K,
-    handleSubmit: J,
-    handlePinChange: Q,
-    handleAuthorityItemToggle: j,
-    handleAuthorityVirtualDrop: H,
-    handleAuthoritySelectAll: $
+    items: R,
+    isReady: H,
+    listWrapperRef: J,
+    handleChange: Q,
+    handleSubmit: K,
+    handlePinChange: Z
   };
 }
 export {
-  Gt as useDataTableColumnListSync
+  Re as useDataTableColumnListSync
 };

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

@@ -1,29 +1,21 @@
 import { default as React } from 'react';
 import { useSensors, DragStartEvent, DragOverEvent, DragEndEvent } from '@dnd-kit/core';
-import { NestedListItem, NestedListDragMode, FlatVirtualRowModel } from '../nested-list.types';
+import { NestedListItem } from '../nested-list.types';
 interface NestedListContentProps {
     isListCollapsed: boolean;
     enableDragDrop: boolean;
-    dragMode?: NestedListDragMode;
     sensors: ReturnType<typeof useSensors>;
     items: {
         item: NestedListItem;
         level: number;
         indentLevel: number;
     }[];
-    flatVirtualRowModel?: FlatVirtualRowModel | null;
-    renderItem: (item: NestedListItem, level: number, indentLevel: number, context?: {
-        isAnyDragging?: boolean;
-    }) => React.ReactNode;
+    renderItem: (item: NestedListItem, level: number, indentLevel: number) => React.ReactNode;
     onDragStart: (event: DragStartEvent) => void;
     onDragOver: (event: DragOverEvent) => void;
     onDragEnd: (event: DragEndEvent) => void;
     onDragCancel: () => void;
     activeId: string | null;
-    onToggleCollapse: (itemId: string) => void;
-    toggleCollapseHandlerRef: React.MutableRefObject<(itemId: string) => void>;
-    collapsedItems?: Record<string, boolean>;
-    onVirtualDrop?: (activeId: string, overId: string, insertAfter: boolean) => void;
 }
 export declare const NestedListContent: React.FC<NestedListContentProps>;
 export {};