impact-nova 2.5.9 → 2.5.11

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

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

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

@@ -7,12 +7,27 @@ interface ColumnTreeCacheEntry {
     items: NestedListItem[];
     gridLayoutFingerprint: string;
     gridVisibilityFingerprint: string;
+    /**
+     * Leaf column ids captured at write time (single tree walk here) so the
+     * structural stale-check at read time needs no tree traversal.
+     */
+    leafColumnIds: ReadonlySet<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;
+/**
+ * True when the live grid's column-id set differs from the cached tree's leaf ids.
+ * Catches a "poisoned" cache: stale tree items stored with up-to-date grid
+ * fingerprints (e.g. after a structural columnDefs change).
+ *
+ * Cheap by design — the cached leaf ids are captured once at write time
+ * ({@link writeColumnTreeCache}), so this does no tree traversal at read time;
+ * it only scans `getColumnState()`, which callers already fetch for fingerprints.
+ */
+export declare function isGridColumnSetDifferentFromCachedLeaves(gridApi: GridApi, cachedLeafColumnIds: ReadonlySet<string>): boolean;
 export declare function resolveColumnTreeFromCacheOrGrid(options: {
     gridApi: GridApi;
     labels: BuildColumnTreeLabels;

package/dist/components/data/data-table/data-table-column-tree-cache.js

@@ -1,124 +1,152 @@
-import { buildColumnTreeFromGrid as G } from "./build-column-tree-from-grid.js";
+import { buildColumnTreeFromGrid as w } from "./build-column-tree-from-grid.js";
 import { computeColumnListSyncFingerprints as M } from "./data-table-column-list-sync.js";
-import { fingerprintColumnTreeIndicators as _, normalizeColumnPinned as w } from "./data-table-column-apply.js";
-import { patchColumnTreeIndicatorsFromGrid as V } from "./patch-column-tree-indicators-from-grid.js";
+import { fingerprintColumnTreeIndicators as _, normalizeColumnPinned as V } from "./data-table-column-apply.js";
+import { patchColumnTreeIndicatorsFromGrid as z } from "./patch-column-tree-indicators-from-grid.js";
 import { patchColumnTreeVisibilityFromGrid as C } from "./patch-column-tree-visibility-from-grid.js";
-function m(n) {
-  return n.map((i) => {
-    const t = w(i.pinned) ?? "0";
-    return `${i.colId}:${t}`;
+function d(i) {
+  return i.map((n) => {
+    const e = V(n.pinned) ?? "0";
+    return `${n.colId}:${e}`;
   }).join("|");
 }
-function d(n) {
-  return n.map((i) => `${i.colId}:${i.hide ? "0" : "1"}`).join("|");
+function m(i) {
+  return i.map((n) => `${n.colId}:${n.hide ? "0" : "1"}`).join("|");
 }
-function x(n) {
-  return m(n.getColumnState());
+function H(i) {
+  return d(i.getColumnState());
 }
-function H(n) {
-  return d(n.getColumnState());
+function O(i) {
+  return m(i.getColumnState());
 }
 const p = /* @__PURE__ */ new WeakMap(), h = {
   frozenColumns: "__prewarm_frozen__",
   scrollableColumns: "__prewarm_scrollable__"
 };
-function P(n) {
-  return typeof n.isDestroyed == "function" && n.isDestroyed();
+function I(i) {
+  return typeof i.isDestroyed == "function" && i.isDestroyed();
 }
-function F(n, i) {
-  return n.map((t) => t.id === "root-frozen" ? { ...t, label: i.frozenColumns } : t.id === "root-scrollable" ? { ...t, label: i.scrollableColumns } : t);
+function F(i, n) {
+  return i.map((e) => e.id === "root-frozen" ? { ...e, label: n.frozenColumns } : e.id === "root-scrollable" ? { ...e, label: n.scrollableColumns } : e);
 }
-function b(n, i) {
-  const t = p.get(n);
-  return t ? {
-    fingerprints: t.fingerprints,
-    items: F(t.items, i),
-    gridLayoutFingerprint: t.gridLayoutFingerprint,
-    gridVisibilityFingerprint: t.gridVisibilityFingerprint
+function P(i) {
+  const n = /* @__PURE__ */ new Set(), e = (r) => {
+    for (const t of r) {
+      if (t.id === "root-frozen" || t.id === "root-scrollable") {
+        t.children && e(t.children);
+        continue;
+      }
+      if (t.children && t.children.length > 0) {
+        e(t.children);
+        continue;
+      }
+      t.id && n.add(t.id);
+    }
+  };
+  return e(i), n;
+}
+function b(i, n) {
+  const e = p.get(i);
+  return e ? {
+    fingerprints: e.fingerprints,
+    items: F(e.items, n),
+    gridLayoutFingerprint: e.gridLayoutFingerprint,
+    gridVisibilityFingerprint: e.gridVisibilityFingerprint,
+    leafColumnIds: e.leafColumnIds
   } : null;
 }
-function u(n, i) {
-  const t = M(i), r = n.getColumnState();
-  return p.set(n, {
-    fingerprints: t,
-    items: F(i, h),
-    gridLayoutFingerprint: m(r),
-    gridVisibilityFingerprint: d(r)
-  }), t;
+function u(i, n) {
+  const e = M(n), r = i.getColumnState();
+  return p.set(i, {
+    fingerprints: e,
+    items: F(n, h),
+    gridLayoutFingerprint: d(r),
+    gridVisibilityFingerprint: m(r),
+    leafColumnIds: P(n)
+  }), e;
+}
+function v(i, n) {
+  const e = w(i, n);
+  return e ? (u(i, e), e) : null;
 }
-function I(n, i) {
-  const t = G(n, i);
-  return t ? (u(n, t), t) : null;
+function D(i, n) {
+  if (I(i))
+    return !1;
+  const e = i.getColumnState();
+  let r = 0;
+  for (const t of e)
+    if (!(!t.colId || t.colId === "ag-Grid-SelectionColumn") && (r += 1, !n.has(t.colId)))
+      return !0;
+  return r !== n.size;
 }
-function z(n) {
-  const { gridApi: i, labels: t, previousFingerprints: r } = n, e = b(i, t), y = i.getColumnState(), v = m(y), T = d(y), k = r.layout === "" && r.visibility === "" && r.indicators === "";
-  if (e) {
-    const o = V(
-      e.items,
-      i
-    ), S = _(o), c = v !== e.gridLayoutFingerprint, a = T !== e.gridVisibilityFingerprint, f = S !== e.fingerprints.indicators;
+function $(i) {
+  const { gridApi: n, labels: e, previousFingerprints: r } = i, t = b(n, e), y = n.getColumnState(), S = d(y), T = m(y), k = r.layout === "" && r.visibility === "" && r.indicators === "";
+  if (t != null && !D(n, t.leafColumnIds) && t) {
+    const o = z(
+      t.items,
+      n
+    ), L = _(o), c = S !== t.gridLayoutFingerprint, a = T !== t.gridVisibilityFingerprint, f = L !== t.fingerprints.indicators;
     if (!c && !a && !f) {
       if (k) {
-        const l = u(i, o);
+        const s = u(n, o);
         return {
           rootItems: o,
           syncMode: "structural",
-          fingerprints: l
+          fingerprints: s
         };
       }
-      if (r.layout !== e.fingerprints.layout || r.visibility !== e.fingerprints.visibility || r.indicators !== e.fingerprints.indicators) {
-        const l = u(i, o);
+      if (r.layout !== t.fingerprints.layout || r.visibility !== t.fingerprints.visibility || r.indicators !== t.fingerprints.indicators) {
+        const s = u(n, o);
         return {
           rootItems: o,
           syncMode: "structural",
-          fingerprints: l
+          fingerprints: s
         };
       }
       return {
         rootItems: null,
         syncMode: "skip",
-        fingerprints: e.fingerprints
+        fingerprints: t.fingerprints
       };
     }
     if (!c && a && !f) {
-      const s = C(
+      const l = C(
         o,
-        i
-      ), l = u(i, s);
+        n
+      ), s = u(n, l);
       return {
-        rootItems: s,
+        rootItems: l,
         syncMode: "visibility-only",
-        fingerprints: l
+        fingerprints: s
       };
     }
     if (!c && !a && f) {
-      const s = u(i, o);
+      const l = u(n, o);
       return {
         rootItems: o,
         syncMode: "indicators-only",
-        fingerprints: s
+        fingerprints: l
       };
     }
     if (!c && a && f) {
-      const s = C(
+      const l = C(
         o,
-        i
-      ), l = u(i, s);
+        n
+      ), s = u(n, l);
       return {
-        rootItems: s,
+        rootItems: l,
         syncMode: "visibility-only",
-        fingerprints: l
+        fingerprints: s
       };
     }
   }
-  const g = I(i, t);
+  const g = v(n, e);
   if (!g)
     return {
       rootItems: null,
       syncMode: "skip",
       fingerprints: r
     };
-  const L = b(i, t)?.fingerprints ?? {
+  const G = b(n, e)?.fingerprints ?? {
     layout: "",
     visibility: "",
     indicators: ""
@@ -126,33 +154,34 @@ function z(n) {
   return {
     rootItems: g,
     syncMode: "structural",
-    fingerprints: L
+    fingerprints: G
   };
 }
-function $(n) {
-  return typeof n.getColumnState == "function" && (typeof n.getAllGridColumns == "function" || typeof n.getColumns == "function");
+function q(i) {
+  return typeof i.getColumnState == "function" && (typeof i.getAllGridColumns == "function" || typeof i.getColumns == "function");
 }
-function O(n) {
-  return z(n).syncMode === "skip";
+function J(i) {
+  return $(i).syncMode === "skip";
 }
-function E(n) {
-  let i = !1, t = 0, r;
-  const e = () => {
-    i || P(n) || !$(n) || p.has(n) || I(n, h);
+function K(i) {
+  let n = !1, e = 0, r;
+  const t = () => {
+    n || I(i) || !q(i) || p.has(i) || v(i, h);
   };
-  return t = requestAnimationFrame(() => {
-    i || (typeof requestIdleCallback < "u" ? r = requestIdleCallback(e, { timeout: 3e3 }) : setTimeout(e, 0));
+  return e = requestAnimationFrame(() => {
+    n || (typeof requestIdleCallback < "u" ? r = requestIdleCallback(t, { timeout: 3e3 }) : setTimeout(t, 0));
   }), () => {
-    i = !0, t && cancelAnimationFrame(t), r !== void 0 && typeof cancelIdleCallback < "u" && cancelIdleCallback(r);
+    n = !0, e && cancelAnimationFrame(e), r !== void 0 && typeof cancelIdleCallback < "u" && cancelIdleCallback(r);
   };
 }
 export {
-  I as buildColumnTreeWithCache,
-  O as peekColumnListSyncWouldSkip,
+  v as buildColumnTreeWithCache,
+  D as isGridColumnSetDifferentFromCachedLeaves,
+  J as peekColumnListSyncWouldSkip,
   b as readColumnTreeCache,
-  x as readGridLayoutFingerprint,
-  H as readGridVisibilityFingerprint,
-  z as resolveColumnTreeFromCacheOrGrid,
-  E as scheduleColumnTreePrewarm,
+  H as readGridLayoutFingerprint,
+  O as readGridVisibilityFingerprint,
+  $ as resolveColumnTreeFromCacheOrGrid,
+  K as scheduleColumnTreePrewarm,
   u as writeColumnTreeCache
 };