impact-nova 2.5.1 → 2.5.3

package/dist/components/data/data-table/build-column-state-from-tree.d.ts

@@ -0,0 +1,7 @@
+import { ColumnState } from 'ag-grid-community';
+import { NestedListItem } from '../nested-list/nested-list.types';
+/**
+ * Build AG Grid `ColumnState` partials (hide, pinned, order) from a column-picker tree.
+ * O(n) over tree leaves; used by column-list sync and runtime state guard.
+ */
+export declare function buildColumnStateFromTree(rootItems: NestedListItem[]): ColumnState[];

package/dist/components/data/data-table/build-column-state-from-tree.js

@@ -0,0 +1,34 @@
+function a(u) {
+  const c = [], l = (f, i) => {
+    f.forEach((r) => {
+      if (r.id === "root-frozen") {
+        r.children && l(r.children, "left");
+        return;
+      }
+      if (r.id === "root-scrollable") {
+        r.children && l(r.children, null);
+        return;
+      }
+      if (r.category === "group" || r.children && r.children.length > 0)
+        r.children && l(r.children, i);
+      else {
+        let t;
+        if (i === null)
+          t = null;
+        else {
+          const e = r.data?.pinned;
+          t = e === "left" || e === "right" ? e : i;
+        }
+        c.push({
+          colId: r.id,
+          pinned: t,
+          hide: !r.checked
+        });
+      }
+    });
+  };
+  return l(u, null), c;
+}
+export {
+  a as buildColumnStateFromTree
+};

package/dist/components/data/data-table/column-runtime-state-guard.d.ts

@@ -0,0 +1,17 @@
+import { GridApi } from 'ag-grid-community';
+export declare function isColumnRuntimeStateGuardUpdating(gridApi: GridApi): boolean;
+export declare function isColumnRuntimeStateGuardDeferred(gridApi: GridApi): boolean;
+/**
+ * Suppress guard restore while an external authority (saved view, server metadata)
+ * applies column state. Cleared on the next macrotask so follow-up grid events settle.
+ */
+export declare function deferColumnRuntimeStateGuard(gridApi: GridApi): void;
+/**
+ * Rebuild column-tree cache from the live grid (authority writers after apply).
+ */
+export declare function rebuildColumnTreeCacheFromGrid(gridApi: GridApi): void;
+/**
+ * Subscribe once per grid: re-apply cached user column state after AG Grid
+ * structural reloads (`newColumnsLoaded`).
+ */
+export declare function scheduleColumnRuntimeStateGuard(gridApi: GridApi): () => void;

package/dist/components/data/data-table/column-runtime-state-guard.js

@@ -0,0 +1,77 @@
+import { buildColumnStateFromTree as y } from "./build-column-state-from-tree.js";
+import { mergePartialOrderedColumnState as C } from "./data-table-column-state.js";
+import { afterSynchronousColumnApply as p } from "./data-table-column-apply.js";
+import { readColumnTreeCache as l, readGridLayoutFingerprint as s, readGridVisibilityFingerprint as m, buildColumnTreeWithCache as b, writeColumnTreeCache as S } from "./data-table-column-tree-cache.js";
+import { subscribeGridApiEvent as h } from "../ag-grid-react/grid-api-event-subscription.js";
+const i = {
+  frozenColumns: "__prewarm_frozen__",
+  scrollableColumns: "__prewarm_scrollable__"
+}, n = /* @__PURE__ */ new WeakMap(), r = /* @__PURE__ */ new WeakMap();
+function c(e) {
+  return typeof e.isDestroyed == "function" && e.isDestroyed();
+}
+function D(e) {
+  return r.get(e) === !0;
+}
+function F(e) {
+  return n.get(e) === !0;
+}
+function V(e) {
+  n.set(e, !0), globalThis.setTimeout(() => {
+    n.delete(e);
+  }, 0);
+}
+function _(e) {
+  if (c(e))
+    return;
+  const t = l(e, i);
+  if (t) {
+    const o = s(e), u = m(e);
+    if (o === t.gridLayoutFingerprint && u === t.gridVisibilityFingerprint)
+      return;
+  }
+  b(e, i);
+}
+function G(e) {
+  const t = l(e, i);
+  if (!t)
+    return;
+  const o = s(e), u = m(e);
+  if (o === t.gridLayoutFingerprint && u === t.gridVisibilityFingerprint)
+    return;
+  const a = y(t.items);
+  if (a.length === 0)
+    return;
+  r.set(e, !0);
+  const f = e.getColumnState(), d = C(f, a);
+  e.applyColumnState({ state: d, applyOrder: !0 }), p(() => {
+    r.delete(e), S(e, t.items);
+  });
+}
+function L(e) {
+  if (!c(e)) {
+    if (F(e)) {
+      _(e);
+      return;
+    }
+    G(e);
+  }
+}
+function g(e) {
+  if (typeof e.addEventListener != "function")
+    return () => {
+    };
+  const t = h(e, "newColumnsLoaded", () => {
+    L(e);
+  });
+  return () => {
+    t(), r.delete(e), n.delete(e);
+  };
+}
+export {
+  V as deferColumnRuntimeStateGuard,
+  F as isColumnRuntimeStateGuardDeferred,
+  D as isColumnRuntimeStateGuardUpdating,
+  _ as rebuildColumnTreeCacheFromGrid,
+  g as scheduleColumnRuntimeStateGuard
+};

package/dist/components/data/data-table/data-table-column-apply.d.ts

@@ -18,6 +18,10 @@ export declare function readGridColumnPinned(gridApi: GridApi, columnId: string)
 export declare function pinnedColumnIdsFromState(state: ColumnState[]): Set<string>;
 /** Align `data.pinned` on leaves with frozen/scrollable section placement. */
 export declare function alignColumnTreePinMetadata(items: NestedListItem[]): NestedListItem[];
+/** Fingerprint for column-tree layout (order, pin section placement). */
+export declare function fingerprintColumnTreeLayout(items: NestedListItem[]): string;
+/** Fingerprint for column-tree visibility (leaf checked state). */
+export declare function fingerprintColumnTreeVisibility(items: NestedListItem[]): string;
 /** Cheap structural fingerprint for column-tree equality (order, pin, visibility). */
 export declare function fingerprintColumnTreeItems(items: NestedListItem[]): string;
 /** Fingerprint for sort/filter indicator badges on column-picker leaves. */

package/dist/components/data/data-table/data-table-column-apply.js

@@ -1,102 +1,119 @@
-const p = 150, s = 300;
-function c(e) {
-  return e === "left" || e === !0 ? "left" : e === "right" ? "right" : null;
+const s = 150, p = 300;
+function u(i) {
+  return i === "left" || i === !0 ? "left" : i === "right" ? "right" : null;
 }
-function f(e, n) {
-  return "pinned" in e && e.pinned !== void 0 ? c(e.pinned) : c(n.getPinned());
+function a(i, r) {
+  return "pinned" in i && i.pinned !== void 0 ? u(i.pinned) : u(r.getPinned());
 }
-function g(e, n) {
-  const r = e.getColumn(n);
-  if (!r) return null;
-  const l = e.getColumnState().find((t) => t.colId === n);
-  return l ? f(l, r) : c(r.getPinned());
+function g(i, r) {
+  const e = i.getColumn(r);
+  if (!e) return null;
+  const o = i.getColumnState().find((n) => n.colId === r);
+  return o ? a(o, e) : u(e.getPinned());
 }
-function d(e, n) {
-  return e.map((r) => {
-    if ((r.category === "group" || r.children && r.children.length > 0) && r.children)
+function d(i, r) {
+  return i.map((e) => {
+    if ((e.category === "group" || e.children && e.children.length > 0) && e.children)
       return {
-        ...r,
-        children: d(r.children, n)
+        ...e,
+        children: d(e.children, r)
       };
-    const t = r.data ?? {};
-    let i = null;
-    if (n !== null) {
-      const o = t.pinned;
-      i = o === "left" || o === "right" ? o : n;
+    const n = e.data ?? {};
+    let t = null;
+    if (r !== null) {
+      const l = n.pinned;
+      t = l === "left" || l === "right" ? l : r;
     }
     return {
-      ...r,
+      ...e,
       data: {
-        ...t,
-        pinned: i
+        ...n,
+        pinned: t
       }
     };
   });
 }
-function m(e) {
-  return e.map((n) => n.id === "root-frozen" ? {
-    ...n,
-    children: n.children ? d(n.children, "left") : []
-  } : n.id === "root-scrollable" ? {
-    ...n,
-    children: n.children ? d(n.children, null) : []
-  } : n);
+function m(i) {
+  return i.map((r) => r.id === "root-frozen" ? {
+    ...r,
+    children: r.children ? d(r.children, "left") : []
+  } : r.id === "root-scrollable" ? {
+    ...r,
+    children: r.children ? d(r.children, null) : []
+  } : r);
 }
-function C(e) {
-  const n = [], r = (l, t) => {
-    for (const i of l) {
-      if (i.id === "root-frozen") {
-        i.children && r(i.children, "left");
+function C(i) {
+  const r = [], e = (o, n) => {
+    for (const t of o) {
+      if (t.id === "root-frozen") {
+        t.children && e(t.children, "left");
         continue;
       }
-      if (i.id === "root-scrollable") {
-        i.children && r(i.children, null);
+      if (t.id === "root-scrollable") {
+        t.children && e(t.children, null);
         continue;
       }
-      if ((i.category === "group" || i.children && i.children.length > 0) && i.children) {
-        r(i.children, t);
+      if ((t.category === "group" || t.children && t.children.length > 0) && t.children) {
+        e(t.children, n);
         continue;
       }
-      let a = "0";
-      if (t !== null) {
-        const u = i.data?.pinned;
-        a = u === "left" || u === "right" ? u : "left";
+      let f = "0";
+      if (n !== null) {
+        const c = t.data?.pinned;
+        f = c === "left" || c === "right" ? c : "left";
       }
-      n.push(`${i.id}:${a}:${i.checked ? "1" : "0"}`);
+      r.push(`${t.id}:${f}`);
     }
   };
-  return r(e, null), n.join("|");
+  return e(i, null), r.join("|");
 }
-function G(e) {
-  const n = [], r = (l) => {
-    for (const t of l) {
-      if (t.id === "root-frozen" || t.id === "root-scrollable") {
-        t.children && r(t.children);
+function G(i) {
+  const r = [], e = (o) => {
+    for (const n of o) {
+      if (n.id === "root-frozen" || n.id === "root-scrollable") {
+        n.children && e(n.children);
         continue;
       }
-      if ((t.category === "group" || t.children && t.children.length > 0) && t.children) {
-        r(t.children);
+      if ((n.category === "group" || n.children && n.children.length > 0) && n.children) {
+        e(n.children);
+        continue;
+      }
+      r.push(`${n.id}:${n.checked ? "1" : "0"}`);
+    }
+  };
+  return e(i), r.join("|");
+}
+function y(i) {
+  const r = [], e = (o) => {
+    for (const n of o) {
+      if (n.id === "root-frozen" || n.id === "root-scrollable") {
+        n.children && e(n.children);
+        continue;
+      }
+      if ((n.category === "group" || n.children && n.children.length > 0) && n.children) {
+        e(n.children);
         continue;
       }
-      const o = t.data;
-      n.push(
-        `${t.id}:${o?.hasSortApplied ? "1" : "0"}:${o?.hasFilterApplied ? "1" : "0"}`
+      const l = n.data;
+      r.push(
+        `${n.id}:${l?.hasSortApplied ? "1" : "0"}:${l?.hasFilterApplied ? "1" : "0"}`
       );
     }
   };
-  return r(e), n.join("|");
+  return e(i), r.join("|");
 }
-function S(e) {
-  queueMicrotask(e);
+function S(i) {
+  queueMicrotask(i);
 }
 export {
-  p as EXTERNAL_SYNC_DEBOUNCE_MS,
-  s as GRID_AUTO_UNPIN_WAIT_MS,
+  s as EXTERNAL_SYNC_DEBOUNCE_MS,
+  p as GRID_AUTO_UNPIN_WAIT_MS,
   S as afterSynchronousColumnApply,
   m as alignColumnTreePinMetadata,
-  G as fingerprintColumnTreeIndicators,
-  C as fingerprintColumnTreeItems,
-  c as normalizeColumnPinned,
+  y as fingerprintColumnTreeIndicators,
+  C as fingerprintColumnTreeLayout,
+  G as fingerprintColumnTreeVisibility,
+  u as normalizeColumnPinned,
   g as readGridColumnPinned,
-  f as resolveColumnPinnedFromGridState
+  a as resolveColumnPinnedFromGridState
 };

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

@@ -1,8 +1,9 @@
 import { NestedListItem } from '../nested-list/nested-list.types';
-export type ColumnListSyncMode = 'skip' | 'indicators-only' | 'structural';
+export type ColumnListSyncMode = 'skip' | 'indicators-only' | 'visibility-only' | 'structural';
 export interface ColumnListSyncFingerprints {
-    structural: string;
+    layout: string;
+    visibility: string;
     indicators: string;
 }
 export declare function computeColumnListSyncFingerprints(rootItems: NestedListItem[]): ColumnListSyncFingerprints;
-export declare function resolveColumnListSyncMode(rootItems: NestedListItem[], previousStructuralFingerprint: string, previousIndicatorsFingerprint: string): ColumnListSyncMode;
+export declare function resolveColumnListSyncMode(rootItems: NestedListItem[], previousFingerprints: ColumnListSyncFingerprints): ColumnListSyncMode;

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

@@ -1,10 +1,11 @@
-import { fingerprintColumnTreeIndicators as n, fingerprintColumnTreeItems as i } from "./data-table-column-apply.js";
-function e(r) {
+import { fingerprintColumnTreeIndicators as n, fingerprintColumnTreeVisibility as r, fingerprintColumnTreeLayout as t } from "./data-table-column-apply.js";
+function o(i) {
   return {
-    structural: i(r),
-    indicators: n(r)
+    layout: t(i),
+    visibility: r(i),
+    indicators: n(i)
   };
 }
 export {
-  e as computeColumnListSyncFingerprints
+  o as computeColumnListSyncFingerprints
 };

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

@@ -1,88 +1,86 @@
-import { jsxs as _, jsx as n } from "react/jsx-runtime";
-import { useRef as y, useState as F, useMemo as O, useCallback as i } from "react";
+import { jsxs as D, jsx as n } from "react/jsx-runtime";
+import { useRef as _, useState as F, useMemo as O, useCallback as i } from "react";
 import { useDataTable as E } from "./data-table-context.js";
-import { useDataTableSheet as z } from "./data-table-sheet-context.js";
-import { NestedList as P } from "../nested-list/nested-list.js";
-import { SelectionMode as R } from "../nested-list/nested-list.types.js";
-import { useImpactNovaI18n as k } from "../../../i18n/use-impact-nova-i18n.js";
-import { countNestedListLeaves as M, buildCollapsedStateForAllGroups as j } from "../nested-list/nested-list-tree-utils.js";
-import { PinSwitch as G } from "./pin-switch.js";
+import { useDataTableSheet as y } from "./data-table-sheet-context.js";
+import { NestedList as z } from "../nested-list/nested-list.js";
+import { SelectionMode as P } from "../nested-list/nested-list.types.js";
+import { useImpactNovaI18n as R } from "../../../i18n/use-impact-nova-i18n.js";
+import { countNestedListLeaves as k, buildCollapsedStateForAllGroups as M } from "../nested-list/nested-list-tree-utils.js";
+import { PinSwitch as j } from "./pin-switch.js";
 import { ColumnIndicator as m } from "./column-indicator.js";
-import { IndicatorLegend as H } from "./indicator-legend.js";
-import { useDataTableColumnListSync as U } from "./use-data-table-column-list-sync.js";
-const W = 100, ne = ({
+import { IndicatorLegend as G } from "./indicator-legend.js";
+import { useDataTableColumnListSync as H } from "./use-data-table-column-list-sync.js";
+const U = 100, te = ({
   enableApplyDiscard: o = !1,
   showSearch: d = !0,
   showSelectAll: p = !0,
   showCollapse: f = !0
 }) => {
-  const { gridApi: h } = E(), { open: C } = z(), { t: r } = k(), b = y({}), [l, S] = F({}), {
+  const { gridApi: h } = E(), { open: C } = y(), { t: r } = R(), b = _({}), [l, L] = F({}), {
     items: a,
-    isReady: L,
-    externalSyncKey: g,
-    listWrapperRef: A,
+    isReady: S,
+    listWrapperRef: g,
     handleChange: c,
-    handleSubmit: T,
+    handleSubmit: A,
     handlePinChange: u
-  } = U({
+  } = H({
     gridApi: h,
     frozenColumnsLabel: r("dataTable.frozenColumns"),
     scrollableColumnsLabel: r("dataTable.scrollableColumns"),
     isSyncActive: C
-  }), x = O(() => Object.keys(l).length > 0 || a.length === 0 || M(a) <= W ? l : j(a), [l, a]), I = i(
+  }), T = O(() => Object.keys(l).length > 0 || a.length === 0 || k(a) <= U ? l : M(a), [l, a]), x = i(
     (e) => {
       c(e, o);
     },
     [o, c]
-  ), N = i(
+  ), I = i(
     (e, s) => {
       if (!s.isLeaf) return null;
       const t = e.data;
-      return !t?.hasSortApplied && !t?.hasFilterApplied ? null : /* @__PURE__ */ _("span", { className: "inline-flex items-center gap-1 shrink-0", children: [
+      return !t?.hasSortApplied && !t?.hasFilterApplied ? null : /* @__PURE__ */ D("span", { className: "inline-flex items-center gap-1 shrink-0", children: [
         t?.hasSortApplied && /* @__PURE__ */ n(m, { type: "sort" }),
         t?.hasFilterApplied && /* @__PURE__ */ n(m, { type: "filter" })
       ] });
     },
     []
-  ), v = i(
+  ), N = i(
     (e, s) => {
       const t = e.data;
-      return e.category === "structure" ? e.id !== "root-frozen" ? null : /* @__PURE__ */ n(H, {}) : !s.isLeaf || !(t?.pinned === "left" || t?.pinned === "right") ? null : /* @__PURE__ */ n(
-        G,
+      return e.category === "structure" ? e.id !== "root-frozen" ? null : /* @__PURE__ */ n(G, {}) : !s.isLeaf || !(t?.pinned === "left" || t?.pinned === "right") ? null : /* @__PURE__ */ n(
+        j,
         {
           value: t?.pinned ?? null,
-          onChange: (D) => u(e.id, D),
+          onChange: (v) => u(e.id, v),
           className: "shrink-0"
         }
       );
     },
     [u]
   );
-  return L ? /* @__PURE__ */ n("div", { ref: A, className: "flex flex-col flex-1 min-h-0 bg-canvas-elevated", children: /* @__PURE__ */ n(
-    P,
+  return S ? /* @__PURE__ */ n("div", { ref: g, className: "flex flex-col flex-1 min-h-0 bg-canvas-elevated", children: /* @__PURE__ */ n(
+    z,
     {
       items: a,
-      onChange: I,
-      onSubmit: T,
-      renderLabelExtras: N,
-      renderActions: v,
+      onChange: x,
+      onSubmit: A,
+      renderLabelExtras: I,
+      renderActions: N,
       enableApplyDiscard: o,
       enableSearch: d,
       enableSelectAll: p,
       enableDragDrop: !0,
       enableCollapse: !0,
       enableGlobalCollapse: f,
-      selectionMode: R.CASCADE_DOWN,
+      selectionMode: P.CASCADE_DOWN,
       searchPlaceholder: r("dataTable.searchColumnsPlaceholder"),
       className: "flex-1 min-h-0",
-      initialCollapsedItems: x,
+      initialCollapsedItems: T,
       onCollapseChange: (e) => {
-        b.current = e, S(e);
+        b.current = e, L(e);
       }
-    },
-    `data-table-column-list-${g}`
+    }
   ) }) : /* @__PURE__ */ n("div", { className: "p-4 text-[13px] text-content-placeholder", children: r("dataTable.loadingColumns") });
 };
 export {
-  ne as DataTableColumnList
+  te as DataTableColumnList
 };

package/dist/components/data/data-table/data-table-column-tree-cache.d.ts

@@ -1,13 +1,15 @@
 import { GridApi } from 'ag-grid-community';
 import { NestedListItem } from '../nested-list/nested-list.types';
 import { BuildColumnTreeLabels } from './build-column-tree-from-grid';
-import { ColumnListSyncFingerprints } from './data-table-column-list-sync';
+import { ColumnListSyncFingerprints, ColumnListSyncMode } from './data-table-column-list-sync';
 interface ColumnTreeCacheEntry {
     fingerprints: ColumnListSyncFingerprints;
     items: NestedListItem[];
-    gridColumnStateFingerprint: string;
+    gridLayoutFingerprint: string;
+    gridVisibilityFingerprint: string;
 }
-export declare function readGridColumnStateFingerprint(gridApi: GridApi): string;
+export declare function readGridLayoutFingerprint(gridApi: GridApi): string;
+export declare function readGridVisibilityFingerprint(gridApi: GridApi): string;
 export declare function readColumnTreeCache(gridApi: GridApi, labels: BuildColumnTreeLabels): ColumnTreeCacheEntry | null;
 export declare function writeColumnTreeCache(gridApi: GridApi, rootItems: NestedListItem[]): ColumnListSyncFingerprints;
 export declare function buildColumnTreeWithCache(gridApi: GridApi, labels: BuildColumnTreeLabels): NestedListItem[] | null;
@@ -17,7 +19,7 @@ export declare function resolveColumnTreeFromCacheOrGrid(options: {
     previousFingerprints: ColumnListSyncFingerprints;
 }): {
     rootItems: NestedListItem[] | null;
-    syncMode: 'skip' | 'indicators-only' | 'structural';
+    syncMode: ColumnListSyncMode;
     fingerprints: ColumnListSyncFingerprints;
 };
 export declare function peekColumnListSyncWouldSkip(options: {