impact-nova 2.0.9 → 2.1.0-alpha.10

package/dist/components/data/ag-grid-react/value-formatter.types.d.ts

@@ -0,0 +1,61 @@
+import { ColDef, ValueFormatterParams } from 'ag-grid-community';
+export type FormatterFormatType = 'full_no' | 'thou' | 'mil' | 'bil' | 'full_precision';
+export interface FormatterGridContext {
+    formatType?: FormatterFormatType;
+    nullDisplay?: string;
+    currency?: string;
+    decimals?: number;
+    locale?: string;
+    [key: string]: unknown;
+}
+export interface BackendFormatterConfigBase {
+    type?: string;
+    nullDisplay?: string;
+    locale?: string;
+    formatType?: FormatterFormatType;
+    decimals?: number;
+    currency?: string;
+    symbol?: string;
+    position?: 'prefix' | 'suffix';
+    divideBy?: number;
+    dateStyle?: Intl.DateTimeFormatOptions['dateStyle'];
+    timeStyle?: Intl.DateTimeFormatOptions['timeStyle'];
+    trueValue?: string;
+    falseValue?: string;
+}
+export interface BackendValueFormatterObject extends BackendFormatterConfigBase {
+    type: string;
+}
+export interface BackendFormatterColDef extends Omit<ColDef, 'valueFormatter'> {
+    valueFormatter?: string | BackendValueFormatterObject | ColDef['valueFormatter'];
+    nullDisplay?: string;
+    currency?: string;
+    symbol?: string;
+    position?: 'prefix' | 'suffix';
+    decimals?: number;
+    formatType?: FormatterFormatType;
+    divideBy?: number;
+    dateStyle?: Intl.DateTimeFormatOptions['dateStyle'];
+    timeStyle?: Intl.DateTimeFormatOptions['timeStyle'];
+    trueValue?: string;
+    falseValue?: string;
+    locale?: string;
+}
+export declare function isBackendValueFormatterObject(value: unknown): value is BackendValueFormatterObject;
+export declare function getBackendFormatterColDef(params: ValueFormatterParams): BackendFormatterColDef;
+export interface ResolvedFormatterConfig {
+    nullDisplay?: string;
+    locale?: string;
+    formatType?: FormatterFormatType;
+    decimals?: number;
+    currency?: string;
+    symbol?: string;
+    position?: 'prefix' | 'suffix';
+    divideBy?: number;
+    dateStyle?: Intl.DateTimeFormatOptions['dateStyle'];
+    timeStyle?: Intl.DateTimeFormatOptions['timeStyle'];
+    trueValue?: string;
+    falseValue?: string;
+}
+export declare function getFormatterConfig(colDef: BackendFormatterColDef): ResolvedFormatterConfig;
+export declare function getNullDisplay(config: Pick<ResolvedFormatterConfig, 'nullDisplay'>, context?: FormatterGridContext): string;

package/dist/components/data/ag-grid-react/value-formatter.types.js

@@ -0,0 +1,19 @@
+function r(t) {
+  return typeof t == "object" && t !== null && "type" in t && typeof t.type == "string";
+}
+function l(t) {
+  return t.colDef ?? {};
+}
+function i(t) {
+  const { valueFormatter: e, type: o, ...n } = t;
+  return r(e) ? { ...n, ...e } : n;
+}
+function u(t, e) {
+  return t.nullDisplay ?? e?.nullDisplay ?? "-";
+}
+export {
+  l as getBackendFormatterColDef,
+  i as getFormatterConfig,
+  u as getNullDisplay,
+  r as isBackendValueFormatterObject
+};

package/dist/components/data/ag-grid-react/value-formatters.js

@@ -0,0 +1,110 @@
+import { getBackendFormatterColDef as s, getNullDisplay as a, getFormatterConfig as b } from "./value-formatter.types.js";
+const d = (t, e) => {
+  let o, n;
+  return e === "bil" ? (o = t / 1e9, n = "B") : e === "mil" ? (o = t / 1e6, n = "M") : (o = t / 1e3, n = "K"), isNaN(o) || !isFinite(o) ? `0.0${n}` : o.toFixed(1) + n;
+}, N = (t, e) => !e || e === "full_no" || e === "full_precision" ? null : d(t, e), f = (t) => t.context, v = (t) => {
+  const e = b(s(t)), o = f(t);
+  if (t.value == null) return a(e, o);
+  const n = e.currency || "USD", r = e.locale || "en-US", c = o?.formatType || e.formatType, i = Number(t.value);
+  if (isNaN(i)) return String(t.value);
+  const u = N(Math.abs(i), c);
+  if (u) {
+    const l = i < 0 ? "-" : "", m = new Intl.NumberFormat(r, {
+      style: "currency",
+      currency: n
+    }).formatToParts(0).find((F) => F.type === "currency")?.value || n;
+    return `${l}${m}${u}`;
+  }
+  if (c === "full_precision") {
+    const l = i < 0 ? "-" : "", m = new Intl.NumberFormat(r, { style: "currency", currency: n }).formatToParts(0).find((F) => F.type === "currency")?.value || n;
+    return `${l}${m}${new Intl.NumberFormat(r, { minimumFractionDigits: 2, maximumFractionDigits: 20 }).format(Math.abs(i))}`;
+  }
+  return new Intl.NumberFormat(r, {
+    style: "currency",
+    currency: n
+  }).format(i);
+}, D = (t) => {
+  const e = b(s(t)), o = f(t);
+  if (t.value == null) return a(e, o);
+  const n = e.symbol || "$", r = e.position || "prefix", c = e.decimals ?? 2, i = e.locale || "en-US", u = o?.formatType || e.formatType, l = Number(t.value);
+  if (isNaN(l)) return String(t.value);
+  const g = N(Math.abs(l), u);
+  let m;
+  return g ? m = `${l < 0 ? "-" : ""}${g}` : u === "full_precision" ? m = `${l < 0 ? "-" : ""}${new Intl.NumberFormat(i, { minimumFractionDigits: c, maximumFractionDigits: 20 }).format(Math.abs(l))}` : m = new Intl.NumberFormat(i, {
+    minimumFractionDigits: c,
+    maximumFractionDigits: c
+  }).format(l), r === "prefix" ? `${n}${m}` : `${m}${n}`;
+}, x = (t) => {
+  const e = s(t), o = f(t);
+  if (t.value == null) return a(e, o);
+  const n = e.decimals ?? 0, r = e.locale || "en-US", c = o?.formatType || e.formatType, i = Number(t.value);
+  if (isNaN(i)) return String(t.value);
+  const u = N(Math.abs(i), c);
+  return u ? `${i < 0 ? "-" : ""}${u}` : c === "full_precision" ? `${i < 0 ? "-" : ""}${new Intl.NumberFormat(r, { minimumFractionDigits: n, maximumFractionDigits: 20 }).format(Math.abs(i))}` : new Intl.NumberFormat(r, {
+    minimumFractionDigits: n,
+    maximumFractionDigits: n
+  }).format(i);
+}, y = (t) => {
+  const e = s(t), o = f(t);
+  if (t.value == null) return a(e, o);
+  const n = Number(t.value);
+  if (isNaN(n)) return String(t.value);
+  const r = Math.abs(n), c = n < 0 ? "-" : "";
+  return r >= 1e9 ? `${c}${(r / 1e9).toFixed(1)}B` : r >= 1e6 ? `${c}${(r / 1e6).toFixed(1)}M` : r >= 1e3 ? `${c}${(r / 1e3).toFixed(1)}K` : new Intl.NumberFormat("en-US", {
+    maximumFractionDigits: 2
+  }).format(n);
+}, $ = (t) => {
+  const e = s(t), o = f(t);
+  if (t.value == null) return a(e, o);
+  const n = Number(t.value);
+  if (isNaN(n)) return String(t.value);
+  const r = e.decimals ?? 2, c = e.divideBy ?? 100, i = o?.formatType || e.formatType, u = n / c;
+  return i === "full_precision" ? new Intl.NumberFormat("en-US", {
+    style: "percent",
+    minimumFractionDigits: 2,
+    maximumFractionDigits: 20
+  }).format(u) : new Intl.NumberFormat("en-US", {
+    style: "percent",
+    minimumFractionDigits: r,
+    maximumFractionDigits: r
+  }).format(u);
+}, S = (t) => {
+  const e = s(t), o = f(t);
+  if (!t.value) return a(e, o);
+  const n = e.dateStyle || "medium", r = e.locale || "en-US", c = new Date(t.value);
+  return isNaN(c.getTime()) ? String(t.value) : new Intl.DateTimeFormat(r, {
+    dateStyle: n
+  }).format(c);
+}, T = (t) => {
+  const e = s(t), o = f(t);
+  if (!t.value) return a(e, o);
+  const n = e.dateStyle || "medium", r = e.timeStyle || "short", c = e.locale || "en-US", i = new Date(t.value);
+  return isNaN(i.getTime()) ? String(t.value) : new Intl.DateTimeFormat(c, {
+    dateStyle: n,
+    timeStyle: r
+  }).format(i);
+}, w = (t) => {
+  const e = s(t), o = f(t);
+  if (t.value == null) return a(e, o);
+  const n = e.trueValue || "Yes", r = e.falseValue || "No";
+  return t.value ? n : r;
+}, M = {
+  // Currency formatters
+  currency: v,
+  currencySymbol: D,
+  // Number formatters
+  number: x,
+  compact: y,
+  compactNumber: y,
+  largeNumber: y,
+  // Percentage formatter
+  percentage: $,
+  // Date formatters
+  date: S,
+  dateTime: T,
+  // Boolean formatter
+  boolean: w
+};
+export {
+  M as AG_GRID_VALUE_FORMATTERS
+};

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

@@ -0,0 +1,14 @@
+import { GridApi } from 'ag-grid-community';
+import { NestedListItem } from '../nested-list/nested-list.types';
+export interface ColumnItemData extends Record<string, unknown> {
+    hasSortApplied?: boolean;
+    hasFilterApplied?: boolean;
+    pinned?: 'left' | 'right' | null;
+}
+export interface BuildColumnTreeLabels {
+    frozenColumns: string;
+    scrollableColumns: string;
+}
+export declare function buildColumnTreeFromGrid(gridApi: GridApi, labels: BuildColumnTreeLabels): NestedListItem[] | null;
+export declare function findColumnTreeLeaf(items: NestedListItem[], columnId: string): NestedListItem | undefined;
+export declare function countPinnedNestedColumns(gridApi: GridApi, prefix?: string): number;

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/column-indicator.d.ts

@@ -0,0 +1,17 @@
+export type IndicatorType = 'sort' | 'filter' | 'nonSavable';
+interface ColumnIndicatorProps {
+    /** Type of indicator - determines color and label */
+    type: IndicatorType;
+    /** Additional CSS classes */
+    className?: string;
+}
+/**
+ * Small colored badge indicating column state (sorted or filtered).
+ * Uses design tokens for colors and i18n for accessibility labels.
+ *
+ * @example
+ * <ColumnIndicator type="sort" />
+ * <ColumnIndicator type="filter" />
+ */
+export declare const ColumnIndicator: React.FC<ColumnIndicatorProps>;
+export {};

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

@@ -0,0 +1,36 @@
+import { jsx as i } from "react/jsx-runtime";
+import { cn as e } from "../../../lib/utils.js";
+import { useImpactNovaI18n as c } from "../../../i18n/use-impact-nova-i18n.js";
+const s = ({
+  type: l,
+  className: r
+}) => {
+  const { t: a } = c(), t = {
+    sort: {
+      colorClass: "bg-indicator-sort",
+      label: a("dataTable.indicatorSortedAriaLabel")
+    },
+    filter: {
+      colorClass: "bg-indicator-filter",
+      label: a("dataTable.indicatorFilteredAriaLabel")
+    },
+    nonSavable: {
+      colorClass: "bg-content-secondary",
+      label: a("dataTable.indicatorNonSavableAriaLabel")
+    }
+  }, { colorClass: n, label: o } = t[l];
+  return /* @__PURE__ */ i(
+    "span",
+    {
+      role: "img",
+      "data-component": "column-indicator",
+      className: e("w-2 h-2 rounded-[2px] inline-block shrink-0", n, r),
+      title: o,
+      "aria-label": o
+    }
+  );
+};
+s.displayName = "ColumnIndicator";
+export {
+  s as ColumnIndicator
+};

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,30 @@
+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;
+}
+export interface SuppressInitialRuntimeState {
+    columnPinning?: boolean;
+    columnVisibility?: boolean;
+}
+/**
+ * AG Grid reapplies stateful `colDef.pinned` / `colDef.hide` on column-definition
+ * refresh. Apps may pass `pinned` / `hide` (or `initialPinned` / `initialHide`);
+ * DataTable maps them to initial attrs on grid-facing defs and `initialState`.
+ */
+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, suppress?: SuppressInitialRuntimeState): GridState | undefined;
+export declare function mergeInitialGridRuntimeState(userInitialState: GridState | undefined, extractedRuntimeDefaults: ExtractedColumnRuntimeDefaults, suppress?: SuppressInitialRuntimeState): GridState | undefined;

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

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

@@ -0,0 +1,18 @@
+/**
+ * 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;