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

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

@@ -0,0 +1,95 @@
+import { resolveColumnPinnedFromGridState as O } from "./data-table-column-apply.js";
+function x(t) {
+  const i = [];
+  let l = t.getOriginalParent();
+  for (; l; ) {
+    const f = l.getColGroupDef();
+    f?.headerName && f?.children && i.push(l), l = l.getOriginalParent();
+  }
+  return i.reverse(), i;
+}
+function T(t, i) {
+  const l = t.getColumnState(), f = t.getGridOption("context"), y = typeof f?.activeSearchColumnId == "string" ? f.activeSearchColumnId : null, z = t.getAllGridColumns?.() ?? t.getColumns() ?? [], N = new Map(
+    z.map((o) => [o.getColId(), o])
+  ), h = [], m = [], G = /* @__PURE__ */ new Map(), v = /* @__PURE__ */ new Map(), p = /* @__PURE__ */ new Map();
+  p.set(h, "f"), p.set(m, "s");
+  let _ = 0;
+  const w = (o) => {
+    let e = p.get(o);
+    return e === void 0 && (e = `n${_++}`, p.set(o, e)), e;
+  }, F = (o, e) => {
+    const n = o.getGroupId(), r = w(e), d = `${n}::${r}`, u = G.get(d);
+    if (u && u.list === e && e[e.length - 1] === u.node)
+      return u.node;
+    const c = v.get(d) || 0;
+    v.set(d, c + 1);
+    const C = o.getColGroupDef(), a = {
+      id: c === 0 ? `${n}__${r}` : `${n}__${r}__${c}`,
+      label: C?.headerName || n,
+      checked: !0,
+      children: [],
+      category: "group"
+    };
+    return e.push(a), G.set(d, { list: e, node: a }), a;
+  };
+  let g = 0, S = 0, I = 0, $ = 0;
+  l.forEach((o) => {
+    const e = N.get(o.colId) ?? t.getColumn(o.colId);
+    if (!e) return;
+    let n = t.getDisplayNameForColumn(e, "header");
+    if (n === "") return;
+    if (n == null) {
+      const s = e.getColDef();
+      if (s.headerName === "") return;
+      n = s.headerName || s.field || o.colId;
+    }
+    if (!n || n.trim() === "")
+      return;
+    const r = !o.hide, d = !!o.sort, u = e.isFilterActive() || y === o.colId, c = O(o, e), C = {
+      id: o.colId,
+      label: n,
+      checked: r,
+      data: {
+        hasSortApplied: d,
+        hasFilterApplied: u,
+        pinned: c
+      }
+    };
+    c ? (g++, r && S++) : (I++, r && $++);
+    const k = c ? h : m, a = x(e);
+    if (a.length > 0) {
+      let s = k, D = null;
+      for (const M of a)
+        D = F(M, s), s = D.children;
+      D.children.push(C);
+    } else
+      k.push(C);
+  });
+  const b = (o) => {
+    let e = o.length > 0;
+    for (const n of o)
+      n.children && (n.checked = b(n.children)), n.checked || (e = !1);
+    return e;
+  };
+  return b(h), b(m), [
+    {
+      id: "root-frozen",
+      label: i.frozenColumns,
+      checked: g > 0 && S === g,
+      children: h,
+      category: "structure",
+      isDragDisabled: !0
+    },
+    {
+      id: "root-scrollable",
+      label: i.scrollableColumns,
+      checked: I > 0 && $ === I,
+      children: m,
+      category: "structure",
+      isDragDisabled: !0
+    }
+  ];
+}
+export {
+  T as buildColumnTreeFromGrid
+};

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

@@ -0,0 +1,29 @@
+import { Column, ColumnPinnedType, ColumnState, GridApi } from 'ag-grid-community';
+import { NestedListItem } from '../nested-list/nested-list.types';
+/** Debounce window for coalescing external grid column events into one UI sync. */
+export declare const EXTERNAL_SYNC_DEBOUNCE_MS = 150;
+/**
+ * Fallback when AG Grid may asynchronously reject a new pin (pinned viewport full).
+ * Event-driven detection is primary; this only covers the "no rejection fired" path.
+ */
+export declare const GRID_AUTO_UNPIN_WAIT_MS = 300;
+export type NormalizedColumnPin = 'left' | 'right' | null;
+export declare function normalizeColumnPinned(pinned: ColumnPinnedType | boolean | null | undefined): NormalizedColumnPin;
+/**
+ * Prefer runtime column state from `getColumnState()`. Only fall back to
+ * `column.getPinned()` when the state object omits `pinned` entirely.
+ */
+export declare function resolveColumnPinnedFromGridState(state: ColumnState, column: Column): NormalizedColumnPin;
+export declare function readGridColumnPinned(gridApi: GridApi, columnId: string): NormalizedColumnPin;
+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[];
+/** 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. */
+export declare function fingerprintColumnTreeIndicators(items: NestedListItem[]): string;
+/**
+ * Run after `applyColumnState` returns. AG Grid applies pin/order/hide synchronously;
+ * `queueMicrotask` lets any same-turn grid events finish before we release the panel lock.
+ */
+export declare function afterSynchronousColumnApply(onSettled: () => void): void;

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

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

package/dist/components/data/data-table/data-table-column-def-pin.d.ts

@@ -0,0 +1,25 @@
+import { ColDef, ColGroupDef, GridState } from 'ag-grid-community';
+export interface ExtractedColumnPinning {
+    leftColIds: string[];
+    rightColIds: string[];
+}
+export interface ExtractedColumnVisibility {
+    hiddenColIds: string[];
+}
+export interface ExtractedColumnRuntimeDefaults {
+    columnPinning: ExtractedColumnPinning;
+    columnVisibility: ExtractedColumnVisibility;
+}
+export interface RuntimeColumnDefsResult {
+    runtimeColumnDefs: (ColDef | ColGroupDef)[];
+    extractedRuntimeDefaults: ExtractedColumnRuntimeDefaults;
+}
+/**
+ * AG Grid reapplies `colDef.pinned` / `colDef.hide` on column-definition refresh.
+ * User changes belong in runtime column state / `initialState`, not on defs.
+ */
+export declare function extractRuntimeColumnDefs(columnDefs: (ColDef | ColGroupDef)[] | undefined): RuntimeColumnDefsResult;
+/** @deprecated Use `extractedRuntimeDefaults.columnPinning` from `extractRuntimeColumnDefs`. */
+export declare function getExtractedColumnPinning(result: RuntimeColumnDefsResult): ExtractedColumnPinning;
+export declare function mergeInitialColumnPinningState(userInitialState: GridState | undefined, extractedColumnPinning: ExtractedColumnPinning): GridState | undefined;
+export declare function mergeInitialGridRuntimeState(userInitialState: GridState | undefined, extractedRuntimeDefaults: ExtractedColumnRuntimeDefaults): GridState | undefined;

package/dist/components/data/data-table/data-table-column-def-pin.js

@@ -0,0 +1,66 @@
+function d(n) {
+  const i = n.colId ?? n.field;
+  return typeof i == "string" && i.length > 0 ? i : void 0;
+}
+function s(n, i, r) {
+  if (i === "left" || i === !0) {
+    r.leftColIds.push(n);
+    return;
+  }
+  i === "right" && r.rightColIds.push(n);
+}
+function h(n, i) {
+  const r = d(n);
+  if (r && (n.pinned != null && s(r, n.pinned, i.columnPinning), n.hide === !0 && i.columnVisibility.hiddenColIds.push(r)), n.pinned === void 0 && n.hide === void 0)
+    return n;
+  const { pinned: e, hide: t, ...o } = n;
+  return o;
+}
+function u(n, i) {
+  let r = !1;
+  const e = n.map((t) => {
+    if ("children" in t && t.children) {
+      const l = u(
+        t.children,
+        i
+      );
+      return l === t.children ? t : (r = !0, {
+        ...t,
+        children: l
+      });
+    }
+    const o = h(
+      t,
+      i
+    );
+    return o !== t && (r = !0), o;
+  });
+  return r ? e : n;
+}
+function c() {
+  return {
+    columnPinning: { leftColIds: [], rightColIds: [] },
+    columnVisibility: { hiddenColIds: [] }
+  };
+}
+function m(n) {
+  const i = c();
+  return !n || n.length === 0 ? { runtimeColumnDefs: [], extractedRuntimeDefaults: i } : {
+    runtimeColumnDefs: u(
+      n,
+      i
+    ),
+    extractedRuntimeDefaults: i
+  };
+}
+function g(n, i) {
+  const r = i.columnPinning.leftColIds.length > 0 || i.columnPinning.rightColIds.length > 0, e = i.columnVisibility.hiddenColIds.length > 0;
+  if (!n && !r && !e)
+    return;
+  const t = { ...n };
+  return !n?.columnPinning && r && (t.columnPinning = i.columnPinning), !n?.columnVisibility && e && (t.columnVisibility = i.columnVisibility), !t.columnPinning && !t.columnVisibility && Object.keys(t).length === 0 ? n : Object.keys(t).length > 0 ? t : void 0;
+}
+export {
+  m as extractRuntimeColumnDefs,
+  g as mergeInitialGridRuntimeState
+};

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

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

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

@@ -0,0 +1,15 @@
+import { fingerprintColumnTreeIndicators as u, fingerprintColumnTreeItems as s } from "./data-table-column-apply.js";
+function c(n) {
+  return {
+    structural: s(n),
+    indicators: u(n)
+  };
+}
+function l(n, t, i) {
+  const r = c(n), e = r.structural !== t, o = r.indicators !== i;
+  return e ? "structural" : o ? "indicators-only" : "skip";
+}
+export {
+  c as computeColumnListSyncFingerprints,
+  l as resolveColumnListSyncMode
+};

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

@@ -1,8 +1,18 @@
-interface DataTableColumnListProps {
+/**
+ * Column visibility, order, and pin picker backed by AG Grid `gridApi`.
+ * Must render inside `DataTable` (reads `useDataTable().gridApi`).
+ */
+export type DataTableColumnListProps = {
+    /**
+     * When `true`, column changes stay staged until the user clicks Apply (Discard resets).
+     * When `false` (default), visibility, order, and pin updates apply to the grid immediately.
+     */
     enableApplyDiscard?: boolean;
+    /** Show the search field that filters the column tree. Default `true`. */
     showSearch?: boolean;
+    /** Show the select-all control for column visibility. Default `true`. */
     showSelectAll?: boolean;
+    /** Show collapse/expand controls on nested column group headers. Default `true`. */
     showCollapse?: boolean;
-}
-export declare const DataTableColumnList: ({ enableApplyDiscard, showSearch, showSelectAll, showCollapse }: DataTableColumnListProps) => import("react/jsx-runtime").JSX.Element;
-export {};
+};
+export declare const DataTableColumnList: ({ enableApplyDiscard, showSearch, showSelectAll, showCollapse, }: DataTableColumnListProps) => import("react/jsx-runtime").JSX.Element;