impact-nova 2.5.12 → 2.5.13

package/dist/components/data/data-table/patch-column-tree-indicators-from-grid.d.ts

@@ -1,3 +1,8 @@
 import { GridApi } from 'ag-grid-community';
 import { NestedListItem } from '../nested-list/nested-list.types';
+export interface ColumnIndicatorMaps {
+    sortAppliedByColumnId: Map<string, boolean>;
+    filterAppliedByColumnId: Map<string, boolean>;
+}
+export declare function buildColumnIndicatorMapsFromGrid(gridApi: GridApi): ColumnIndicatorMaps;
 export declare function patchColumnTreeIndicatorsFromGrid(rootItems: NestedListItem[], gridApi: GridApi): NestedListItem[];

package/dist/components/data/data-table/patch-column-tree-indicators-from-grid.js

@@ -1,24 +1,41 @@
-function h(n, c) {
-  const e = c.getGridOption("context"), a = typeof e?.activeSearchColumnId == "string" ? e.activeSearchColumnId : null, o = new Map(
-    c.getColumnState().map((r) => [r.colId, r])
-  ), i = (r) => r.map((t) => {
+function p(l) {
+  const o = l.getGridOption("context"), r = typeof o?.activeSearchColumnId == "string" ? o.activeSearchColumnId : null, s = /* @__PURE__ */ new Map();
+  for (const n of l.getColumnState())
+    s.set(n.colId, !!n.sort);
+  const a = /* @__PURE__ */ new Map(), u = l.getAllGridColumns?.() ?? l.getColumns?.() ?? [];
+  for (const n of u) {
+    const c = n.getColId();
+    a.set(
+      c,
+      n.isFilterActive() === !0 || r === c
+    );
+  }
+  return { sortAppliedByColumnId: s, filterAppliedByColumnId: a };
+}
+function I(l, o) {
+  const r = o.getGridOption("context"), s = typeof r?.activeSearchColumnId == "string" ? r.activeSearchColumnId : null, a = new Map(
+    o.getColumnState().map((e) => [e.colId, e])
+  ), u = o.getAllGridColumns?.() ?? o.getColumns?.() ?? [], n = new Map(
+    u.map((e) => [e.getColId(), e])
+  ), c = (e) => e.map((t) => {
     if ((t.category === "group" || t.children && t.children.length > 0) && t.children)
       return {
         ...t,
-        children: i(t.children)
+        children: c(t.children)
       };
-    const l = c.getColumn(t.id), s = o.get(t.id), u = t.data;
+    const i = n.get(t.id), m = a.get(t.id), d = t.data;
     return {
       ...t,
       data: {
-        ...u,
-        hasSortApplied: !!s?.sort,
-        hasFilterApplied: l?.isFilterActive() === !0 || a === t.id
+        ...d,
+        hasSortApplied: !!m?.sort,
+        hasFilterApplied: i?.isFilterActive() === !0 || s === t.id
       }
     };
   });
-  return i(n);
+  return c(l);
 }
 export {
-  h as patchColumnTreeIndicatorsFromGrid
+  p as buildColumnIndicatorMapsFromGrid,
+  I as patchColumnTreeIndicatorsFromGrid
 };

package/dist/components/data/data-table/reconcile-column-tree-from-grid.d.ts

@@ -0,0 +1,12 @@
+import { GridApi } from 'ag-grid-community';
+import { NestedListItem } from '../nested-list/nested-list.types';
+import { ColumnListSyncFingerprints } from './data-table-column-list-sync';
+import { BuildColumnTreeLabels } from './build-column-tree-from-grid';
+export declare function rebuildColumnTreeFromGrid(gridApi: GridApi, labels: BuildColumnTreeLabels): NestedListItem[] | null;
+export declare function commitRebuiltColumnTreeFromGrid(options: {
+    gridApi: GridApi;
+    labels: BuildColumnTreeLabels;
+}): {
+    tree: NestedListItem[];
+    fingerprints: ColumnListSyncFingerprints;
+} | null;

package/dist/components/data/data-table/reconcile-column-tree-from-grid.js

@@ -0,0 +1,12 @@
+import { buildColumnTreeFromGrid as m } from "./build-column-tree-from-grid.js";
+import { writeColumnTreeCache as t } from "./data-table-column-tree-cache.js";
+function l(r) {
+  const e = m(r.gridApi, r.labels);
+  if (!e)
+    return null;
+  const i = t(r.gridApi, e);
+  return { tree: e, fingerprints: i };
+}
+export {
+  l as commitRebuiltColumnTreeFromGrid
+};

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

@@ -1,5 +1,7 @@
 import { GridApi } from 'ag-grid-community';
 import { NestedListItem } from '../nested-list/nested-list.types';
+import { ColumnPickerMode } from './data-table-column-tree-cache';
+import { ColumnPickerAuthority } from './column-picker-authority';
 export interface UseDataTableColumnListSyncOptions {
     gridApi: GridApi | null;
     frozenColumnsLabel: string;
@@ -8,9 +10,17 @@ export interface UseDataTableColumnListSyncOptions {
 }
 export declare function useDataTableColumnListSync({ gridApi, frozenColumnsLabel, scrollableColumnsLabel, isSyncActive, }: UseDataTableColumnListSyncOptions): {
     items: NestedListItem[];
+    columnPickerAuthority: ColumnPickerAuthority | null;
+    pickerMode: ColumnPickerMode;
     isReady: boolean;
     listWrapperRef: import('react').RefObject<HTMLDivElement | null>;
     handleChange: (currentItems: NestedListItem[], enableApplyDiscard: boolean) => void;
     handleSubmit: (finalItems: NestedListItem[]) => void;
     handlePinChange: (itemId: string, newPinned: "left" | "right" | null) => void;
+    handleAuthorityItemToggle: (toggleChanges: Array<{
+        itemId: string;
+        checked: boolean;
+    }>) => void;
+    handleAuthorityVirtualDrop: (activeId: string, overId: string, insertAfter: boolean) => void;
+    handleAuthoritySelectAll: (shouldSelectAll: boolean) => void;
 };

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

@@ -1,129 +1,128 @@
-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) {
+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) {
   return {
     layout: e.current,
-    visibility: C.current,
-    indicators: h.current
+    visibility: p.current,
+    indicators: b.current
   };
 }
-function w(e, C, h, c) {
-  C.current = e.layout, h.current = e.visibility, c.current = e.indicators;
+function Ct(e, p, b, a) {
+  p.current = e.layout, b.current = e.visibility, a.current = e.indicators;
 }
-function Re({
+function Gt({
   gridApi: e,
-  frozenColumnsLabel: C,
-  scrollableColumnsLabel: h,
-  isSyncActive: c = !0
+  frozenColumnsLabel: p,
+  scrollableColumnsLabel: b,
+  isSyncActive: a = !0
 }) {
-  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(
+  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(
     () => ({
-      frozenColumns: C,
-      scrollableColumns: h
+      frozenColumns: p,
+      scrollableColumns: b
     }),
-    [C, h]
-  ), y = f(
-    (n) => {
-      w(
-        re(n),
-        S,
-        I,
-        b
-      );
-    },
-    []
-  ), T = f(
-    (n) => {
+    [p, b]
+  ), f = c((t) => {
+    Ct(
+      t,
+      G,
+      _,
+      L
+    );
+  }, []), d = c(
+    (t, r) => {
       if (!e) {
-        l.current = !1;
+        r?.();
         return;
       }
-      l.current = !1, B(e, n), y(n);
+      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?.();
+      });
     },
-    [e, y]
-  ), a = f(() => {
-    if (!e || l.current || g(e))
+    [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))
       return;
-    const n = oe({
+    const t = et({
       gridApi: e,
-      labels: E(),
-      previousFingerprints: Y(
-        S,
-        I,
-        b
+      labels: l(),
+      previousFingerprints: z(
+        G,
+        _,
+        L
       )
     });
-    if (n.syncMode === "skip" || !n.rootItems) {
-      n.syncMode !== "skip" && M(!0);
+    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);
       return;
     }
-    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
+    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
     );
-    if (!(!n && r.layout !== "" && ue({
+    !t && n.layout !== "" && rt({
       gridApi: e,
-      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();
-      });
-    }
+      labels: r,
+      previousFingerprints: n
+    }) || queueMicrotask(() => {
+      i();
+    });
   }, [
     e,
-    c,
-    E,
-    a
-  ]), j(() => {
-    if (!e || !c) return;
-    const n = [
+    a,
+    l,
+    i
+  ]), v(() => {
+    if (!e || !a) return;
+    const t = [
       "columnVisible",
       "columnPinned",
       "columnMoved",
@@ -139,120 +138,175 @@ function Re({
       "filterChanged",
       "newColumnsLoaded"
     ];
-    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();
+    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();
       })
-    ), i = ae(() => {
-      r();
+    ), m = dt(() => {
+      n();
     });
     return () => {
-      t && clearTimeout(t), o.forEach((m) => m()), i();
+      r && clearTimeout(r), u.forEach((s) => s()), m();
     };
-  }, [e, c, a]);
-  const v = f(
-    (n) => {
-      if (!e) return;
-      l.current = !0;
-      const t = te(n);
-      if (t.length === 0) {
-        k(() => {
-          T(n);
-        });
+  }, [e, a, i]);
+  const j = c(
+    (t) => {
+      const r = S.current;
+      if (!e || !r || t.length === 0)
         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
+        );
       }
-      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);
+      d(n, () => {
+        o.current = !1;
+      });
+    },
+    [e, d]
+  ), H = c(
+    (t, r, n) => {
+      const u = S.current;
+      if (!e || !u)
         return;
-      }
-      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();
-          });
+      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;
         }
-      }), U = setTimeout(() => {
-        L?.(), O || u();
-      }, A);
+      });
     },
-    [e, T, a]
-  ), K = f(
-    (n) => {
-      v(V(n));
+    [e, k, i]
+  ), J = c(
+    (t) => {
+      g(w(t));
     },
-    [v]
-  ), Q = f(
-    (n, t) => {
-      const r = V(n);
-      t || v(r), F(r), y(r);
+    [g]
+  ), K = c(
+    (t, r) => {
+      const n = w(t);
+      if (!r) {
+        g(n);
+        return;
+      }
+      y(n);
     },
-    [v, y]
-  ), Z = f(
-    (n, t) => {
-      const r = (P) => P.map((u) => u.id === n ? {
-        ...u,
+    [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,
         data: {
-          ...u.data,
-          pinned: t
+          ...C.data,
+          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 }
+      } : 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 }
       ]);
-      e.applyColumnState({ state: m, applyOrder: !0 }), k(() => {
-        if (ne(e, n) !== t) {
-          l.current = !1, a();
+      e.applyColumnState({ state: N, applyOrder: !0 }), U(() => {
+        if (W(e, t) !== r) {
+          o.current = !1, i();
           return;
         }
-        T(o);
+        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;
       });
     },
-    [e, y, T, a]
+    [e, d]
   );
   return {
-    items: R,
-    isReady: H,
-    listWrapperRef: J,
-    handleChange: Q,
-    handleSubmit: K,
-    handlePinChange: Z
+    items: T,
+    columnPickerAuthority: I,
+    pickerMode: O,
+    isReady: Y,
+    listWrapperRef: Z,
+    handleChange: K,
+    handleSubmit: J,
+    handlePinChange: Q,
+    handleAuthorityItemToggle: j,
+    handleAuthorityVirtualDrop: H,
+    handleAuthoritySelectAll: $
   };
 }
 export {
-  Re as useDataTableColumnListSync
+  Gt as useDataTableColumnListSync
 };

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

@@ -1,21 +1,29 @@
 import { default as React } from 'react';
 import { useSensors, DragStartEvent, DragOverEvent, DragEndEvent } from '@dnd-kit/core';
-import { NestedListItem } from '../nested-list.types';
+import { NestedListItem, NestedListDragMode, FlatVirtualRowModel } from '../nested-list.types';
 interface NestedListContentProps {
     isListCollapsed: boolean;
     enableDragDrop: boolean;
+    dragMode?: NestedListDragMode;
     sensors: ReturnType<typeof useSensors>;
     items: {
         item: NestedListItem;
         level: number;
         indentLevel: number;
     }[];
-    renderItem: (item: NestedListItem, level: number, indentLevel: number) => React.ReactNode;
+    flatVirtualRowModel?: FlatVirtualRowModel | null;
+    renderItem: (item: NestedListItem, level: number, indentLevel: number, context?: {
+        isAnyDragging?: boolean;
+    }) => 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 {};