impact-nova 2.2.3 → 2.2.4

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

@@ -1,55 +1,154 @@
-import { useState as O, useRef as h, useCallback as a, useEffect as x } from "react";
-import { mergePartialOrderedColumnState as N } from "./data-table-column-state.js";
-import { afterSynchronousColumnApply as v, normalizeColumnPinned as q, GRID_AUTO_UNPIN_WAIT_MS as J, alignColumnTreePinMetadata as L, EXTERNAL_SYNC_DEBOUNCE_MS as Q, readGridColumnPinned as Z } from "./data-table-column-apply.js";
-import { buildColumnTreeFromGrid as $ } from "./build-column-tree-from-grid.js";
-import { computeColumnListSyncFingerprints as z, resolveColumnListSyncMode as A } from "./data-table-column-list-sync.js";
-import { subscribeGridApiEvent as j } from "../ag-grid-react/grid-api-event-subscription.js";
-import { subscribeColumnIndicatorSync as ee } from "../ag-grid-react/column-indicator-sync-bus.js";
-function ie({
-  gridApi: o,
-  frozenColumnsLabel: D,
-  scrollableColumnsLabel: U
+import { useState as U, useRef as S, useCallback as m, useLayoutEffect as et, useEffect as _ } from "react";
+import { mergePartialOrderedColumnState as V } from "./data-table-column-state.js";
+import { afterSynchronousColumnApply as M, normalizeColumnPinned as B, GRID_AUTO_UNPIN_WAIT_MS as nt, alignColumnTreePinMetadata as X, EXTERNAL_SYNC_DEBOUNCE_MS as rt, readGridColumnPinned as ot } from "./data-table-column-apply.js";
+import { computeColumnListSyncFingerprints as Y } from "./data-table-column-list-sync.js";
+import { resolveColumnTreeFromCacheOrGrid as z, peekColumnListSyncWouldSkip as ct, readColumnTreeCache as H, writeColumnTreeCache as ut } from "./data-table-column-tree-cache.js";
+import { patchColumnTreeIndicatorsFromGrid as J } from "./patch-column-tree-indicators-from-grid.js";
+import { subscribeGridApiEvent as P } from "../ag-grid-react/grid-api-event-subscription.js";
+import { subscribeColumnIndicatorSync as Q } from "../ag-grid-react/column-indicator-sync-bus.js";
+function Ct({
+  gridApi: t,
+  frozenColumnsLabel: d,
+  scrollableColumnsLabel: f,
+  isSyncActive: a = !0
 }) {
-  const [K, R] = O([]), [V, W] = O(!1), [_, B] = O(!1), i = h(!1), E = h(null), S = h(0), y = h(""), G = h(""), C = a(() => !o || i.current ? null : $(o, {
-    frozenColumns: D,
-    scrollableColumns: U
-  }), [o, D, U]), I = a(
-    (n, e) => {
-      const r = y.current, l = z(n);
-      y.current = l.structural, G.current = l.indicators, R(n), W(!0), e === "structural" && r !== "" && B((t) => !t);
+  const [Z, k] = U([]), [$, x] = U(!1), [q, N] = U(!1), i = S(!1), g = S(null), E = S(0), I = S(""), R = S(""), W = S(a), b = S(!1), T = m(
+    (e, n) => {
+      const o = I.current, c = Y(e);
+      I.current = c.structural, R.current = c.indicators, k(e), x(!0), n === "structural" && o !== "" && N((r) => !r), n === "indicators-only" && b.current && (b.current = !1, N((r) => !r));
     },
     []
-  ), f = a(
+  ), p = m(
     () => {
-      const n = C();
-      n && I(n, "structural");
+      if (!t || i.current) return;
+      const e = z({
+        gridApi: t,
+        labels: {
+          frozenColumns: d,
+          scrollableColumns: f
+        },
+        previousFingerprints: {
+          structural: I.current,
+          indicators: R.current
+        }
+      });
+      if (e.syncMode === "skip" || !e.rootItems) {
+        e.syncMode !== "skip" && x(!0);
+        return;
+      }
+      T(
+        e.rootItems,
+        e.syncMode === "indicators-only" ? "indicators-only" : "structural"
+      );
     },
-    [I, C]
-  ), k = a(
+    [
+      T,
+      d,
+      t,
+      f
+    ]
+  ), j = m(
     () => {
-      const n = C();
-      if (!n) return;
-      const e = A(
-        n,
-        y.current,
-        G.current
-      );
-      if (e !== "skip") {
-        if (e === "structural") {
-          const r = E.current?.querySelector(
+      if (!t || i.current) return;
+      const e = z({
+        gridApi: t,
+        labels: {
+          frozenColumns: d,
+          scrollableColumns: f
+        },
+        previousFingerprints: {
+          structural: I.current,
+          indicators: R.current
+        }
+      });
+      if (e.syncMode !== "skip" && e.rootItems) {
+        if (e.syncMode === "structural") {
+          const n = g.current?.querySelector(
             '[data-component="nested-list"] .overflow-y-auto'
           );
-          r && (S.current = r.scrollTop);
+          n && (E.current = n.scrollTop);
         }
-        I(n, e);
+        T(
+          e.rootItems,
+          e.syncMode === "indicators-only" ? "indicators-only" : "structural"
+        );
       }
     },
-    [I, C]
+    [
+      T,
+      d,
+      t,
+      f
+    ]
   );
-  x(() => {
-    if (!o) return;
-    queueMicrotask(() => f());
-    const n = [
+  et(() => {
+    const e = a && !W.current;
+    if (W.current = a, !t || !a) return;
+    const n = {
+      frozenColumns: d,
+      scrollableColumns: f
+    }, o = {
+      structural: I.current,
+      indicators: R.current
+    };
+    if (!(!e && o.structural !== "" && ct({
+      gridApi: t,
+      labels: n,
+      previousFingerprints: o
+    }))) {
+      if (e) {
+        b.current = !0, queueMicrotask(() => {
+          const c = H(t, n);
+          if (c) {
+            const s = J(
+              c.items,
+              t
+            );
+            T(s, "indicators-only");
+            return;
+          }
+          p();
+        });
+        return;
+      }
+      queueMicrotask(() => {
+        p();
+      });
+    }
+  }, [
+    t,
+    a,
+    d,
+    f,
+    p,
+    T
+  ]), _(() => {
+    if (!t || a) return;
+    const e = {
+      frozenColumns: d,
+      scrollableColumns: f
+    }, n = () => {
+      const r = H(t, e);
+      if (!r)
+        return;
+      const h = J(
+        r.items,
+        t
+      );
+      ut(t, h);
+    }, o = P(t, "sortChanged", () => {
+      n();
+    }), c = P(t, "filterChanged", () => {
+      n();
+    }), s = Q(() => {
+      n();
+    });
+    return () => {
+      o(), c(), s();
+    };
+  }, [t, a, d, f]), _(() => {
+    if (!t || !a) return;
+    const e = [
       "columnVisible",
       "columnPinned",
       "columnMoved",
@@ -65,161 +164,161 @@ function ie({
       "filterChanged",
       "newColumnsLoaded"
     ];
-    let e = null;
-    const r = () => {
-      i.current || (e && clearTimeout(e), e = setTimeout(() => {
-        e = null, !(i.current || o.isDestroyed()) && k();
-      }, Q));
-    }, l = n.map(
-      (t) => j(o, t, () => {
-        r();
+    let n = null;
+    const o = () => {
+      i.current || (n && clearTimeout(n), n = setTimeout(() => {
+        n = null, !(i.current || t.isDestroyed()) && j();
+      }, rt));
+    }, c = e.map(
+      (r) => P(t, r, () => {
+        o();
       })
-    ), u = ee(() => {
-      r();
+    ), s = Q(() => {
+      o();
     });
     return () => {
-      e && clearTimeout(e), l.forEach((t) => t()), u();
+      n && clearTimeout(n), c.forEach((r) => r()), s();
     };
-  }, [o, f, k]), x(() => {
-    if (S.current === 0) return;
-    const n = requestAnimationFrame(() => {
-      const e = E.current?.querySelector(
+  }, [t, a, j]), _(() => {
+    if (E.current === 0) return;
+    const e = requestAnimationFrame(() => {
+      const n = g.current?.querySelector(
         '[data-component="nested-list"] .overflow-y-auto'
       );
-      e && (e.scrollTop = S.current, S.current = 0);
+      n && (n.scrollTop = E.current, E.current = 0);
     });
-    return () => cancelAnimationFrame(n);
-  }, [_]);
-  const w = a(
-    (n) => {
-      const e = [], r = (l, u) => {
-        l.forEach((t) => {
-          if (t.id === "root-frozen") {
-            t.children && r(t.children, "left");
+    return () => cancelAnimationFrame(e);
+  }, [q]);
+  const K = m(
+    (e) => {
+      const n = [], o = (c, s) => {
+        c.forEach((r) => {
+          if (r.id === "root-frozen") {
+            r.children && o(r.children, "left");
             return;
           }
-          if (t.id === "root-scrollable") {
-            t.children && r(t.children, null);
+          if (r.id === "root-scrollable") {
+            r.children && o(r.children, null);
             return;
           }
-          if (t.category === "group" || t.children && t.children.length > 0)
-            t.children && r(t.children, u);
+          if (r.category === "group" || r.children && r.children.length > 0)
+            r.children && o(r.children, s);
           else {
-            let c;
-            if (u === null)
-              c = null;
+            let u;
+            if (s === null)
+              u = null;
             else {
-              const d = t.data?.pinned;
-              c = d === "left" || d === "right" ? d : u;
+              const y = r.data?.pinned;
+              u = y === "left" || y === "right" ? y : s;
             }
-            e.push({
-              colId: t.id,
-              pinned: c,
-              hide: !t.checked
+            n.push({
+              colId: r.id,
+              pinned: u,
+              hide: !r.checked
             });
           }
         });
       };
-      return r(n, null), e;
+      return o(e, null), n;
     },
     []
-  ), g = a(
-    (n) => {
-      if (!o) return;
+  ), F = m(
+    (e) => {
+      if (!t) return;
       i.current = !0;
-      const e = w(n);
-      if (e.length === 0) {
-        v(() => {
+      const n = K(e);
+      if (n.length === 0) {
+        M(() => {
           i.current = !1;
         });
         return;
       }
-      const r = o.getColumnState(), l = N(r, e), u = new Set(
-        r.filter((s) => q(s.pinned)).map((s) => s.colId)
-      ), t = l.filter(
-        (s) => q(s.pinned) && !u.has(s.colId)
-      ), p = new Set(t.map((s) => s.colId));
-      o.applyColumnState({ state: l, applyOrder: !0 });
-      const c = () => {
-        i.current = !1, f();
+      const o = t.getColumnState(), c = V(o, n), s = new Set(
+        o.filter((l) => B(l.pinned)).map((l) => l.colId)
+      ), r = c.filter(
+        (l) => B(l.pinned) && !s.has(l.colId)
+      ), h = new Set(r.map((l) => l.colId));
+      t.applyColumnState({ state: c, applyOrder: !0 });
+      const u = () => {
+        i.current = !1, p();
       };
-      if (p.size === 0) {
-        v(c);
+      if (h.size === 0) {
+        M(u);
         return;
       }
-      let b = !1, d = null, P = null;
-      P = j(o, "columnPinned", () => {
-        if (b || o.isDestroyed()) return;
-        const s = o.getColumnState();
-        if (t.filter((T) => {
-          const m = s.find((F) => F.colId === T.colId);
-          return m && !m.pinned;
+      let v = !1, y = null, O = null;
+      O = P(t, "columnPinned", () => {
+        if (v || t.isDestroyed()) return;
+        const l = t.getColumnState();
+        if (r.filter((G) => {
+          const C = l.find((w) => w.colId === G.colId);
+          return C && !C.pinned;
         }).length > 0) {
-          b = !0, d && clearTimeout(d), P?.();
-          const T = l.filter(
-            (m) => m.pinned && !p.has(m.colId)
+          v = !0, y && clearTimeout(y), O?.();
+          const G = c.filter(
+            (C) => C.pinned && !h.has(C.colId)
           );
-          if (T.length > 0) {
-            const m = T[0], F = l.map(
-              (M) => M.colId === m.colId ? { ...M, pinned: null } : M
+          if (G.length > 0) {
+            const C = G[0], w = c.map(
+              (D) => D.colId === C.colId ? { ...D, pinned: null } : D
             );
-            o.applyColumnState({ state: F, applyOrder: !0 });
+            t.applyColumnState({ state: w, applyOrder: !0 });
           }
-          v(c);
+          M(u);
         }
-      }), d = setTimeout(() => {
-        P?.(), b || c();
-      }, J);
+      }), y = setTimeout(() => {
+        O?.(), v || u();
+      }, nt);
     },
-    [o, w, f]
-  ), X = a(
-    (n) => {
-      g(L(n));
+    [t, K, p]
+  ), L = m(
+    (e) => {
+      F(X(e));
     },
-    [g]
-  ), Y = a(
-    (n, e) => {
-      const r = L(n);
-      e || g(r), R(r);
-      const l = z(r);
-      y.current = l.structural, G.current = l.indicators;
+    [F]
+  ), A = m(
+    (e, n) => {
+      const o = X(e);
+      n || F(o), k(o);
+      const c = Y(o);
+      I.current = c.structural, R.current = c.indicators;
     },
-    [g]
-  ), H = a(
-    (n, e) => {
-      if (R((u) => {
-        const t = (p) => p.map((c) => c.id === n ? {
-          ...c,
+    [F]
+  ), tt = m(
+    (e, n) => {
+      if (k((s) => {
+        const r = (h) => h.map((u) => u.id === e ? {
+          ...u,
           data: {
-            ...c.data,
-            pinned: e
+            ...u.data,
+            pinned: n
           }
-        } : c.children ? {
-          ...c,
-          children: t(c.children)
-        } : c);
-        return t(u);
-      }), !o) return;
+        } : u.children ? {
+          ...u,
+          children: r(u.children)
+        } : u);
+        return r(s);
+      }), !t) return;
       i.current = !0;
-      const r = o.getColumnState(), l = N(r, [
-        { colId: n, pinned: e }
+      const o = t.getColumnState(), c = V(o, [
+        { colId: e, pinned: n }
       ]);
-      o.applyColumnState({ state: l, applyOrder: !0 }), v(() => {
-        i.current = !1, Z(o, n) !== e && f();
+      t.applyColumnState({ state: c, applyOrder: !0 }), M(() => {
+        i.current = !1, ot(t, e) !== n && p();
       });
     },
-    [o, f]
+    [t, p]
   );
   return {
-    items: K,
-    isReady: V,
-    externalSyncKey: _,
-    listWrapperRef: E,
-    handleChange: Y,
-    handleSubmit: X,
-    handlePinChange: H
+    items: Z,
+    isReady: $,
+    externalSyncKey: q,
+    listWrapperRef: g,
+    handleChange: A,
+    handleSubmit: L,
+    handlePinChange: tt
   };
 }
 export {
-  ie as useDataTableColumnListSync
+  Ct as useDataTableColumnListSync
 };