ag-grid-community 35.3.0 → 36.0.0

package/dist/types/src/rendering/row/rowCtrl.d.ts

@@ -6,25 +6,34 @@ import type { RowNode } from '../../entities/rowNode';
 import type { AgEventType } from '../../eventTypes';
 import type { CellFocusedEvent, RowEvent } from '../../events';
 import type { RowContainerType } from '../../gridBodyComp/rowContainer/rowContainerCtrl';
+import type { PinnedSectionWidths } from '../../headerRendering/headerUtils';
 import type { BrandedType } from '../../interfaces/brandedType';
 import type { RenderedRowEvent } from '../../interfaces/iCallbackParams';
 import type { RefreshRowsParams } from '../../interfaces/iCellsParams';
 import type { ColumnPinnedType } from '../../interfaces/iColumn';
+import type { HorizontalSection, HorizontalSectionMap } from '../../interfaces/iGridSection';
 import type { RowPosition } from '../../interfaces/iRowPosition';
 import type { IRowStyleFeature } from '../../interfaces/iRowStyleFeature';
 import type { UserCompDetails } from '../../interfaces/iUserCompDetails';
-import type { INotesFeature } from '../../interfaces/notes';
 import { CellCtrl } from '../cell/cellCtrl';
 import type { ICellRenderer, ICellRendererParams } from '../cellRenderers/iCellRenderer';
+import type { FullWidthTarget } from './iRowModeFeature';
+type RowType = 'Normal' | 'FullWidth' | 'FullWidthLoading' | 'FullWidthGroup' | 'FullWidthDetail';
 export type RowCtrlInstanceId = BrandedType<string, 'RowCtrlInstanceId'>;
 /** @internal AG_GRID_INTERNAL - Not for public use. Can change / be removed at any time. */
 export interface IRowComp {
     setDomOrder(domOrder: boolean): void;
     toggleCss(cssClassName: string, on: boolean): void;
     setCellCtrls(cellCtrls: CellCtrl[], useFlushSync: boolean): void;
+    getPinnedLeftRowElement(): HTMLElement | undefined;
+    getScrollingRowElement(): HTMLElement | undefined;
+    getPinnedRightRowElement(): HTMLElement | undefined;
+    refreshPinnedSections(): void;
     showFullWidth(compDetails: UserCompDetails): void;
-    getFullWidthCellRenderer(): ICellRenderer | null | undefined;
+    showEmbeddedFullWidth?(compDetails: HorizontalSectionMap<UserCompDetails>): void;
+    getFullWidthCellRenderers(): (ICellRenderer | null | undefined)[];
     getFullWidthCellRendererParams(): ICellRendererParams | undefined;
+    getFullWidthCellRendererParamsForPinned?(pinned: ColumnPinnedType): ICellRendererParams | undefined;
     setTop(top: string): void;
     setTransform(transform: string): void;
     setRowIndex(rowIndex: string): void;
@@ -32,6 +41,7 @@ export interface IRowComp {
     setRowBusinessKey(businessKey: string): void;
     setUserStyles(styles: RowStyle | undefined): void;
     refreshFullWidth(getUpdatedParams: () => ICellRendererParams): boolean;
+    refreshEmbeddedFullWidth?(getUpdatedParams: (pinned: ColumnPinnedType) => ICellRendererParams): boolean;
 }
 /** @internal AG_GRID_INTERNAL - Not for public use. Can change / be removed at any time. */
 export interface RowGui {
@@ -40,30 +50,26 @@ export interface RowGui {
     containerType: RowContainerType;
     compBean: BeanStub;
 }
+/** @internal AG_GRID_INTERNAL - Not for public use. Can change / be removed at any time. */
+export type PinnedCellGroupWidths = PinnedSectionWidths;
+interface MappedPinnedCellGroupWidths extends PinnedCellGroupWidths {
+    renderLeft: boolean;
+    renderRight: boolean;
+}
 type RowCtrlEvent = RenderedRowEvent;
 /** @internal AG_GRID_INTERNAL - Not for public use. Can change / be removed at any time. */
 export declare class RowCtrl extends BeanStub<RowCtrlEvent> {
     readonly rowNode: RowNode;
-    private readonly useAnimationFrameForCreate;
+    readonly useAnimationFrameForCreate: boolean;
     readonly printLayout: boolean;
     readonly instanceId: RowCtrlInstanceId;
-    private tooltipFeature;
-    private readonly fullWidthNotesFeature;
-    private readonly guiListenerOwners;
     private rowType;
-    private leftGui;
-    private centerGui;
-    private rightGui;
-    private fullWidthGui;
-    private focusEventWhileNotReady;
-    private allRowGuis;
+    private rowGui;
+    private readonly rowModeFeature;
     private firstRowOnPage;
     private lastRowOnPage;
     private active;
     private rowFocused;
-    private centerCellCtrls;
-    private leftCellCtrls;
-    private rightCellCtrls;
     private slideInAnimation;
     private fadeInAnimation;
     private rowDragComps;
@@ -73,17 +79,18 @@ export declare class RowCtrl extends BeanStub<RowCtrlEvent> {
     rowStyles: RowStyle;
     private readonly emptyStyle;
     private readonly suppressRowTransform;
-    private updateColumnListsPending;
     rowId: string | null;
     ariaRowIndex: number | null;
     /** sanitised */
     businessKey: string | null;
     private businessKeyForNodeFunc;
     rowEditStyleFeature?: IRowStyleFeature;
+    isEmbeddedFullWidth: boolean;
+    embeddedSectionHasContent: HorizontalSectionMap<boolean>;
     constructor(rowNode: RowNode, beans: BeanCollection, animateIn: boolean, useAnimationFrameForCreate: boolean, printLayout: boolean);
+    private createRowModeFeature;
     private initRowBusinessKey;
     private updateRowBusinessKey;
-    private updateGui;
     setComp(rowComp: IRowComp, element: HTMLElement, containerType: RowContainerType, compBean: BeanStub<any> | undefined): void;
     unsetComp(containerType: RowContainerType): void;
     isCacheable(): boolean;
@@ -93,48 +100,41 @@ export declare class RowCtrl extends BeanStub<RowCtrlEvent> {
     private setRowCompRowId;
     private executeSlideAndFadeAnimations;
     private addRowDraggerToRow;
-    private setupFullWidth;
-    getFullWidthCellRenderers(): (ICellRenderer<any> | null | undefined)[];
+    getModeCellRenderers(): (ICellRenderer<any> | null | undefined)[];
     private executeProcessRowPostCreateFunc;
-    private areAllContainersReady;
     private isNodeFullWidthCell;
     private setRowType;
-    private updateColumnLists;
     /**
      * Overridden by SpannedRowCtrl
      */
-    protected getNewCellCtrl(col: AgColumn): CellCtrl | undefined;
+    getNewCellCtrl(col: AgColumn): CellCtrl | undefined;
     /**
      * Overridden by SpannedRowCtrl, if span context changes cell needs rebuilt
      */
-    protected isCorrectCtrlForSpan(cell: CellCtrl): boolean;
-    private createCellCtrls;
-    /**
-     * Creates a new cell ctrl for the focused cell, if this is the correct row ctrl.
-     * @returns a CellCtrl for the focused cell, if required.
-     */
-    private createFocusedCellCtrl;
-    private updateColumnListsImpl;
-    private setCellCtrls;
-    private getCellCtrlsForContainer;
-    private createAllCellCtrls;
+    isCorrectCtrlForSpan(cell: CellCtrl): boolean;
+    setEmbeddedSectionHasContent(section: HorizontalSection, hasContent: boolean): void;
+    refreshPinnedCellGroupWidths(): void;
+    getMappedPinnedCellGroupWidths(): MappedPinnedCellGroupWidths;
+    getPinnedCellGroupWidths(): PinnedCellGroupWidths;
     /**
-     * CellCtrls for the container if eagerly created in the constructor, or `null`
-     * when creation is deferred (animation-frame path) or skipped (full-width rows).
-     * We don't want to enable this during scrolling as well, as it can cause sluggishness
-     * during scroll.
-     * Used by framework wrappers to seed first render and avoid bulk-add flicker.
+     * CellCtrls for rows whose normal-mode feature eagerly created cells in the constructor.
+     * React uses this to seed first render and avoid an empty row flash on bulk add.
      */
     getInitialCellCtrls(containerType: RowContainerType): CellCtrl[] | null;
-    private isCellEligibleToBeRemoved;
     getDomOrder(): boolean;
     private listenOnDomOrder;
     private setAnimateFlags;
     isFullWidth(): boolean;
-    refreshFullWidth(): boolean;
-    getNotesFeature(): INotesFeature | undefined;
+    /** Called by NormalRowFeature after refreshing cells */
+    onNormalRowRefreshed(): void;
+    getCurrentRowComp(): IRowComp | undefined;
+    getCurrentRowElement(): HTMLElement | undefined;
+    redrawThisRow(): void;
+    getRowType(): RowType;
+    getContainerType(): RowContainerType | undefined;
+    shouldCreateCellSections(): boolean;
+    getNotesFeature(): import("../../main-umd-noStyles").INotesFeature | undefined;
     private addListeners;
-    private addListenersForCellComps;
     /** Should only ever be triggered on source rows (i.e. not on pinned siblings) */
     private onRowPinned;
     private onRowNodeDataChanged;
@@ -149,38 +149,26 @@ export declare class RowCtrl extends BeanStub<RowCtrlEvent> {
     getRowPosition(): RowPosition;
     onKeyboardNavigate(keyboardEvent: KeyboardEvent): void;
     onTabKeyDown(keyboardEvent: KeyboardEvent): void;
-    getFullWidthElement(): HTMLElement | null;
+    getRowContentElement(): HTMLElement | null;
+    getNavigationColumn(): AgColumn;
     getRowYPosition(): number;
     onSuppressCellFocusChanged(suppressCellFocus: boolean): void;
-    private setupFocus;
-    private restoreFullWidthFocus;
-    private getFullWidthRowGuiForFocus;
-    private setFullWidthRowFocusedClass;
-    onFullWidthRowFocused(event?: CellFocusedEvent): void;
+    onRowFocused(event?: CellFocusedEvent): void;
     recreateCell(cellCtrl: CellCtrl): void;
-    private removeCellCtrl;
     onMouseEvent(eventName: string, mouseEvent: MouseEvent): void;
     createRowEvent<T extends AgEventType>(type: T, domEvent?: Event): RowEvent<T>;
     private createRowEventWithSource;
     private onRowDblClick;
-    findFullWidthInfoForEvent(event?: Event): {
-        rowGui: RowGui;
+    findInfoForEvent(event?: Event): {
         column: AgColumn;
         pinned: ColumnPinnedType;
     } | undefined;
-    private findFullWidthRowGui;
-    getColumnForFullWidth(fullWidthRowGui?: RowGui): AgColumn;
-    getPinnedForFullWidth(fullWidthRowGui?: RowGui): ColumnPinnedType;
-    addManagedGuiElementListeners<TEvent extends keyof HTMLElementEventMap>(gui: RowGui, handlers: {
-        [K in TEvent]?: (event: HTMLElementEventMap[K]) => void;
-    }): void;
+    getTargets(): FullWidthTarget[];
+    getTarget(element?: EventTarget | null): FullWidthTarget | undefined;
     private onRowMouseDown;
     isSuppressMouseEvent(mouseEvent: MouseEvent): boolean;
     onRowClick(mouseEvent: MouseEvent): void;
     setupDetailRowAutoHeight(eDetailGui: HTMLElement): void;
-    private createFullWidthCompDetails;
-    private setupFullWidthRowTooltip;
-    private addFullWidthRowDragging;
     private onUiLevelChanged;
     private isFirstRowOnPage;
     private isLastRowOnPage;
@@ -189,30 +177,51 @@ export declare class RowCtrl extends BeanStub<RowCtrlEvent> {
     private postProcessClassesFromGridOptions;
     private postProcessRowClassRules;
     private setStylesFromGridOptions;
-    private getPinnedForContainer;
-    protected getInitialRowClasses(rowContainerType: RowContainerType): string[];
+    protected getInitialRowClasses(): string[];
     private processStylesFromGridOptions;
     private onRowSelected;
     announceDescription(cellCtrl?: CellCtrl): void;
     private announceNoteDescription;
     protected addHoverFunctionality(eGui: RowGui): void;
     resetHoveredStatus(el?: HTMLElement): void;
+    getGui(): RowGui | undefined;
     private roundRowTopToBounds;
-    forEachGui(gui: RowGui | undefined, callback: (gui: RowGui) => void): void;
     isRowRendered(): boolean;
-    protected onRowHeightChanged(gui?: RowGui): void;
+    protected onRowHeightChanged(): void;
     destroyFirstPass(suppressAnimation?: boolean): void;
     destroySecondPass(): void;
     private setFocusedClasses;
     private onCellFocusChanged;
+    private onPinnedRowsChanged;
     private onPaginationChanged;
     private onTopChanged;
     private onPaginationPixelOffsetChanged;
+    private onStickyBottomOffsetChanged;
+    /**
+     * Applies pagination offset, eg if on second page, and page height is 500px, then removes
+     * 500px from the top position, so a row with rowTop 600px is displayed at location 100px.
+     * reverse will take the offset away rather than add.
+     */
     private applyPaginationOffset;
     setRowTop(pixels: number): void;
-    getInitialRowTop(rowContainerType: RowContainerType): string | undefined;
-    getInitialTransform(rowContainerType: RowContainerType): string | undefined;
+    /**
+     * Applies pagination offset and pixel scaling to produce final top position.
+     * Rows are positioned relative to their container, not the section.
+     */
+    private calculateRowTopPx;
+    /**
+     * The top needs to be set into the DOM element when the element is created, not updated afterwards.
+     * otherwise the transition would not work, as it would be transitioning from zero (the unset value).
+     * for example, suppose a row that is outside the viewport, then user does a filter to remove other rows
+     * and this row now appears in the viewport, and the row moves up (ie it was under the viewport and not rendered,
+     * but now is in the viewport) then a new RowComp is created, however it should have it's position initialised
+     * to below the viewport, so the row will appear to animate up. if we didn't set the initial position at creation
+     * time, the row would animate down (ie from position zero).
+     */
+    getInitialRowTop(): string | undefined;
+    getInitialTransform(): string | undefined;
     private getInitialRowTopShared;
+    private getCalculatedRowTop;
     private setRowTopStyle;
     getCellCtrl(column: AgColumn, skipColSpanSearch?: boolean): CellCtrl | null;
     protected onRowIndexChanged(): void;

package/dist/types/src/rendering/rowContainerHeightService.d.ts

@@ -11,6 +11,7 @@ export declare class RowContainerHeightService extends BeanStub implements Named
     private modelHeight;
     uiContainerHeight: number | null;
     private pixelsToShave;
+    stickyBottomRowsHeight: number;
     divStretchOffset: number;
     private scrollY;
     private uiBodyHeight;
@@ -23,6 +24,7 @@ export declare class RowContainerHeightService extends BeanStub implements Named
     private setDivStretchOffset;
     setModelHeight(modelHeight: number | null): void;
     getRealPixelPosition(modelPixel: number): number;
+    getAdjustedUiContainerHeight(): number | null;
     private getUiBodyHeight;
     getScrollPositionForPixel(rowTop: number): number;
 }

package/dist/types/src/rendering/rowRenderer.d.ts

@@ -1,4 +1,4 @@
-import type { IEventListener } from '../agStack/interfaces/iEventEmitter';
+import type { IEventListener } from 'ag-stack';
 import type { NamedBean } from '../context/bean';
 import { BeanStub } from '../context/beanStub';
 import type { BeanCollection } from '../context/context';
@@ -24,6 +24,7 @@ export declare class RowRenderer extends BeanStub implements NamedBean {
     private rowContainerHeight;
     private ctrlsSvc;
     private editSvc?;
+    private showValuesAsSvc;
     wireBeans(beans: BeanCollection): void;
     private gridBodyCtrl;
     private readonly destroyFuncsForColumnListeners;
@@ -84,12 +85,12 @@ export declare class RowRenderer extends BeanStub implements NamedBean {
      * if the column passed is the first column of the span (used for auto width calculation).
      */
     getAllCellsNotSpanningForColumn(column: AgColumn): HTMLElement[];
-    private refreshFloatingRowComps;
+    private refreshPinnedRowComps;
     /**
      * Determines which row controllers need to be destroyed and re-created vs which ones can
      * be re-used.
      *
-     * This is operation is to pinned/floating rows as `this.recycleRows` is to normal/body rows.
+     * This operation is to pinned rows as `this.recycleRows` is to normal/body rows.
      *
      * All `RowCtrl` instances in `rowCtrls` that don't correspond to `RowNode` instances in `rowNodes` are destroyed.
      * All `RowNode` instances in `rowNodes` that don't correspond to `RowCtrl` instances in `rowCtrls` are created.
@@ -98,7 +99,7 @@ export declare class RowRenderer extends BeanStub implements NamedBean {
      * @param rowCtrls The list of existing row controllers
      * @param rowNodes The canonical list of row nodes that should have associated controllers
      */
-    private refreshFloatingRows;
+    private refreshPinnedRows;
     private onPinnedRowDataChanged;
     private onPinnedRowsChanged;
     redrawRow(rowNode: RowNode, suppressEvent?: boolean): void;
@@ -121,7 +122,6 @@ export declare class RowRenderer extends BeanStub implements NamedBean {
     private getStickyRowCtrlByNode;
     /** Refreshes the rendered row for the given node if it is currently in the viewport. Null-safe: no-op when node is null or undefined. */
     refreshRowByNode(node: IRowNode | null | undefined): void;
-    private refreshFullWidth;
     /**
      * @param rowNodes if provided, returns the RowCtrls for the provided rowNodes. otherwise returns all RowCtrls.
      */
@@ -134,6 +134,7 @@ export declare class RowRenderer extends BeanStub implements NamedBean {
     private onBodyScroll;
     redraw(params?: {
         afterScroll?: boolean;
+        force?: boolean;
     }): void;
     private removeRowCompsNotToDraw;
     private calculateIndexesToDraw;

package/dist/types/src/rendering/spanning/rowSpanCache.d.ts

@@ -1,4 +1,4 @@
-import { BeanStub } from '../../context/beanStub';
+import type { BeanCollection } from '../../context/context';
 import type { AgColumn } from '../../entities/agColumn';
 import type { RowNode } from '../../entities/rowNode';
 import type { CellPosition } from '../../interfaces/iCellPosition';
@@ -33,14 +33,14 @@ export declare class CellSpan {
  *
  * Only create if spanning is enabled for this column.
  */
-export declare class RowSpanCache extends BeanStub {
-    private readonly column;
+export declare class RowSpanCache {
+    private readonly beans;
+    readonly column: AgColumn;
     private centerValueNodeMap;
     private topValueNodeMap;
     private bottomValueNodeMap;
-    constructor(column: AgColumn);
+    constructor(beans: BeanCollection, column: AgColumn);
     buildCache(pinned: 'top' | 'center' | 'bottom'): void;
-    isCellSpanning(node: RowNode): boolean;
     getCellSpan(node: RowNode): CellSpan | undefined;
     private getNodeMap;
 }

package/dist/types/src/rendering/spanning/rowSpanService.d.ts

@@ -8,20 +8,20 @@ export declare class RowSpanService extends BeanStub<'spannedCellsUpdated'> impl
     beanName: "rowSpanSvc";
     /** Active only if `enableCellSpan=true` */
     active: boolean;
-    private readonly spanningColumns;
+    private spanningColumns;
     postConstruct(): void;
-    /**
-     * When a new column is created with spanning (or spanning changes for a column)
-     * @param column column that is now spanning
-     */
-    register(column: AgColumn): void;
+    /** Create and build a span cache for `column`. Idempotent. */
+    private register;
+    /** `spanRows` config changed: start spanning, stop spanning, or rebuild if it still spans. */
+    columnRowSpanChanged(column: AgColumn): void;
+    /** Register newly-added spanning columns. Called post-commit, when values (e.g. calc cols) resolve. */
+    refreshCols(): void;
+    /** Rebuild all regions for one column's cache and signal consumers to re-render. */
+    private buildCache;
     private readonly debouncePinnedEvent;
     private readonly debounceModelEvent;
     private dispatchCellsUpdatedEvent;
-    /**
-     * When a new column is destroyed with spanning (or spanning changes for a column)
-     * @param column column that is now spanning
-     */
+    /** Drop `column`'s span cache (column destroyed or no longer spanning). */
     deregister(column: AgColumn): void;
     private pinnedTimeout;
     private modelTimeout;
@@ -32,14 +32,10 @@ export declare class RowSpanService extends BeanStub<'spannedCellsUpdated'> impl
     getCellSpanByPosition(position: CellPosition): CellSpan | undefined;
     getCellStart(position: CellPosition): CellPosition | undefined;
     getCellEnd(position: CellPosition): CellPosition | undefined;
-    /**
-     * Look-up a spanned cell given a col and node as position indicators
-     *
-     * @param col a column to lookup a span at this position
-     * @param rowNode a node that may be spanned at this position
-     * @returns the CellSpan object if one exists
-     */
-    getCellSpan(col: AgColumn, rowNode: RowNode): CellSpan | undefined;
-    forEachSpannedColumn(rowNode: RowNode, callback: (col: AgColumn, span: CellSpan) => void): void;
+    /** Look up the spanned cell at `column`/`rowNode`, if any. */
+    getCellSpan(column: AgColumn, rowNode: RowNode): CellSpan | undefined;
+    forEachSpannedColumn(rowNode: RowNode, callback: (column: AgColumn, span: CellSpan) => void): void;
+    private clearModelTimeout;
+    private clearPinnedTimeout;
     destroy(): void;
 }

package/dist/types/src/rendering/spanning/spannedRowCtrl.d.ts

@@ -1,11 +1,10 @@
 import type { AgColumn } from '../../entities/agColumn';
-import type { RowContainerType } from '../../gridBodyComp/rowContainer/rowContainerCtrl';
 import type { CellCtrl } from '../cell/cellCtrl';
 import { RowCtrl } from '../row/rowCtrl';
 export declare class SpannedRowCtrl extends RowCtrl {
-    protected getInitialRowClasses(_rowContainerType: RowContainerType): string[];
-    protected getNewCellCtrl(col: AgColumn<any>): CellCtrl | undefined;
-    protected isCorrectCtrlForSpan(cell: CellCtrl): boolean;
+    protected getInitialRowClasses(): string[];
+    getNewCellCtrl(col: AgColumn<any>): CellCtrl | undefined;
+    isCorrectCtrlForSpan(cell: CellCtrl): boolean;
     /**
      * Below overrides are explicitly disabling styling and other unwanted behaviours for spannedRowCtrl
      */

package/dist/types/src/rendering/spanning/spannedRowRenderer.d.ts

@@ -1,9 +1,10 @@
 import type { NamedBean } from '../../context/bean';
 import { BeanStub } from '../../context/beanStub';
 import type { CellPosition } from '../../interfaces/iCellPosition';
+import type { VerticalSection } from '../../interfaces/iGridSection';
 import type { CellCtrl } from '../cell/cellCtrl';
 import type { RowCtrl } from '../row/rowCtrl';
-type SpannedRowContainerType = 'top' | 'bottom' | 'center';
+type SpannedRowContainerType = VerticalSection | 'center';
 export declare class SpannedRowRenderer extends BeanStub<'spannedRowsUpdated'> implements NamedBean {
     beanName: "spannedRowRenderer";
     postConstruct(): void;
@@ -17,7 +18,7 @@ export declare class SpannedRowRenderer extends BeanStub<'spannedRowsUpdated'> i
     createCtrls(ctrlsKey: SpannedRowContainerType): void;
     private getAllRelevantRowControls;
     getCellByPosition(cellPosition: CellPosition): CellCtrl | undefined;
-    getCtrls(container: 'top' | 'bottom' | 'center'): RowCtrl[];
+    getCtrls(container: SpannedRowContainerType): RowCtrl[];
     private destroyRowCtrls;
     private getCtrlsMap;
     private setCtrlsMap;

package/dist/types/src/selection/baseSelectionService.d.ts

@@ -5,7 +5,7 @@ import type { RowNode } from '../entities/rowNode';
 import type { SelectionEventSourceType } from '../events';
 import type { IRowNode } from '../interfaces/iRowNode';
 import type { ISetNodesSelectedParams } from '../interfaces/iSelectionService';
-import type { RowCtrl, RowGui } from '../rendering/row/rowCtrl';
+import type { RowCtrl } from '../rendering/row/rowCtrl';
 import type { ChangedPath } from '../utils/changedPath';
 import { CheckboxSelectionComponent } from './checkboxSelectionComponent';
 import { RowRangeSelectionContext } from './rowRangeSelectionContext';
@@ -19,9 +19,9 @@ export declare abstract class BaseSelectionService extends BeanStub {
     createCheckboxSelectionComponent(): CheckboxSelectionComponent;
     createSelectAllFeature(column: AgColumn): SelectAllFeature | undefined;
     protected isMultiSelect(): boolean;
-    onRowCtrlSelected(rowCtrl: RowCtrl, hasFocusFunc: (gui: RowGui) => void, gui?: RowGui): void;
+    onRowCtrlSelected(rowCtrl: RowCtrl, hasFocusFunc: () => void): void;
     announceAriaRowSelection(rowNode: RowNode): void;
-    updateGroupsFromChildrenSelections?(source: SelectionEventSourceType, changedPath?: ChangedPath): boolean;
+    updateGroupsFromChildrenSelections?(source: SelectionEventSourceType, changedPath?: ChangedPath, event?: Event): boolean;
     abstract setNodesSelected(params: ISetNodesSelectedParams): number;
     protected abstract updateSelectable(changedPath?: ChangedPath): void;
     protected isRowSelectionBlocked(rowNode: RowNode): boolean;

package/dist/types/src/selection/selectionService.d.ts

@@ -32,7 +32,7 @@ export declare class SelectionService extends BaseSelectionService implements Na
      * events do not need fired in this case
      */
     filterFromSelection(predicate: (node: RowNode) => boolean): void;
-    updateGroupsFromChildrenSelections(source: SelectionEventSourceType, changedPath?: ChangedPath): boolean;
+    updateGroupsFromChildrenSelections(source: SelectionEventSourceType, changedPath?: ChangedPath, event?: Event): boolean;
     private clearOtherNodes;
     private onRowSelected;
     syncInRowNode(rowNode: RowNode, oldNode?: RowNode): void;

package/dist/types/src/sort/rowNodeSorter.d.ts

@@ -1,5 +1,6 @@
 import type { NamedBean } from '../context/bean';
 import { BeanStub } from '../context/beanStub';
+import type { BeanCollection } from '../context/context';
 import type { RowNode } from '../entities/rowNode';
 import type { SortOption } from '../interfaces/iSortOption';
 /** @internal AG_GRID_INTERNAL - Not for public use. Can change / be removed at any time. */
@@ -9,21 +10,13 @@ export declare class RowNodeSorter extends BeanStub implements NamedBean {
     private primaryColumnsSortGroups;
     private pivotActive;
     private firstLeaf;
+    private colModel;
+    private formula;
+    private valueSvc;
     postConstruct(): void;
-    private updateOptions;
-    private updatePivotModeState;
+    wireBeans(beans: BeanCollection): void;
     doFullSortInPlace(rowNodes: RowNode[], sortOptions: SortOption[]): RowNode[];
     compareRowNodes(sortOptions: SortOption[], nodeA: RowNode, nodeB: RowNode): number;
-    /**
-     * if user defines a comparator as a function then use that.
-     * if user defines a dictionary of comparators, then use the one matching the sort type.
-     * if no comparator provided, or no matching comparator found in dictionary, then return undefined.
-     *
-     * grid checks later if undefined is returned here and falls back to a default comparator corresponding to sort type on the coldef.
-     * @private
-     */
-    private getComparator;
-    private getComparatorFromColDef;
     private getValue;
     private getGroupDataValue;
 }

package/dist/types/src/sort/sortIndicatorComp.d.ts

@@ -1,5 +1,5 @@
 import type { AgColumn } from '../entities/agColumn';
-import type { SortDef } from '../entities/colDef';
+import type { SortDef } from '../interfaces/iSort';
 import type { ComponentSelector } from '../widgets/component';
 import { Component } from '../widgets/component';
 export declare class SortIndicatorComp extends Component {

package/dist/types/src/sort/sortOptionUtils.d.ts

@@ -0,0 +1,9 @@
+import type { ColumnModel } from '../columns/columnModel';
+import type { SortOption } from '../interfaces/iSortOption';
+/**
+ * Resolves each option's comparators in place so the sorter reads them directly per comparison: a comparator on
+ * the col applies to every row; a row-group display col otherwise falls back to its primary column's comparator
+ * (the sorter applies that fallback to leaf rows only). Call once after building an option array, before sorting.
+ * @internal AG_GRID_INTERNAL - Not for public use. Can change / be removed at any time.
+ */
+export declare const _resolveSortOptions: (options: SortOption[], colModel: ColumnModel) => void;

package/dist/types/src/sort/sortService.d.ts

@@ -1,47 +1,50 @@
 import type { NamedBean } from '../context/bean';
 import { BeanStub } from '../context/beanStub';
 import type { AgColumn } from '../entities/agColumn';
-import type { DisplaySortDef, SortDef, SortDirection } from '../entities/colDef';
 import type { ColumnEventType } from '../events';
+import type { DisplaySortDef, SortDef, SortDirection } from '../interfaces/iSort';
 import type { SortModelItem } from '../interfaces/iSortModelItem';
 import type { SortOption } from '../interfaces/iSortOption';
-import type { Component, ComponentSelector } from '../widgets/component';
+import type { Component } from '../widgets/component';
 import { SortIndicatorComp } from './sortIndicatorComp';
 /** @internal AG_GRID_INTERNAL - Not for public use. Can change / be removed at any time. */
 export declare class SortService extends BeanStub implements NamedBean {
     beanName: "sortSvc";
+    readonly SortIndicatorSelector: import("../main-umd-noStyles").ComponentSelector;
+    readonly SortIndicatorComp: typeof SortIndicatorComp;
+    private cols;
+    private map;
+    private opts;
+    private multi;
+    destroy(): void;
+    invalidate(): void;
     progressSort(column: AgColumn, multiSort: boolean, source: ColumnEventType): void;
     progressSortFromEvent(column: AgColumn, event: MouseEvent | KeyboardEvent): void;
     setSortForColumn(column: AgColumn, sortDef: SortDef, multiSort: boolean, source: ColumnEventType): void;
     private updateSortIndex;
     onSortChanged(source: string, columns?: AgColumn[]): void;
-    isSortActive(): boolean;
     dispatchSortChangedEvents(source: string, columns?: AgColumn[]): void;
     private clearSortBarTheseColumns;
     getNextSortDirection(column: AgColumn, currentSort?: SortDef | SortDirection | null): SortDef;
-    /**
-     * @returns a map of sort indexes for every sorted column, if groups sort primaries then they will have equivalent indices
-     */
-    private getIndexedSortMap;
-    getColumnsWithSortingOrdered(): AgColumn[];
-    /**
-     * Util method to collect sort items by going through sorted columns once.
-     */
-    private collectSortItems;
-    getSortModel(): SortModelItem[];
+    private getSortedCols;
+    private getIndexMap;
+    /** Sorted cols in display order. Pivot drops primary leaves (irrelevant to the result); coupled mode
+     *  interleaves each display group col with its source row-group cols (shared display index). */
+    private loadSortedCols;
+    /** Col -> display index. Coupled mode: source row-group cols share their display col's index (which
+     *  counts display cols only). Sets `multi`. */
+    private loadIndexMap;
     getSortOptions(): SortOption[];
-    canColumnDisplayMixedSort(column: AgColumn): boolean;
-    getDisplaySortForColumn(column: AgColumn): DisplaySortDef | null;
-    getDisplaySortIndexForColumn(column: AgColumn): number | null | undefined;
+    getDisplaySort(column: AgColumn): DisplaySortDef | null;
+    getDisplaySortIndex(column: AgColumn): number | undefined;
+    /** `true` when the indicator should show ordinal numbers (2+ distinct display indices). */
+    isMultiSort(): boolean;
     setupHeader(comp: Component, column: AgColumn): void;
     initCol(column: AgColumn): void;
-    /**
-     * Update a column's sort state from a sort definition.
-     * If `sortDefOrDirection` is `undefined`, the call is a no-op (no change).
-     */
+    /** Update a column's sort from a sort def; `undefined` is a no-op. */
     updateColSort(column: AgColumn, sortDefOrDirection: SortDirection | SortDef | undefined, source: ColumnEventType): void;
     private setColSort;
     setColSortIndex(column: AgColumn, sortOrder?: number | null): void;
-    createSortIndicator(skipTemplate?: boolean): SortIndicatorComp;
-    getSortIndicatorSelector(): ComponentSelector;
 }
+/** @internal AG_GRID_INTERNAL - Not for public use. Can change / be removed at any time. */
+export declare function _getSortModel(sortSvc: SortService | undefined): SortModelItem[];

package/dist/types/src/styling/calculatedColumnCss.d.ts

@@ -0,0 +1,5 @@
+import type { AgColumn } from '../entities/agColumn';
+import type { ICalculatedColumnsService } from '../interfaces/iCalculatedColumns';
+export declare const CSS_CALCULATED_COLUMN = "ag-calculated-column";
+export declare const CSS_CALCULATED_COLUMN_HIGHLIGHTED = "ag-calculated-column-highlighted";
+export declare function _getCalculatedColumnCssClasses(column: AgColumn | null | undefined, calculatedColsSvc: ICalculatedColumnsService | undefined): readonly string[];

package/dist/types/src/testing/testIdUtils.d.ts

@@ -75,9 +75,9 @@ export declare const agTestIdFor: {
     columnSelectListItemGroupClosedIcon(label?: string | null): string;
     columnSelectListItemCheckbox(label?: string | null): string;
     columnSelectListItemDragHandle(label?: string | null): string;
-    columnDropCellDragHandle(source: 'panel' | 'toolbar', area?: string | null, label?: string | null): string;
-    columnDropCellCancelButton(source: 'panel' | 'toolbar', area?: string | null, label?: string | null): string;
-    columnDropArea(source: 'panel' | 'toolbar', name?: string | null): string;
+    columnDropCellDragHandle(source: "panel" | "toolbar", area?: string | null, label?: string | null): string;
+    columnDropCellCancelButton(source: "panel" | "toolbar", area?: string | null, label?: string | null): string;
+    columnDropArea(source: "panel" | "toolbar", name?: string | null): string;
     /** Filter Tool Panel (New) */
     filterToolPanel(): string;
     filterToolPanelAddFilterButton(): string;