ag-grid-community 35.3.0 → 36.0.0

package/dist/types/src/columns/columnApi.d.ts

@@ -1,15 +1,14 @@
 import type { BeanCollection } from '../context/context';
 import type { ColDef, ColGroupDef, ColKey, HeaderLocation } from '../entities/colDef';
 import type { Column, ColumnPinnedType } from '../interfaces/iColumn';
-import type { ApplyColumnStateParams, ColumnState } from './columnStateUtils';
-export type ColumnChangedEventType = 'columnValueChanged' | 'columnPivotChanged' | 'columnRowGroupChanged';
+import type { ApplyColumnStateParams } from './columnStateUtils';
 export declare function getColumnDef<TValue = any, TData = any>(beans: BeanCollection, key: string | Column<TValue>): ColDef<TData, TValue> | null;
 export declare function getColumnDefs<TData = any>(beans: BeanCollection): (ColDef<TData> | ColGroupDef<TData>)[] | undefined;
 export declare function getDisplayNameForColumn(beans: BeanCollection, column: Column, location: HeaderLocation): string;
 export declare function getColumn<TValue = any, TData = any>(beans: BeanCollection, key: ColKey<TData, TValue>): Column<TValue> | null;
 export declare function getColumns(beans: BeanCollection): Column[] | null;
 export declare function applyColumnState(beans: BeanCollection, params: ApplyColumnStateParams): boolean;
-export declare function getColumnState(beans: BeanCollection): ColumnState[];
+export declare const getColumnState: (beans: BeanCollection) => import("./columnStateUtils").ColumnState[];
 export declare function resetColumnState(beans: BeanCollection): void;
 export declare function isPinning(beans: BeanCollection): boolean;
 export declare function isPinningLeft(beans: BeanCollection): boolean;

package/dist/types/src/columns/columnDefFactory.d.ts

@@ -1,17 +1,13 @@
 import type { NamedBean } from '../context/bean';
 import { BeanStub } from '../context/beanStub';
 import type { BeanCollection } from '../context/context';
-import type { AgColumn } from '../entities/agColumn';
 import type { ColDef, ColGroupDef } from '../entities/colDef';
 /** @knipIgnore Used in tests */
-export declare function _deepCloneDefinition<T>(object: T, keysToSkip?: string[]): T | undefined;
+export declare function _deepCloneDefinition<T>(object: T, rootKeyToSkip?: string): T | undefined;
 export declare class ColumnDefFactory extends BeanStub implements NamedBean {
     beanName: "colDefFactory";
-    private rowGroupColsSvc?;
-    private pivotColsSvc?;
+    private colModel;
     wireBeans(beans: BeanCollection): void;
-    getColumnDefs(colDefColsList: AgColumn[], showingPivotResult: boolean, lastOrder: AgColumn[] | null, colsList: AgColumn[], sorted?: boolean): (ColDef | ColGroupDef)[] | undefined;
-    private buildColumnDefs;
-    private createDefFromGroup;
-    private createDefFromColumn;
+    /** Snapshot of the column tree as `ColDef[] | ColGroupDef[]`, display-ordered. Backs `getColumnDefs`. */
+    getColumnDefs(): (ColDef | ColGroupDef)[] | undefined;
 }

package/dist/types/src/columns/columnEventUtils.d.ts

@@ -1,7 +1,10 @@
 import type { AgColumn } from '../entities/agColumn';
 import type { ColumnEventType } from '../events';
+import type { ColumnChangedEventType } from '../interfaces/iColsService';
 import type { IEventService } from '../interfaces/iEventService';
 export declare function dispatchColumnPinnedEvent(eventSvc: IEventService, changedColumns: AgColumn[], source: ColumnEventType): void;
+/** @internal AG_GRID_INTERNAL - Not for public use. Can change / be removed at any time. */
 export declare function dispatchColumnVisibleEvent(eventSvc: IEventService, changedColumns: AgColumn[], source: ColumnEventType): void;
-export declare function dispatchColumnChangedEvent<T extends 'columnValueChanged' | 'columnPivotChanged' | 'columnRowGroupChanged'>(eventSvc: IEventService, type: T, columns: AgColumn[], source: ColumnEventType): void;
+/** @internal AG_GRID_INTERNAL - Not for public use. Can change / be removed at any time. */
+export declare function _dispatchColumnChangedEvent<T extends ColumnChangedEventType>(eventSvc: IEventService, type: T, columns: AgColumn[], source: ColumnEventType): void;
 export declare function dispatchColumnResizedEvent(eventSvc: IEventService, columns: AgColumn[] | null, finished: boolean, source: ColumnEventType, flexColumns?: AgColumn[] | null): void;

package/dist/types/src/columns/columnFlexService.d.ts

@@ -5,7 +5,7 @@ import type { ColumnEventType } from '../events';
 export declare class ColumnFlexService extends BeanStub implements NamedBean {
     beanName: "colFlex";
     private flexViewportWidth;
-    private columnsHidden;
+    columnsHidden: boolean;
     refreshFlexedColumns(params?: {
         resizingCols?: AgColumn[];
         skipSetLeft?: boolean;

package/dist/types/src/columns/columnGroups/colWrapperCache.d.ts

@@ -0,0 +1,16 @@
+import type { BeanCollection } from '../../context/context';
+import type { AgColumn } from '../../entities/agColumn';
+import { AgProvidedColumnGroup } from '../../entities/agProvidedColumnGroup';
+/** @internal AG_GRID_INTERNAL - Not for public use. Can change / be removed at any time. */
+export declare class ColWrapperCache {
+    private readonly entries;
+    private readonly context;
+    constructor(beans: BeanCollection);
+    /** Return the cached wrapper for `(col, depth)`, or build one. Stamps `buildToken` so a later
+     *  `evict(buildToken)` drops wrappers not refreshed this build. */
+    wrap(col: AgColumn, depth: number, buildToken: number): AgColumn | AgProvidedColumnGroup;
+    /** Destroy and remove entries whose token doesn't match the current build. */
+    evict(buildToken: number): void;
+    /** Destroy all cached wrapper chains and clear the cache. */
+    destroy(): void;
+}

package/dist/types/src/columns/columnGroups/columnGroupService.d.ts

@@ -1,50 +1,23 @@
 import type { NamedBean } from '../../context/bean';
 import { BeanStub } from '../../context/beanStub';
+import type { BeanCollection } from '../../context/context';
 import type { AgColumn } from '../../entities/agColumn';
 import { AgColumnGroup } from '../../entities/agColumnGroup';
-import { AgProvidedColumnGroup } from '../../entities/agProvidedColumnGroup';
-import type { ColGroupDef } from '../../entities/colDef';
-import type { ColumnEventType } from '../../events';
 import type { ColumnPinnedType } from '../../interfaces/iColumn';
-import type { IColumnKeyCreator } from '../columnKeyCreator';
 import type { GroupInstanceIdCreator } from '../groupInstanceIdCreator';
-export interface CreateGroupsParams {
-    columns: AgColumn[];
-    idCreator: GroupInstanceIdCreator;
-    pinned: ColumnPinnedType;
-    oldDisplayedGroups?: (AgColumn | AgColumnGroup)[];
-    isStandaloneStructure?: boolean;
-}
+import { ColWrapperCache } from './colWrapperCache';
 export declare class ColumnGroupService extends BeanStub implements NamedBean {
     beanName: "colGroupSvc";
-    getColumnGroupState(): {
-        groupId: string;
-        open: boolean;
-    }[];
-    resetColumnGroupState(source: ColumnEventType): void;
-    setColumnGroupState(stateItems: {
-        groupId: string;
-        open: boolean | undefined;
-    }[], source: ColumnEventType): void;
-    setColumnGroupOpened(key: AgProvidedColumnGroup | string | null, newValue: boolean, source: ColumnEventType): void;
-    getProvidedColGroup(key: string): AgProvidedColumnGroup | null;
-    getGroupAtDirection(columnGroup: AgColumnGroup, direction: 'After' | 'Before'): AgColumnGroup | null;
-    getColGroupAtLevel(column: AgColumn, level: number): AgColumnGroup | null;
-    updateOpenClosedVisibility(): void;
-    getColumnGroup(colId: string | AgColumnGroup, partId?: number): AgColumnGroup | null;
-    createColumnGroups(params: CreateGroupsParams): (AgColumn | AgColumnGroup)[];
-    createProvidedColumnGroup(primaryColumns: boolean, colGroupDef: ColGroupDef, level: number, existingColumns: AgColumn[], columnKeyCreator: IColumnKeyCreator, existingGroups: AgProvidedColumnGroup[], source: ColumnEventType): AgProvidedColumnGroup;
-    balanceColumnTree(unbalancedTree: (AgColumn | AgProvidedColumnGroup)[], currentDepth: number, columnDepth: number, columnKeyCreator: IColumnKeyCreator): (AgColumn | AgProvidedColumnGroup)[];
-    findDepth(balancedColumnTree: (AgColumn | AgProvidedColumnGroup)[]): number;
-    findMaxDepth(treeChildren: (AgColumn | AgProvidedColumnGroup)[], depth: number): number;
-    /**
-     * Inserts dummy group columns in the hierarchy above auto-generated columns
-     * in order to ensure auto-generated columns are leaf nodes (and therefore are
-     * displayed correctly)
-     */
-    balanceTreeForAutoCols(autoCols: AgColumn[], depth: number): (AgColumn | AgProvidedColumnGroup)[];
-    private findExistingGroup;
-    private createColumnGroup;
-    private mapOldGroupsById;
-    private setupParentsIntoCols;
+    private colModel;
+    private colViewport;
+    /** Cache service-column wrappers (auto-group/selection/row-numbers) across `refreshCols` by `(col, depth)`. */
+    wrapperCache: ColWrapperCache;
+    wireBeans(beans: BeanCollection): void;
+    destroy(): void;
+    /** Build one pinned section's displayed group tree from already-sorted `columns`.
+     *  @param buildToken Stamp reused/created groups for `prune` to drop stale tail entries.
+     *  @param isStandaloneStructure Build detached output (e.g. exports) without reuse, bean registration, or parent wiring. */
+    createGroups(columns: AgColumn[], idCreator: GroupInstanceIdCreator, pinned: ColumnPinnedType, buildToken?: number, isStandaloneStructure?: boolean): (AgColumn | AgColumnGroup)[];
+    /** Finalise display instances by keeping groups stamped with `buildToken` and truncating stale tail entries. */
+    prune(buildToken: number): void;
 }

package/dist/types/src/columns/columnGroups/columnGroupState.d.ts

@@ -0,0 +1,13 @@
+import type { BeanCollection } from '../../context/context';
+import type { AgProvidedColumnGroup } from '../../entities/agProvidedColumnGroup';
+import type { ColumnEventType } from '../../events';
+export declare const _getColGroupState: (beans: BeanCollection) => {
+    groupId: string;
+    open: boolean;
+}[];
+export declare const _setColGroupOpen: (beans: BeanCollection, key: AgProvidedColumnGroup | string | null | undefined, newValue: boolean, source: ColumnEventType) => void;
+export declare const _setColGroupState: (beans: BeanCollection, stateItems: {
+    groupId: string;
+    open: boolean | undefined;
+}[], source: ColumnEventType) => void;
+export declare const _resetColGroupState: (beans: BeanCollection, source: ColumnEventType) => void;

package/dist/types/src/columns/columnModel.d.ts

@@ -1,80 +1,126 @@
 import type { NamedBean } from '../context/bean';
 import { BeanStub } from '../context/beanStub';
-import { AgColumn } from '../entities/agColumn';
+import type { AgColumn } from '../entities/agColumn';
 import type { AgProvidedColumnGroup } from '../entities/agProvidedColumnGroup';
 import type { ColDef, ColGroupDef, ColKey } from '../entities/colDef';
 import type { GridOptions } from '../entities/gridOptions';
 import type { ColumnEventType } from '../events';
 import type { PropertyChangedEvent, PropertyValueChangedEvent } from '../gridOptionsService';
-export type Maybe<T> = T | null | undefined;
-/** @internal AG_GRID_INTERNAL - Not for public use. Can change / be removed at any time. */
-export interface ColumnCollections {
-    tree: (AgColumn | AgProvidedColumnGroup)[];
-    treeDepth: number;
-    list: AgColumn[];
-    map: {
-        [id: string]: AgColumn;
-    };
-}
 /** @internal AG_GRID_INTERNAL - Not for public use. Can change / be removed at any time. */
 export declare class ColumnModel extends BeanStub implements NamedBean {
     beanName: "colModel";
-    private colDefs?;
-    colDefCols?: ColumnCollections;
-    cols?: ColumnCollections;
     pivotMode: boolean;
-    private showingPivotResult;
-    private lastOrder;
-    private lastPivotOrder;
     colSpanActive: boolean;
     ready: boolean;
+    /** Suppresses row model refreshes during batch column state dispatching. */
     changeEventsDispatching: boolean;
+    showingPivotResult: boolean;
+    /** >0 inside a {@link beginColBatch}/{@link endColBatch} pair: cols services defer their flush to the outermost close. */
+    private colBatchDepth;
+    /** Set when a staged change needs a display rebuild; consumed (cleared) once by {@link performRefresh}. */
+    private pendingRefresh;
+    /** A batched `buildFromColDefs` already raised `columnEverythingChanged`; stops the batch flush re-raising it. */
+    private everythingChangedInBatch;
+    colsList: AgColumn[];
+    colsTree: (AgColumn | AgProvidedColumnGroup)[];
+    colsTreeDepth: number;
+    colDefList: AgColumn[];
+    colDefTree: (AgColumn | AgProvidedColumnGroup)[];
+    colDefTreeDepth: number;
+    private colDefHasMarryChildren;
+    hasMarryChildren: boolean;
+    /** Single source of truth for `getCol`. Pivot result colIds are namespaced (`pivot_…`). */
+    colsById: {
+        [id: string]: AgColumn;
+    };
+    colDefGroupsById: Map<string, AgProvidedColumnGroup>;
+    /** Primary cols keyed by colId / userProvidedColDef ref / field; passed back for next-build reuse. */
+    private colDefColsByKey;
+    /** Every primary group (padding + non-padding) — sweep uses this to find orphans whose parent's
+     *  `.children` was reassigned. */
+    private colDefAllGroups;
+    /** Non-padding displayed groups by `groupId`. Pivot mode = pivot's groups; else = colDefGroupsById. */
+    colsGroupsById: Map<string, AgProvidedColumnGroup>;
+    /** Every displayed group — padding groups carry `displayInstances` */
+    colsAllGroups: AgProvidedColumnGroup[];
+    /** Lazy fallback for ColDef-shaped keys not in `colsById`: by-ref (merged + user colDef) plus
+     *  `field` when distinct from colId (first-write-wins). */
+    private cachedColsByDef;
+    private cachedAllCols;
+    /** Cache for getColsInStateOrder (pivot only). Invalidated on `colsList` mutation — ref equality
+     *  can't substitute, as `moveColumns` reorders in place. */
+    private cachedColsInStateOrder;
+    /** Prior display order per mode, as colId snapshots, so the next refresh can restore user moves. */
+    private lastOrder;
+    private lastPivotOrder;
+    /** Set when colsList order changes; {@link ensureColsListIndex} re-stamps `colsListIndex` lazily. */
+    private colsListIndexDirty;
+    /** User provided column definitions */
+    colDefs: (ColDef | ColGroupDef)[] | undefined;
+    private buildTokenCounter;
+    /** Persistent padding-group cache for hierarchy virtual cols, handed to each column-tree build
+     *  so `(col, depth)`-stable wrappers survive rebuilds. Owns the padding-group bean lifecycle. */
+    private hierarchyWrapperCache;
     postConstruct(): void;
-    private createColsFromColDefs;
+    destroy(): void;
+    nextBuildToken(): number;
+    isPivotActive(): boolean;
+    getCols(): AgColumn[];
+    /** Every column known to the grid (user, hierarchy, service, pivot result) in display (`colsList`)
+     *  order, with parked pivot primaries appended. Lazily computed on first read after invalidation. */
+    getAllCols(): AgColumn[];
+    /** Resolve a provided group by id, falling back to parked primaries while pivoting (mirrors `getCol`). */
+    getColGroup(groupId: string): AgProvidedColumnGroup | undefined;
+    /** Columns in column-state order: hidden pivot primaries first, then `colsList`. Must not be mutated. */
+    getColsInStateOrder(): AgColumn[];
+    /** `newColDefs`: true = colDefs changed (order restored only with `maintainColumnOrder`); false =
+     *  dynamic refresh with unchanged colDefs (prior order restored). */
+    private buildFromColDefs;
+    /** Open a column-change batch; mutations until the {@link endColBatch} share one flush. */
+    beginColBatch(): void;
+    /** Close a {@link beginColBatch}; the outermost close flushes once (one source for the whole action). */
+    endColBatch(source: ColumnEventType): void;
+    /** Refresh once (if needed) + dispatch each touched service. Fires immediately, or defers to {@link endColBatch}
+     *  when batched. `refresh` accumulates into {@link pendingRefresh}: membership passes `true`, order/aggFunc-only
+     *  (`moveColumn`/`setColumnAggFunc`) pass `false` to dispatch without a rebuild. */
+    flushColChanges(source: ColumnEventType, refresh: boolean): void;
     refreshCols(newColDefs: boolean, source: ColumnEventType): void;
-    private createColumnsForService;
-    private selectCols;
-    getColsToShow(): AgColumn[];
+    /** Refresh state derived from `colsList` (group + quick-filter cols, colSpan/autoHeight flags) and
+     *  reset displayed-col + viewport caches, ahead of `visibleCols.refresh`. Shared by full refreshCols
+     *  and by a visibility-only change (which leaves `colsList` unchanged, so skips the rebuild). */
+    refreshColsDerivedState(): void;
+    /** Single pass: set `colSpanActive` and `rowAutoHeight.active` from `colsList`. */
+    private computeColSpanAndAutoHeight;
+    /** Full refresh (rebuild cols + recompute visible); immediate, or deferred to {@link endColBatch} when batched. */
     refreshAll(source: ColumnEventType): void;
-    setColsVisible(keys: (string | AgColumn)[], visible: boolean | undefined, source: ColumnEventType): void;
-    /**
-     * Restores provided columns order to the previous order in this.lastPivotOrder / this.lastOrder
-     * If columns are not in the last order:
-     *  - Check column groups, and apply column after the last column in the lowest shared group
-     *  - If no sibling is found, apply the column at the end of the cols
-     */
-    private restoreColOrder;
-    private positionLockedCols;
-    private saveColOrder;
-    getColumnDefs(sorted?: boolean): (ColDef | ColGroupDef)[] | undefined;
-    private setColSpanActive;
-    isPivotMode(): boolean;
+    private performRefresh;
+    /** Reorder `colDefList` only — `newList` MUST be a permutation of the existing col instances
+     *  (caller owns the invariant). A full refresh should follow to propagate to display cols.
+     *  `colsById` unchanged; `getAllCols` is order-agnostic. */
+    replaceColDefList(newList: AgColumn[]): void;
     private setPivotMode;
-    isPivotActive(): boolean;
     recreateColumnDefs(e: PropertyChangedEvent | PropertyValueChangedEvent<keyof GridOptions>): void;
     setColumnDefs(columnDefs: (ColDef | ColGroupDef)[], source: ColumnEventType): void;
-    destroy(): void;
-    getColTree(): (AgColumn | AgProvidedColumnGroup)[];
-    getColDefColTree(): (AgColumn | AgProvidedColumnGroup)[];
-    getColDefCols(): AgColumn[] | null;
-    getCols(): AgColumn[];
-    /**
-     * If callback returns true, exit early.
-     */
-    forAllCols(callback: (column: AgColumn) => boolean | void): void;
-    getColsForKeys(keys: ColKey[]): AgColumn[];
-    getColDefCol(key: ColKey): AgColumn | null;
-    /** Look up by key across colDefCols, displayed cols, and service columns (auto-group, selection, row-number). */
-    getColDefColOrCol(key: Maybe<ColKey>): AgColumn | null;
-    /** Look up by key across displayed cols, colDefCols, and service columns — prefers displayed cols. */
-    getColOrColDefCol(key: Maybe<ColKey>): AgColumn | null;
-    getCol(key: Maybe<ColKey>): AgColumn | null;
-    /**
-     * Get column exclusively by ID.
-     *
-     * Note getCol/getColFromCollection have poor performance when col has been removed.
-     */
-    getColById(key: string): AgColumn | null;
-    getColFromCollection(key: ColKey, cols?: ColumnCollections): AgColumn | null;
-    private getColFromServiceCols;
+    /** Full structural rebuild from current `colDefs` + all contributors (hierarchy, calc cols, …).
+     *  Used by contributors whose mutation changes tree structure (e.g. calc-col add/update/remove). */
+    rebuildCols(source: ColumnEventType): void;
+    /** Mark `AgColumn.colsListIndex` stale — called when `colsList`'s order changes outside a refresh
+     *  (`moveColumns`, `applyColumnState` with `applyOrder`); next `ensureColsListIndex` re-stamps. */
+    markColsListIndexDirty(): void;
+    /** Lazily stamp each col's index in `colsList` onto `AgColumn.colsListIndex`, once per order change.
+     *  Readers (e.g. `getColumnDefs`) call this before reading `col.colsListIndex`, so a burst of moves
+     *  costs one O(N) pass on the next read, not one per move. */
+    ensureColsListIndex(): void;
+    /** Resolve any key (colId string, AgColumn, or ColDef) to its current AgColumn. Fast path inline:
+     *  string colId, or object whose `colId` hits `colsById` (O(1)); misses delegate to `getColFallback`. */
+    getCol(key: ColKey | null | undefined): AgColumn | undefined;
+    /** Slow-path fallback for `getCol`: ColDef/ColGroupDef ref lookup + `field`-string fallback, building
+     *  the lazy `colsByDef` map on first use. Stale AgColumn refs return `undefined` (unregistered, no `field`). */
+    private getColFallback;
+    /** Find a column excluding pivot result cols. `pivotKeys` (grid-set) is an O(1) discriminator
+     *  standing in for a `pivotCols`-membership test, so `getColumnDefs()` doesn't round-trip them. */
+    getNonPivotCol(key: ColKey): AgColumn | undefined;
+    /** Like `getNonPivotCol` for hot paths where the key is a known colId string — skips the type-check + field-fallback. */
+    getNonPivotColById(key: string): AgColumn | undefined;
+    private loadColsByDef;
 }

package/dist/types/src/columns/columnNameService.d.ts

@@ -7,7 +7,7 @@ import type { HeaderLocation } from '../entities/colDef';
 /** @internal AG_GRID_INTERNAL - Not for public use. Can change / be removed at any time. */
 export declare class ColumnNameService extends BeanStub implements NamedBean {
     beanName: "colNames";
-    getDisplayNameForColumn(column: AgColumn | null, location: HeaderLocation, includeAggFunc?: boolean): string | null;
+    getDisplayNameForColumn(column: AgColumn | null | undefined, location: HeaderLocation, includeAggFunc?: boolean): string | null;
     getDisplayNameForProvidedColumnGroup(columnGroup: AgColumnGroup | null, providedColumnGroup: AgProvidedColumnGroup | null, location: HeaderLocation): string | null;
     getDisplayNameForColumnGroup(columnGroup: AgColumnGroup, location: HeaderLocation): string | null;
     private getHeaderName;

package/dist/types/src/columns/columnStateUtils.d.ts

@@ -1,8 +1,10 @@
 import type { BeanCollection } from '../context/context';
 import type { AgColumn } from '../entities/agColumn';
-import type { IAggFunc, SortDirection, SortType } from '../entities/colDef';
+import type { ColAggFunc, IAggFunc } from '../entities/colDef';
+import type { ShowValuesAsStateValue } from '../entities/colDef-showValuesAs';
 import type { ColumnEventType } from '../events';
 import type { ColumnPinnedType } from '../interfaces/iColumn';
+import type { SortDef, SortDirection, SortType } from '../interfaces/iSort';
 export interface ColumnStateParams {
     /** True if the column is hidden */
     hide?: boolean | null;
@@ -13,11 +15,17 @@ export interface ColumnStateParams {
     /** The sort direction of the column */
     sort?: SortDirection;
     /** The type of sort applied to the column */
-    sortType?: SortType;
+    sortType?: SortType | null;
     /** The order of the sort, if sorting by many columns */
     sortIndex?: number | null;
     /** The aggregation function applied */
     aggFunc?: string | IAggFunc | null;
+    /**
+     * The position of this column in the order of value columns when aggregating in pivot mode.
+     * When aggregating by a single column, any number can be used. When aggregating by multiple
+     * columns, this determines the order (e.g. `0` for first, `1` for second).
+     */
+    valueIndex?: number | null;
     /** True if pivot active */
     pivot?: boolean | null;
     /** The order of the pivot, if pivoting by many columns */
@@ -28,6 +36,9 @@ export interface ColumnStateParams {
     rowGroup?: boolean | null;
     /** The order of the row group, if grouping by many columns */
     rowGroupIndex?: number | null;
+    /** The active "Show Values As" selection: the mode name, or the object form (with `params` / `precision`)
+     *  for modes that take input. `null` clears it. */
+    showValuesAs?: ShowValuesAsStateValue;
 }
 export interface ColumnState extends ColumnStateParams {
     /** ID of the column */
@@ -41,16 +52,46 @@ export interface ApplyColumnStateParams {
     /** State to apply to columns where state is missing for those columns */
     defaultState?: ColumnStateParams;
 }
-/** @internal AG_GRID_INTERNAL - Not for public use. Can change / be removed at any time. */
+/** Pre-mutation snapshot; `dispatchColStateChanges` diffs against it to fire the right column events. */
+interface ColumnStateChanges {
+    /** Pre-mutation snapshot (`sortColumns` mutates `.columns` in place); `undefined` when empty/absent. */
+    rowGroupColumns: AgColumn[] | undefined;
+    pivotColumns: AgColumn[] | undefined;
+    /** Per-column scalar snapshot keyed by colId; insertion order = capture order. */
+    before: Map<string, ColumnStateBefore>;
+    /** Pre-mutation `colsList` ref. Unchanged ref ⇒ order untouched (only ever reassigned) ⇒ skip the O(n) diff. */
+    colsList: AgColumn[];
+}
+/** Minimal pre-apply snapshot: only the fields `dispatchColumnFieldChanges` diffs. */
+interface ColumnStateBefore {
+    width: number;
+    hide: boolean;
+    pinned: ColumnPinnedType;
+    sort: SortDirection;
+    sortType: SortType | undefined;
+    sortIndex: number | null;
+    aggFunc: ColAggFunc;
+}
+/** Updates hide/sort/sortIndex/pinned/flex. Per field: `null`/empty clears, only `undefined` is skipped. */
+export declare const updateSomeColumnState: (beans: BeanCollection, column: AgColumn, hide: boolean | null | undefined, sort: SortDirection | SortDef | undefined, sortIndex: number | null | undefined, pinned: boolean | "left" | "right" | null | undefined, flex: number | null | undefined, source: ColumnEventType) => void;
+/** Show/hide columns — skips the full `_applyColumnState` rebuild (visibility can't change colsList membership/order).
+ *  `filterLockedColumns` (UI paths) skips `lockVisible` cols; the API path passes `false`.
+ *  @internal AG_GRID_INTERNAL - Not for public use. Can change / be removed at any time. */
+export declare function _setColsVisible(beans: BeanCollection, keys: (string | AgColumn)[], visible: boolean | undefined, source: ColumnEventType, filterLockedColumns?: boolean): void;
+/** Apply `ColumnState` across two passes, then — once for the whole operation — re-order, refresh the
+ *  visible cols and dispatch the resulting events. Returns `true` if every provided state matched a column.
+ *  @internal AG_GRID_INTERNAL - Not for public use. Can change / be removed at any time. */
 export declare function _applyColumnState(beans: BeanCollection, params: ApplyColumnStateParams, source: ColumnEventType): boolean;
-/** @internal AG_GRID_INTERNAL - Not for public use. Can change / be removed at any time. */
+/** Reset all columns to the state declared in their colDefs (`initial*`/explicit), re-apply the colDef
+ *  order, and fire `columnsReset`.
+ *  @internal AG_GRID_INTERNAL - Not for public use. Can change / be removed at any time. */
 export declare function _resetColumnState(beans: BeanCollection, source: ColumnEventType): void;
-/**
- * calculates what events to fire between column state changes. gets used when:
- * a) apply column state
- * b) apply new column definitions (so changes from old cols)
- */
-export declare function _compareColumnStatesAndDispatchEvents(beans: BeanCollection, source: ColumnEventType): () => void;
-/** @internal AG_GRID_INTERNAL - Not for public use. Can change / be removed at any time. */
-export declare function _getColumnState(beans: BeanCollection): ColumnState[];
-export declare function getColumnStateFromColDef(column: AgColumn): ColumnState;
+/** Snapshot column state before a mutation. Pair with {@link dispatchColStateChanges} after the
+ *  mutation to fire the resulting events. Used by both apply-column-state and apply-new-column-defs. */
+export declare function captureColumnStateChanges(beans: BeanCollection): ColumnStateChanges;
+/** Diff current column state against a {@link captureColumnStateChanges} snapshot and dispatch the changed
+ *  column events (value/resize/pin/visible/sort/rowGroup/pivot/moved). */
+export declare function dispatchColStateChanges(beans: BeanCollection, source: ColumnEventType, changes: ColumnStateChanges): void;
+export declare const _getColumnState: (beans: BeanCollection) => ColumnState[];
+export declare function getColumnStateFromColDef(beans: BeanCollection, column: AgColumn): ColumnState;
+export {};

package/dist/types/src/columns/columnUtils.d.ts

@@ -1,42 +1,37 @@
-import type { AgPropertyChangedSource } from '../agStack/interfaces/iProperties';
+import type { AgPropertyChangedSource } from 'ag-stack';
 import type { BeanCollection } from '../context/context';
 import type { AgColumn } from '../entities/agColumn';
 import type { AgProvidedColumnGroup } from '../entities/agProvidedColumnGroup';
-import type { ColDef, ColKey } from '../entities/colDef';
+import type { ColDef, ColGroupDef } from '../entities/colDef';
 import type { ColumnEventType } from '../events';
-import type { ColumnCollections } from './columnModel';
-import type { ColumnState, ColumnStateParams } from './columnStateUtils';
+import type { Column } from '../interfaces/iColumn';
+import type { ColumnState } from './columnStateUtils';
 export declare const GROUP_AUTO_COLUMN_ID = "ag-Grid-AutoColumn";
 export declare const SELECTION_COLUMN_ID = "ag-Grid-SelectionColumn";
 export declare const ROW_NUMBERS_COLUMN_ID = "ag-Grid-RowNumbersColumn";
 export declare const GROUP_HIERARCHY_COLUMN_ID_PREFIX = "ag-Grid-HierarchyColumn";
-/** @internal AG_GRID_INTERNAL - Not for public use. Can change / be removed at any time. */
-export declare function _getColumnsFromTree(rootColumns: (AgColumn | AgProvidedColumnGroup)[]): AgColumn[];
 export declare function getWidthOfColsInList(columnList: AgColumn[]): number;
 /** @internal AG_GRID_INTERNAL - Not for public use. Can change / be removed at any time. */
-export declare function _destroyColumnTree(beans: BeanCollection, oldTree: (AgColumn | AgProvidedColumnGroup)[] | null | undefined, newTree?: (AgColumn | AgProvidedColumnGroup)[] | null): void;
-/** @internal AG_GRID_INTERNAL - Not for public use. Can change / be removed at any time. */
-export declare function isColumnGroupAutoCol(col: AgColumn): boolean;
+export declare function isColumnGroupAutoCol(col: Column): boolean;
 /** @internal AG_GRID_INTERNAL - Not for public use. Can change / be removed at any time. */
-export declare function isColumnSelectionCol(col: ColKey): boolean;
+export declare function isColumnSelectionCol(col: Column): boolean;
 /** @internal AG_GRID_INTERNAL - Not for public use. Can change / be removed at any time. */
-export declare function isRowNumberCol(col: ColKey): boolean;
+export declare function isRowNumberCol(col: Column): boolean;
 /** @internal AG_GRID_INTERNAL - Not for public use. Can change / be removed at any time. */
-export declare function isSpecialCol(col: ColKey): boolean;
+export declare function isSpecialCol(col: Column): boolean;
 export declare function convertColumnTypes(type: string | string[]): string[];
 /** @internal AG_GRID_INTERNAL - Not for public use. Can change / be removed at any time. */
-export declare function _areColIdsEqual(colsA: AgColumn[] | null, colsB: AgColumn[] | null): boolean;
-/** @internal AG_GRID_INTERNAL - Not for public use. Can change / be removed at any time. */
-export declare function _updateColsMap(cols: ColumnCollections): void;
-/** @internal AG_GRID_INTERNAL - Not for public use. Can change / be removed at any time. */
 export declare function _convertColumnEventSourceType(source: AgPropertyChangedSource): ColumnEventType;
 /** @internal AG_GRID_INTERNAL - Not for public use. Can change / be removed at any time. */
-export declare function _columnsMatch(column: AgColumn, key: ColKey): boolean;
-export declare const getValueFactory: (stateItem: ColumnState | null, defaultState: ColumnStateParams | undefined) => <U extends keyof ColumnStateParams, S extends keyof ColumnStateParams>(key1: U, key2?: S) => {
-    value1: ColumnStateParams[U] | undefined;
-    value2: ColumnStateParams[S] | undefined;
-};
-/** @internal AG_GRID_INTERNAL - Not for public use. Can change / be removed at any time. */
-export declare function _getColumnStateFromColDef(colDef: ColDef, colId: string): ColumnState;
-/** @internal AG_GRID_INTERNAL - Not for public use. Can change / be removed at any time. */
-export declare function _getSortDefFromColDef(colDef: ColDef): import("../main-umd-noStyles").SortDef | null;
+export declare function _getColumnStateFromColDef(beans: BeanCollection, colDef: ColDef, colId: string): ColumnState;
+export declare function getSortDefFromColDef(colDef: ColDef): import("../main-umd-noStyles").SortDef | null;
+/** Destroys every still-alive node via flat lists (not `.children`, which a reused group may have replaced);
+ *  the `isAlive()` guard de-dups nodes reachable via multiple paths (hierarchy cols sit in colDefList + wrappers).
+ *  @internal AG_GRID_INTERNAL - Not for public use. Can change / be removed at any time. */
+export declare const _destroyColumnTreeAll: (cols: readonly AgColumn[] | null, allGroups: readonly AgProvidedColumnGroup[] | null) => void;
+/** Destroys prev-build nodes absent from the new build. Walks flat prev lists, not `.children`:
+ *  orphans whose parent's array was replaced are otherwise unreachable.
+ *  @internal AG_GRID_INTERNAL - Not for public use. Can change / be removed at any time. */
+export declare const _destroyColumnTreeUnused: (prevCols: readonly AgColumn[], prevAllGroups: readonly AgProvidedColumnGroup[], buildToken: number) => void;
+/** Calls `callback` for each leaf `ColDef`, recursing into `ColGroupDef` children; not called on groups. */
+export declare function forEachColDef(columnDefs: (ColDef | ColGroupDef)[], callback: (colDef: ColDef) => void): void;

package/dist/types/src/columns/dataTypeService.d.ts

@@ -5,6 +5,8 @@ import type { AgColumn } from '../entities/agColumn';
 import type { ColDef } from '../entities/colDef';
 import type { BaseCellDataType, CoreDataTypeDefinition, DataTypeDefinition, DataTypeFormatValueFunc } from '../entities/dataType';
 /** @internal AG_GRID_INTERNAL - Not for public use. Can change / be removed at any time. */
+export declare const DATA_TYPE_DERIVED_COL_DEF_PROPERTIES: readonly ["cellRenderer", "cellEditorParams", "comparator", "getFindText", "keyCreator", "suppressKeyboardEvent", "valueFormatter", "valueParser"];
+/** @internal AG_GRID_INTERNAL - Not for public use. Can change / be removed at any time. */
 export declare class DataTypeService extends BeanStub implements NamedBean {
     beanName: "dataTypeSvc";
     private colModel;
@@ -35,7 +37,6 @@ export declare class DataTypeService extends BeanStub implements NamedBean {
     private getInitialData;
     private initWaitForRowData;
     private processColumnsPendingInference;
-    private generateColumnStateForRowGroupAndPivotIndexes;
     private resetColDefIntoCol;
     private getDateStringTypeDefinition;
     getDateParserFunction(column?: AgColumn | null): (value: string | undefined) => Date | undefined;
@@ -47,6 +48,7 @@ export declare class DataTypeService extends BeanStub implements NamedBean {
     validateColDef(colDef: ColDef, userColDef?: ColDef, defaultColDef?: ColDef, colId?: string): void;
     postProcess(colDef: ColDef): void;
     getFormatValue(cellDataType: string): DataTypeFormatValueFunc | undefined;
+    isDataTypeRegistered(cellDataType: string): boolean;
     isColPendingInference(colId: string): boolean;
     private readonly columnDefinitionPropsPerDataType;
     private setColDefPropertiesForBaseDataType;

package/dist/types/src/columns/groupInstanceIdCreator.d.ts

@@ -1,5 +1,4 @@
-/** @internal AG_GRID_INTERNAL - Not for public use. Can change / be removed at any time. */
 export declare class GroupInstanceIdCreator {
-    private existingIds;
+    private readonly existingIds;
     getInstanceIdForKey(key: string): number;
 }

package/dist/types/src/columns/selectionColService.d.ts

@@ -1,35 +1,14 @@
 import type { NamedBean } from '../context/bean';
-import { BeanStub } from '../context/beanStub';
-import { AgColumn } from '../entities/agColumn';
-import type { ColKey } from '../entities/colDef';
+import type { ColKind } from '../entities/agColumn';
+import type { ColDef } from '../entities/colDef';
 import type { PropertyValueChangedEvent } from '../gridOptionsService';
-import type { IColumnCollectionService } from '../interfaces/iColumnCollectionService';
-import type { ColumnCollections } from './columnModel';
-export declare class SelectionColService extends BeanStub implements NamedBean, IColumnCollectionService {
+import { BaseSingleColService } from './baseSingleColService';
+export declare class SelectionColService extends BaseSingleColService implements NamedBean {
     beanName: "selectionColSvc";
-    columns: ColumnCollections | null;
+    protected readonly colKind: ColKind;
     postConstruct(): void;
-    addColumns(cols: ColumnCollections): void;
-    createColumns(cols: ColumnCollections, updateOrders: (callback: (cols: AgColumn[] | null) => AgColumn[] | null) => void): void;
     updateColumns(event: PropertyValueChangedEvent<'selectionColumnDef'>): void;
-    getColumn(key: ColKey): AgColumn | null;
-    getColumns(): AgColumn[] | null;
-    isSelectionColumnEnabled(): boolean;
-    private createSelectionColDef;
-    private generateSelectionCols;
+    isEnabled(): boolean;
+    protected createColDef(): ColDef;
     private onSelectionOptionsChanged;
-    destroy(): void;
-    /**
-     * Refreshes visibility of the selection column based on which columns are currently visible.
-     * Called by the VisibleColsService with the columns that are currently visible in left/center/right
-     * containers. This method *MUTATES* those arrays directly.
-     *
-     * The selection column should be visible if all of the following are true
-     * - The selection column is not disabled
-     * - The number of visible columns excluding the selection column and row numbers column is greater than 0
-     * @param leftCols Visible columns in the left-pinned container
-     * @param centerCols Visible columns in the center viewport
-     * @param rightCols Visible columns in the right-pinned container
-     */
-    refreshVisibility(leftCols: AgColumn[], centerCols: AgColumn[], rightCols: AgColumn[]): void;
 }