impact-nova 2.6.0-alpha.0 → 2.6.0

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

@@ -1,22 +1,26 @@
-import { GridApi } from 'ag-grid-community';
+import { ColumnState, GridApi } from 'ag-grid-community';
 import { NestedListItem } from '../nested-list/nested-list.types';
 import { BuildColumnTreeLabels } from './build-column-tree-from-grid';
 import { ColumnListSyncFingerprints, ColumnListSyncMode } from './data-table-column-list-sync';
+import { ColumnPickerAuthority } from './column-picker-authority';
+export type ColumnPickerMode = 'tree' | 'authority-flat';
 interface ColumnTreeCacheEntry {
     fingerprints: ColumnListSyncFingerprints;
     items: NestedListItem[];
+    pickerMode: ColumnPickerMode;
+    authority: ColumnPickerAuthority | null;
     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 hasColumnTreeCache(gridApi: GridApi): boolean;
+/** Column counts at or above this threshold prewarm immediately instead of on idle. */
+export declare const LARGE_COLUMN_PREWARM_THRESHOLD = 5000;
 export declare function readColumnTreeCache(gridApi: GridApi, labels: BuildColumnTreeLabels): ColumnTreeCacheEntry | null;
 export declare function writeColumnTreeCache(gridApi: GridApi, rootItems: NestedListItem[]): ColumnListSyncFingerprints;
+export declare function writeColumnTreeAuthorityCache(gridApi: GridApi, authority: ColumnPickerAuthority): 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.
@@ -27,13 +31,15 @@ export declare function buildColumnTreeWithCache(gridApi: GridApi, labels: Build
  * ({@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 isGridColumnSetDifferentFromCachedLeaves(gridApi: GridApi, cachedLeafColumnIds: ReadonlySet<string>, precomputedColumnState?: ColumnState[]): boolean;
 export declare function resolveColumnTreeFromCacheOrGrid(options: {
     gridApi: GridApi;
     labels: BuildColumnTreeLabels;
     previousFingerprints: ColumnListSyncFingerprints;
 }): {
     rootItems: NestedListItem[] | null;
+    authority: ColumnPickerAuthority | null;
+    pickerMode: ColumnPickerMode;
     syncMode: ColumnListSyncMode;
     fingerprints: ColumnListSyncFingerprints;
 };

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

@@ -1,187 +1,306 @@
-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 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 d(i) {
-  return i.map((n) => {
-    const e = V(n.pinned) ?? "0";
-    return `${n.colId}:${e}`;
-  }).join("|");
-}
-function m(i) {
-  return i.map((n) => `${n.colId}:${n.hide ? "0" : "1"}`).join("|");
-}
-function H(i) {
-  return d(i.getColumnState());
-}
-function O(i) {
-  return m(i.getColumnState());
-}
-const p = /* @__PURE__ */ new WeakMap(), h = {
+import { buildColumnTreeFromGrid as W } from "./build-column-tree-from-grid.js";
+import { computeColumnListSyncFingerprints as U } from "./data-table-column-list-sync.js";
+import { fingerprintGridColumnIndicators as g, normalizeColumnPinned as x } from "./data-table-column-apply.js";
+import { isPickerEligibleColumnId as Z } from "./data-table-picker-column-eligibility.js";
+import { patchColumnTreeIndicatorsFromGrid as w } from "./patch-column-tree-indicators-from-grid.js";
+import { patchColumnTreeVisibilityFromGrid as G } from "./patch-column-tree-visibility-from-grid.js";
+import { Fnv1a128Hasher as V } from "../../../lib/hash/fnv1a128.js";
+import { buildAuthorityFromGrid as k, fingerprintAuthority as j } from "./column-picker-authority.js";
+import { buildAuthorityFlatShellItems as y, isFlatLargeColumnPicker as D } from "./data-table-flat-column-virtual-rows.js";
+import { NESTED_LIST_ROOT_FROZEN_ID as O, NESTED_LIST_ROOT_SCROLLABLE_ID as R } from "../nested-list/nested-list-constants.js";
+function m(e) {
+  const i = new V();
+  for (const r of e) {
+    const n = x(r.pinned) ?? "0";
+    i.update(r.colId).update(":").update(n).update("|");
+  }
+  return i.digest();
+}
+function p(e) {
+  const i = new V();
+  for (const r of e)
+    i.update(r.colId).update(":").update(r.hide ? "0" : "1").update("|");
+  return i.digest();
+}
+function ut(e) {
+  return m(e.getColumnState());
+}
+function lt(e) {
+  return p(e.getColumnState());
+}
+const C = /* @__PURE__ */ new WeakMap(), S = {
   frozenColumns: "__prewarm_frozen__",
   scrollableColumns: "__prewarm_scrollable__"
-};
-function I(i) {
-  return typeof i.isDestroyed == "function" && i.isDestroyed();
+}, L = 5e3;
+function B(e) {
+  return typeof e.isDestroyed == "function" && e.isDestroyed();
 }
-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 T(e, i) {
+  return e.map((r) => r.id === O ? { ...r, label: i.frozenColumns } : r.id === R ? { ...r, label: i.scrollableColumns } : r);
 }
-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);
+function J(e) {
+  const i = /* @__PURE__ */ new Set(), r = (n) => {
+    for (const t of n) {
+      if (t.id === O || t.id === R) {
+        t.children && r(t.children);
         continue;
       }
       if (t.children && t.children.length > 0) {
-        e(t.children);
+        r(t.children);
         continue;
       }
-      t.id && n.add(t.id);
+      t.id && i.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(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 D(i, n) {
-  if (I(i))
+  return r(e), i;
+}
+function v(e, i) {
+  const r = C.get(e);
+  if (!r)
+    return null;
+  const n = r.pickerMode === "authority-flat" && r.authority ? y(r.authority, i) : T(r.items, i);
+  return {
+    fingerprints: r.fingerprints,
+    items: n,
+    pickerMode: r.pickerMode,
+    authority: r.authority,
+    gridLayoutFingerprint: r.gridLayoutFingerprint,
+    gridVisibilityFingerprint: r.gridVisibilityFingerprint,
+    leafColumnIds: r.leafColumnIds
+  };
+}
+function f(e, i) {
+  const r = U(i), n = {
+    layout: r.layout,
+    visibility: r.visibility,
+    indicators: g(e)
+  }, t = e.getColumnState(), o = J(i);
+  return C.set(e, {
+    fingerprints: n,
+    items: T(i, S),
+    pickerMode: "tree",
+    authority: null,
+    gridLayoutFingerprint: m(t),
+    gridVisibilityFingerprint: p(t),
+    leafColumnIds: o
+  }), n;
+}
+function M(e, i) {
+  const r = j(i), n = {
+    layout: r.layout,
+    visibility: r.visibility,
+    indicators: g(e)
+  }, t = e.getColumnState(), o = new Set(i.orderedColumnIds);
+  return C.set(e, {
+    fingerprints: n,
+    items: y(i, S),
+    pickerMode: "authority-flat",
+    authority: i,
+    gridLayoutFingerprint: m(t),
+    gridVisibilityFingerprint: p(t),
+    leafColumnIds: o
+  }), n;
+}
+function K(e) {
+  const i = k(e);
+  if (i) {
+    if (D(i, L)) {
+      M(e, i);
+      return;
+    }
+    z(e, S);
+  }
+}
+function z(e, i) {
+  const r = W(e, i);
+  return r ? (f(e, r), r) : null;
+}
+function A(e, i, r) {
+  if (B(e))
     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)))
+  const n = r ?? e.getColumnState();
+  let t = 0;
+  for (const o of n)
+    if (Z(o.colId) && (t += 1, !i.has(o.colId)))
       return !0;
-  return r !== n.size;
-}
-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 s = u(n, o);
-        return {
-          rootItems: o,
+  return t !== i.size;
+}
+function at(e) {
+  const { gridApi: i, labels: r, previousFingerprints: n } = e, t = v(i, r), o = i.getColumnState(), b = m(o), I = p(o), F = n.layout === "" && n.visibility === "" && n.indicators === "";
+  if (t != null && !A(i, t.leafColumnIds, o) && t) {
+    const l = b !== t.gridLayoutFingerprint, c = I !== t.gridVisibilityFingerprint, d = g(i) !== t.fingerprints.indicators;
+    if (!l && !c && !d) {
+      if (t.pickerMode === "authority-flat" && t.authority)
+        return F ? {
+          rootItems: y(t.authority, r),
+          authority: t.authority,
+          pickerMode: "authority-flat",
           syncMode: "structural",
-          fingerprints: s
+          fingerprints: t.fingerprints
+        } : n.layout !== t.fingerprints.layout || n.visibility !== t.fingerprints.visibility || n.indicators !== t.fingerprints.indicators ? {
+          rootItems: t.items,
+          authority: t.authority,
+          pickerMode: "authority-flat",
+          syncMode: "structural",
+          fingerprints: t.fingerprints
+        } : {
+          rootItems: null,
+          authority: t.authority,
+          pickerMode: "authority-flat",
+          syncMode: "skip",
+          fingerprints: t.fingerprints
         };
-      }
-      if (r.layout !== t.fingerprints.layout || r.visibility !== t.fingerprints.visibility || r.indicators !== t.fingerprints.indicators) {
-        const s = u(n, o);
+      if (F) {
+        const u = T(t.items, r), E = w(
+          u,
+          i
+        ), N = f(i, E);
         return {
-          rootItems: o,
-          syncMode: "structural",
-          fingerprints: s
+          rootItems: E,
+          authority: null,
+          pickerMode: "tree",
+          syncMode: "indicators-only",
+          fingerprints: N
         };
       }
-      return {
+      return n.layout !== t.fingerprints.layout || n.visibility !== t.fingerprints.visibility || n.indicators !== t.fingerprints.indicators ? {
+        rootItems: t.items,
+        authority: null,
+        pickerMode: "tree",
+        syncMode: "structural",
+        fingerprints: t.fingerprints
+      } : {
         rootItems: null,
+        authority: null,
+        pickerMode: "tree",
         syncMode: "skip",
         fingerprints: t.fingerprints
       };
     }
-    if (!c && a && !f) {
-      const l = C(
-        o,
-        n
-      ), s = u(n, l);
+    if (t.pickerMode === "authority-flat" && t.authority) {
+      const s = k(i);
+      if (s) {
+        const u = M(i, s);
+        return {
+          rootItems: y(s, r),
+          authority: s,
+          pickerMode: "authority-flat",
+          syncMode: l ? "structural" : c ? "visibility-only" : "indicators-only",
+          fingerprints: u
+        };
+      }
+    }
+    const h = d ? w(t.items, i) : t.items;
+    if (!l && c && !d) {
+      const s = G(
+        h,
+        i
+      ), u = f(i, s);
       return {
-        rootItems: l,
+        rootItems: s,
+        authority: null,
+        pickerMode: "tree",
         syncMode: "visibility-only",
-        fingerprints: s
+        fingerprints: u
       };
     }
-    if (!c && !a && f) {
-      const l = u(n, o);
+    if (!l && !c && d) {
+      const s = f(i, h);
       return {
-        rootItems: o,
+        rootItems: h,
+        authority: null,
+        pickerMode: "tree",
         syncMode: "indicators-only",
-        fingerprints: l
+        fingerprints: s
       };
     }
-    if (!c && a && f) {
-      const l = C(
-        o,
-        n
-      ), s = u(n, l);
+    if (!l && c && d) {
+      const s = G(
+        h,
+        i
+      ), u = f(i, s);
       return {
-        rootItems: l,
+        rootItems: s,
+        authority: null,
+        pickerMode: "tree",
         syncMode: "visibility-only",
-        fingerprints: s
+        fingerprints: u
       };
     }
   }
-  const g = v(n, e);
-  if (!g)
+  const a = k(i);
+  if (a && D(a, L)) {
+    const l = M(i, a);
+    return {
+      rootItems: y(a, r),
+      authority: a,
+      pickerMode: "authority-flat",
+      syncMode: "structural",
+      fingerprints: l
+    };
+  }
+  const _ = z(i, r);
+  if (!_)
     return {
       rootItems: null,
+      authority: null,
+      pickerMode: "tree",
       syncMode: "skip",
-      fingerprints: r
+      fingerprints: n
     };
-  const G = b(n, e)?.fingerprints ?? {
+  const H = v(i, r)?.fingerprints ?? {
     layout: "",
     visibility: "",
     indicators: ""
   };
   return {
-    rootItems: g,
+    rootItems: _,
+    authority: null,
+    pickerMode: "tree",
     syncMode: "structural",
-    fingerprints: G
+    fingerprints: H
   };
 }
-function q(i) {
-  return typeof i.getColumnState == "function" && (typeof i.getAllGridColumns == "function" || typeof i.getColumns == "function");
+function P(e) {
+  return typeof e.getColumnState == "function" && (typeof e.getAllGridColumns == "function" || typeof e.getColumns == "function");
 }
-function J(i) {
-  return $(i).syncMode === "skip";
+function ct(e) {
+  const { gridApi: i, labels: r, previousFingerprints: n } = e, t = v(i, r);
+  if (!t)
+    return !1;
+  const o = i.getColumnState();
+  if (A(
+    i,
+    t.leafColumnIds,
+    o
+  ))
+    return !1;
+  const b = m(o), I = p(o);
+  return b !== t.gridLayoutFingerprint || I !== t.gridVisibilityFingerprint || g(i) !== t.fingerprints.indicators ? !1 : !(n.layout !== t.fingerprints.layout || n.visibility !== t.fingerprints.visibility || n.indicators !== t.fingerprints.indicators);
 }
-function K(i) {
-  let n = !1, e = 0, r;
+function dt(e) {
+  let i = !1, r = 0, n;
   const t = () => {
-    n || I(i) || !q(i) || p.has(i) || v(i, h);
+    i || B(e) || !P(e) || C.has(e) || K(e);
   };
-  return e = requestAnimationFrame(() => {
-    n || (typeof requestIdleCallback < "u" ? r = requestIdleCallback(t, { timeout: 3e3 }) : setTimeout(t, 0));
+  return P(e) && e.getColumnState().length >= L ? (queueMicrotask(t), () => {
+    i = !0;
+  }) : (r = requestAnimationFrame(() => {
+    i || (typeof requestIdleCallback < "u" ? n = requestIdleCallback(t, { timeout: 3e3 }) : setTimeout(t, 0));
   }), () => {
-    n = !0, e && cancelAnimationFrame(e), r !== void 0 && typeof cancelIdleCallback < "u" && cancelIdleCallback(r);
-  };
+    i = !0, r && cancelAnimationFrame(r), n !== void 0 && typeof cancelIdleCallback < "u" && cancelIdleCallback(n);
+  });
 }
 export {
-  v as buildColumnTreeWithCache,
-  D as isGridColumnSetDifferentFromCachedLeaves,
-  J as peekColumnListSyncWouldSkip,
-  b as readColumnTreeCache,
-  H as readGridLayoutFingerprint,
-  O as readGridVisibilityFingerprint,
-  $ as resolveColumnTreeFromCacheOrGrid,
-  K as scheduleColumnTreePrewarm,
-  u as writeColumnTreeCache
+  L as LARGE_COLUMN_PREWARM_THRESHOLD,
+  z as buildColumnTreeWithCache,
+  A as isGridColumnSetDifferentFromCachedLeaves,
+  ct as peekColumnListSyncWouldSkip,
+  v as readColumnTreeCache,
+  ut as readGridLayoutFingerprint,
+  lt as readGridVisibilityFingerprint,
+  at as resolveColumnTreeFromCacheOrGrid,
+  dt as scheduleColumnTreePrewarm,
+  M as writeColumnTreeAuthorityCache,
+  f as writeColumnTreeCache
 };

package/dist/components/data/data-table/data-table-context.js

@@ -1,14 +1,14 @@
-import { useContext as e, createContext as a } from "react";
+import { createContext as e, useContext as a } from "react";
 import { useDataTableSheetPortalSnapshot as s } from "./data-table-sheet-portal-store.js";
-const n = a(
+const n = e(
   null
-), l = a(null), b = () => {
-  const t = e(n);
+), l = e(null), b = () => {
+  const t = a(n);
   if (!t)
     throw new Error("useDataTable must be used within a DataTable");
   return t;
 }, u = () => {
-  const t = e(l);
+  const t = a(l);
   if (!t)
     throw new Error(
       "useDataTableSheetPortalStore must be used within a DataTable"

package/dist/components/data/data-table/data-table-flat-column-virtual-rows.d.ts

@@ -0,0 +1,27 @@
+import { FlatNestedListRow } from '../nested-list/nested-list-virtual-drop';
+import { NestedListItem } from '../nested-list/nested-list.types';
+import { ColumnPickerAuthority } from './column-picker-authority';
+import { BuildColumnTreeLabels } from './build-column-tree-from-grid';
+export interface FlatColumnVirtualRowModelOptions {
+    searchQuery?: string;
+    sortAppliedByColumnId?: ReadonlyMap<string, boolean>;
+    filterAppliedByColumnId?: ReadonlyMap<string, boolean>;
+    nonSavableByColumnId?: ReadonlyMap<string, boolean>;
+}
+export interface FlatColumnVirtualRowModel {
+    rowCount: number;
+    frozenColumnIds: readonly string[];
+    scrollableColumnIds: readonly string[];
+    getRowAt: (index: number) => FlatNestedListRow;
+    getColumnIdAt: (index: number) => string | null;
+    findFlatIndexByColumnId: (columnId: string) => number;
+}
+export declare function buildFlatColumnVirtualRowModel(authority: ColumnPickerAuthority, labels: BuildColumnTreeLabels, options?: FlatColumnVirtualRowModelOptions): FlatColumnVirtualRowModel;
+export declare function buildAuthorityFlatShellItems(authority: ColumnPickerAuthority, labels: BuildColumnTreeLabels): NestedListItem[];
+export declare function isFlatLargeColumnPicker(authority: ColumnPickerAuthority, threshold: number): boolean;
+export interface FlatVirtualDropToAuthorityOptions {
+    draggedColumnId: string;
+    overId: string;
+    insertAfter: boolean;
+}
+export declare function applyFlatVirtualDropToAuthority(authority: ColumnPickerAuthority, rowModel: FlatColumnVirtualRowModel, options: FlatVirtualDropToAuthorityOptions): ColumnPickerAuthority | null;