impact-nova 2.1.0-alpha.6 → 2.1.0-alpha.8

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

@@ -1,54 +1,55 @@
-import { useState as M, useRef as h, useCallback as a, useEffect as x } from "react";
-import { mergePartialOrderedColumnState as L } from "./data-table-column-state.js";
-import { afterSynchronousColumnApply as b, normalizeColumnPinned as q, GRID_AUTO_UNPIN_WAIT_MS as H, alignColumnTreePinMetadata as N, EXTERNAL_SYNC_DEBOUNCE_MS as J, readGridColumnPinned as Q } from "./data-table-column-apply.js";
-import { buildColumnTreeFromGrid as Z } from "./build-column-tree-from-grid.js";
+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";
-function se({
-  gridApi: n,
-  frozenColumnsLabel: O,
-  scrollableColumnsLabel: _
+import { subscribeColumnIndicatorSync as ee } from "../ag-grid-react/column-indicator-sync-bus.js";
+function ie({
+  gridApi: o,
+  frozenColumnsLabel: D,
+  scrollableColumnsLabel: U
 }) {
-  const [K, v] = M([]), [V, W] = M(!1), [w, B] = M(!1), i = h(!1), E = h(null), S = h(0), y = h(""), P = h(""), C = a(() => !n || i.current ? null : Z(n, {
-    frozenColumns: O,
-    scrollableColumns: _
-  }), [n, O, _]), g = a(
-    (t, e, o) => {
-      const l = y.current, c = z(t);
-      y.current = c.structural, P.current = c.indicators, v(t), W(!0), e === "structural" && l !== "" && B((d) => !d);
+  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);
     },
-    [n]
-  ), p = a(
-    (t = "unknown") => {
-      const e = C();
-      e && g(e, "structural", t);
+    []
+  ), f = a(
+    () => {
+      const n = C();
+      n && I(n, "structural");
     },
-    [g, C, n]
-  ), D = a(
-    (t) => {
-      const e = C();
-      if (!e) return;
-      const o = A(
-        e,
+    [I, C]
+  ), k = a(
+    () => {
+      const n = C();
+      if (!n) return;
+      const e = A(
+        n,
         y.current,
-        P.current
+        G.current
       );
-      if (o !== "skip") {
-        if (o === "structural") {
-          const l = E.current?.querySelector(
+      if (e !== "skip") {
+        if (e === "structural") {
+          const r = E.current?.querySelector(
             '[data-component="nested-list"] .overflow-y-auto'
           );
-          l && (S.current = l.scrollTop);
+          r && (S.current = r.scrollTop);
         }
-        g(e, o, t);
+        I(n, e);
       }
     },
-    [g, C]
+    [I, C]
   );
   x(() => {
-    if (!n) return;
-    queueMicrotask(() => p("initial"));
-    const t = [
+    if (!o) return;
+    queueMicrotask(() => f());
+    const n = [
       "columnVisible",
       "columnPinned",
       "columnMoved",
@@ -65,158 +66,160 @@ function se({
       "newColumnsLoaded"
     ];
     let e = null;
-    const o = (c) => {
+    const r = () => {
       i.current || (e && clearTimeout(e), e = setTimeout(() => {
-        e = null, !(i.current || n.isDestroyed()) && D(`grid:${c}`);
-      }, J));
-    }, l = t.map(
-      (c) => j(n, c, () => {
-        o(c);
+        e = null, !(i.current || o.isDestroyed()) && k();
+      }, Q));
+    }, l = n.map(
+      (t) => j(o, t, () => {
+        r();
       })
-    );
+    ), u = ee(() => {
+      r();
+    });
     return () => {
-      e && clearTimeout(e), l.forEach((c) => c());
+      e && clearTimeout(e), l.forEach((t) => t()), u();
     };
-  }, [n, p, D]), x(() => {
+  }, [o, f, k]), x(() => {
     if (S.current === 0) return;
-    const t = requestAnimationFrame(() => {
+    const n = requestAnimationFrame(() => {
       const e = E.current?.querySelector(
         '[data-component="nested-list"] .overflow-y-auto'
       );
       e && (e.scrollTop = S.current, S.current = 0);
     });
-    return () => cancelAnimationFrame(t);
-  }, [w]);
-  const U = a(
-    (t) => {
-      const e = [], o = (l, c) => {
-        l.forEach((r) => {
-          if (r.id === "root-frozen") {
-            r.children && o(r.children, "left");
+    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;
           }
-          if (r.id === "root-scrollable") {
-            r.children && o(r.children, null);
+          if (t.id === "root-scrollable") {
+            t.children && r(t.children, null);
             return;
           }
-          if (r.category === "group" || r.children && r.children.length > 0)
-            r.children && o(r.children, c);
+          if (t.category === "group" || t.children && t.children.length > 0)
+            t.children && r(t.children, u);
           else {
-            let u;
-            if (c === null)
-              u = null;
+            let c;
+            if (u === null)
+              c = null;
             else {
-              const f = r.data?.pinned;
-              u = f === "left" || f === "right" ? f : c;
+              const d = t.data?.pinned;
+              c = d === "left" || d === "right" ? d : u;
             }
             e.push({
-              colId: r.id,
-              pinned: u,
-              hide: !r.checked
+              colId: t.id,
+              pinned: c,
+              hide: !t.checked
             });
           }
         });
       };
-      return o(t, null), e;
+      return r(n, null), e;
     },
     []
-  ), I = a(
-    (t) => {
-      if (!n) return;
+  ), g = a(
+    (n) => {
+      if (!o) return;
       i.current = !0;
-      const e = U(t);
+      const e = w(n);
       if (e.length === 0) {
-        b(() => {
+        v(() => {
           i.current = !1;
         });
         return;
       }
-      const o = n.getColumnState(), l = L(o, e), c = new Set(
-        o.filter((s) => q(s.pinned)).map((s) => s.colId)
-      ), r = l.filter(
-        (s) => q(s.pinned) && !c.has(s.colId)
-      ), d = new Set(r.map((s) => s.colId));
-      n.applyColumnState({ state: l, applyOrder: !0 });
-      const u = () => {
-        i.current = !1, p("handleChanges:releaseLockAndSync");
+      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();
       };
-      if (d.size === 0) {
-        b(u);
+      if (p.size === 0) {
+        v(c);
         return;
       }
-      let T = !1, f = null, G = null;
-      G = j(n, "columnPinned", () => {
-        if (T || n.isDestroyed()) return;
-        const s = n.getColumnState();
-        if (r.filter((R) => {
-          const m = s.find((F) => F.colId === R.colId);
+      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;
         }).length > 0) {
-          T = !0, f && clearTimeout(f), G?.();
-          const R = l.filter(
-            (m) => m.pinned && !d.has(m.colId)
+          b = !0, d && clearTimeout(d), P?.();
+          const T = l.filter(
+            (m) => m.pinned && !p.has(m.colId)
           );
-          if (R.length > 0) {
-            const m = R[0], F = l.map(
-              (k) => k.colId === m.colId ? { ...k, pinned: null } : k
+          if (T.length > 0) {
+            const m = T[0], F = l.map(
+              (M) => M.colId === m.colId ? { ...M, pinned: null } : M
             );
-            n.applyColumnState({ state: F, applyOrder: !0 });
+            o.applyColumnState({ state: F, applyOrder: !0 });
           }
-          b(u);
+          v(c);
         }
-      }), f = setTimeout(() => {
-        G?.(), T || u();
-      }, H);
+      }), d = setTimeout(() => {
+        P?.(), b || c();
+      }, J);
     },
-    [n, U, p]
+    [o, w, f]
   ), X = a(
-    (t) => {
-      I(N(t));
+    (n) => {
+      g(L(n));
     },
-    [I]
+    [g]
   ), Y = a(
-    (t, e) => {
-      const o = N(t);
-      e || I(o), v(o);
-      const l = z(o);
-      y.current = l.structural, P.current = l.indicators;
+    (n, e) => {
+      const r = L(n);
+      e || g(r), R(r);
+      const l = z(r);
+      y.current = l.structural, G.current = l.indicators;
     },
-    [I]
-  ), $ = a(
-    (t, e) => {
-      if (v((c) => {
-        const r = (d) => d.map((u) => u.id === t ? {
-          ...u,
+    [g]
+  ), H = a(
+    (n, e) => {
+      if (R((u) => {
+        const t = (p) => p.map((c) => c.id === n ? {
+          ...c,
           data: {
-            ...u.data,
+            ...c.data,
             pinned: e
           }
-        } : u.children ? {
-          ...u,
-          children: r(u.children)
-        } : u);
-        return r(c);
-      }), !n) return;
+        } : c.children ? {
+          ...c,
+          children: t(c.children)
+        } : c);
+        return t(u);
+      }), !o) return;
       i.current = !0;
-      const o = n.getColumnState(), l = L(o, [
-        { colId: t, pinned: e }
+      const r = o.getColumnState(), l = N(r, [
+        { colId: n, pinned: e }
       ]);
-      n.applyColumnState({ state: l, applyOrder: !0 }), b(() => {
-        i.current = !1, Q(n, t) !== e && p("handlePinChange");
+      o.applyColumnState({ state: l, applyOrder: !0 }), v(() => {
+        i.current = !1, Z(o, n) !== e && f();
       });
     },
-    [n, p]
+    [o, f]
   );
   return {
     items: K,
     isReady: V,
-    externalSyncKey: w,
+    externalSyncKey: _,
     listWrapperRef: E,
     handleChange: Y,
     handleSubmit: X,
-    handlePinChange: $
+    handlePinChange: H
   };
 }
 export {
-  se as useDataTableColumnListSync
+  ie as useDataTableColumnListSync
 };

package/dist/components/data/nested-list/nested-list-change-detection.d.ts

@@ -0,0 +1,11 @@
+import { NestedListItem } from './nested-list.types';
+/** Above this count, apply/discard uses O(1) revision tracking instead of JSON comparison. */
+export declare const NESTED_LIST_REVISION_THRESHOLD = 1000;
+export declare function shouldUseNestedListRevisionTracking(itemCount: number): boolean;
+export declare function computeNestedListHasChanges(options: {
+    enableApplyDiscard: boolean;
+    items: NestedListItem[];
+    savedItems: NestedListItem[];
+    revision: number;
+    savedRevision: number;
+}): boolean;

package/dist/components/data/nested-list/nested-list-change-detection.js

@@ -0,0 +1,13 @@
+const S = 1e3;
+function o(e) {
+  return e > 1e3;
+}
+function a(e) {
+  const { enableApplyDiscard: i, items: s, savedItems: n, revision: t, savedRevision: r } = e;
+  return i ? o(s.length) ? t !== r : JSON.stringify(s) !== JSON.stringify(n) : !1;
+}
+export {
+  S as NESTED_LIST_REVISION_THRESHOLD,
+  a as computeNestedListHasChanges,
+  o as shouldUseNestedListRevisionTracking
+};