ag-grid-community 32.3.2 → 33.0.0

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

@@ -0,0 +1,167 @@
+import { BeanStub } from '../../context/beanStub';
+import type { BeanCollection } from '../../context/context';
+import type { AgColumn } from '../../entities/agColumn';
+import type { RowStyle } from '../../entities/gridOptions';
+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 { BrandedType } from '../../interfaces/brandedType';
+import type { RenderedRowEvent } from '../../interfaces/iCallbackParams';
+import type { RowPosition } from '../../interfaces/iRowPosition';
+import type { UserCompDetails } from '../../interfaces/iUserCompDetails';
+import { CellCtrl } from '../cell/cellCtrl';
+import type { ICellRenderer, ICellRendererParams } from '../cellRenderers/iCellRenderer';
+export type RowCtrlInstanceId = BrandedType<string, 'RowCtrlInstanceId'>;
+export interface IRowComp {
+    setDomOrder(domOrder: boolean): void;
+    addOrRemoveCssClass(cssClassName: string, on: boolean): void;
+    setCellCtrls(cellCtrls: CellCtrl[], useFlushSync: boolean): void;
+    showFullWidth(compDetails: UserCompDetails): void;
+    getFullWidthCellRenderer(): ICellRenderer | null | undefined;
+    setTop(top: string): void;
+    setTransform(transform: string): void;
+    setRowIndex(rowIndex: string): void;
+    setRowId(rowId: string): void;
+    setRowBusinessKey(businessKey: string): void;
+    setUserStyles(styles: RowStyle | undefined): void;
+    refreshFullWidth(getUpdatedParams: () => ICellRendererParams): boolean;
+}
+export interface RowGui {
+    rowComp: IRowComp;
+    element: HTMLElement;
+    containerType: RowContainerType;
+    compBean: BeanStub;
+}
+export declare const DOM_DATA_KEY_ROW_CTRL = "renderedRow";
+export type RowCtrlEvent = RenderedRowEvent;
+export declare class RowCtrl extends BeanStub<RowCtrlEvent> {
+    readonly rowNode: RowNode;
+    private readonly useAnimationFrameForCreate;
+    readonly printLayout: boolean;
+    readonly instanceId: RowCtrlInstanceId;
+    private tooltipFeature;
+    private rowType;
+    private leftGui;
+    private centerGui;
+    private rightGui;
+    private fullWidthGui;
+    private allRowGuis;
+    private firstRowOnPage;
+    private lastRowOnPage;
+    private active;
+    stoppingRowEdit: boolean;
+    /** full row editing */
+    editing: boolean;
+    private rowFocused;
+    private centerCellCtrls;
+    private leftCellCtrls;
+    private rightCellCtrls;
+    private slideInAnimation;
+    private fadeInAnimation;
+    private rowDragComps;
+    private paginationPage;
+    private lastMouseDownOnDragger;
+    private rowLevel;
+    rowStyles: RowStyle;
+    private readonly emptyStyle;
+    private readonly suppressRowTransform;
+    private updateColumnListsPending;
+    rowId: string | null;
+    /** sanitised */
+    businessKey: string | null;
+    private businessKeyForNodeFunc;
+    constructor(rowNode: RowNode, beans: BeanCollection, animateIn: boolean, useAnimationFrameForCreate: boolean, printLayout: boolean);
+    private initRowBusinessKey;
+    private updateRowBusinessKey;
+    private updateGui;
+    setComp(rowComp: IRowComp, element: HTMLElement, containerType: RowContainerType, compBean: BeanStub<any> | undefined): void;
+    unsetComp(containerType: RowContainerType): void;
+    isCacheable(): boolean;
+    setCached(cached: boolean): void;
+    private initialiseRowComp;
+    private setRowCompRowBusinessKey;
+    private setRowCompRowId;
+    private executeSlideAndFadeAnimations;
+    private addRowDraggerToRow;
+    private setupFullWidth;
+    getFullWidthCellRenderers(): (ICellRenderer<any> | null | undefined)[];
+    private executeProcessRowPostCreateFunc;
+    private areAllContainersReady;
+    private isNodeFullWidthCell;
+    private setRowType;
+    private updateColumnLists;
+    private createCellCtrls;
+    private updateColumnListsImpl;
+    private setCellCtrls;
+    private getCellCtrlsForContainer;
+    private createAllCellCtrls;
+    private isCellEligibleToBeRemoved;
+    getDomOrder(): boolean;
+    private listenOnDomOrder;
+    private setAnimateFlags;
+    isFullWidth(): boolean;
+    refreshFullWidth(): boolean;
+    private addListeners;
+    private addListenersForCellComps;
+    private onRowNodeDataChanged;
+    private postProcessCss;
+    private onRowNodeHighlightChanged;
+    private postProcessRowDragging;
+    private onDisplayedColumnsChanged;
+    private onVirtualColumnsChanged;
+    getRowPosition(): RowPosition;
+    private findFullWidthRowGui;
+    onKeyboardNavigate(keyboardEvent: KeyboardEvent): void;
+    onTabKeyDown(keyboardEvent: KeyboardEvent): void;
+    getFullWidthElement(): HTMLElement | null;
+    getRowYPosition(): number;
+    onSuppressCellFocusChanged(suppressCellFocus: boolean): void;
+    onFullWidthRowFocused(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;
+    private getColumnForFullWidth;
+    private onRowMouseDown;
+    onRowClick(mouseEvent: MouseEvent): void;
+    setupDetailRowAutoHeight(eDetailGui: HTMLElement): void;
+    private createFullWidthCompDetails;
+    private refreshRowTooltip;
+    private addFullWidthRowDragging;
+    private onUiLevelChanged;
+    private isFirstRowOnPage;
+    private isLastRowOnPage;
+    private refreshFirstAndLastRowStyles;
+    getAllCellCtrls(): CellCtrl[];
+    private postProcessClassesFromGridOptions;
+    private postProcessRowClassRules;
+    private setStylesFromGridOptions;
+    private getPinnedForContainer;
+    private getInitialRowClasses;
+    private processStylesFromGridOptions;
+    private onRowSelected;
+    announceDescription(): void;
+    addHoverFunctionality(eGui: RowGui): void;
+    private roundRowTopToBounds;
+    forEachGui(gui: RowGui | undefined, callback: (gui: RowGui) => void): void;
+    private onRowHeightChanged;
+    destroyFirstPass(suppressAnimation?: boolean): void;
+    destroySecondPass(): void;
+    private setFocusedClasses;
+    private onCellFocusChanged;
+    private onPaginationChanged;
+    private onTopChanged;
+    private onPaginationPixelOffsetChanged;
+    private applyPaginationOffset;
+    setRowTop(pixels: number): void;
+    getInitialRowTop(rowContainerType: RowContainerType): string | undefined;
+    getInitialTransform(rowContainerType: RowContainerType): string | undefined;
+    private getInitialRowTopShared;
+    private setRowTopStyle;
+    getCellCtrl(column: AgColumn, skipColSpanSearch?: boolean): CellCtrl | null;
+    private onRowIndexChanged;
+    private updateRowIndexes;
+}

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

@@ -0,0 +1,28 @@
+import type { NamedBean } from '../context/bean';
+import { BeanStub } from '../context/beanStub';
+/**
+ * This class solves the 'max height' problem, where the user might want to show more data than
+ * the max div height actually allows.
+ */
+export declare class RowContainerHeightService extends BeanStub implements NamedBean {
+    beanName: "rowContainerHeight";
+    private maxDivHeight;
+    stretching: boolean;
+    private modelHeight;
+    uiContainerHeight: number | null;
+    private pixelsToShave;
+    divStretchOffset: number;
+    private scrollY;
+    private uiBodyHeight;
+    private maxScrollY;
+    postConstruct(): void;
+    updateOffset(): void;
+    private calculateOffset;
+    private setUiContainerHeight;
+    private clearOffset;
+    private setDivStretchOffset;
+    setModelHeight(modelHeight: number | null): void;
+    getRealPixelPosition(modelPixel: number): number;
+    private getUiBodyHeight;
+    getScrollPositionForPixel(rowTop: number): number;
+}

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

@@ -0,0 +1,157 @@
+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 { RowNode } from '../entities/rowNode';
+import type { RenderedRowEvent } from '../interfaces/iCallbackParams';
+import type { RefreshCellsParams } from '../interfaces/iCellsParams';
+import type { IEventListener } from '../interfaces/iEventEmitter';
+import type { IRowNode } from '../interfaces/iRowNode';
+import type { RowPosition } from '../interfaces/iRowPosition';
+import type { CellCtrl } from './cell/cellCtrl';
+import { RowCtrl } from './row/rowCtrl';
+interface RowNodeMap {
+    [id: string]: IRowNode;
+}
+export declare class RowRenderer extends BeanStub implements NamedBean {
+    beanName: "rowRenderer";
+    private pageBounds;
+    private colModel;
+    private pinnedRowModel?;
+    private rowModel;
+    private focusSvc;
+    private rowContainerHeight;
+    private ctrlsSvc;
+    wireBeans(beans: BeanCollection): void;
+    private gridBodyCtrl;
+    private destroyFuncsForColumnListeners;
+    firstRenderedRow: number;
+    lastRenderedRow: number;
+    private rowCtrlsByRowIndex;
+    private zombieRowCtrls;
+    private cachedRowCtrls;
+    allRowCtrls: RowCtrl[];
+    topRowCtrls: RowCtrl[];
+    bottomRowCtrls: RowCtrl[];
+    private pinningLeft;
+    private pinningRight;
+    firstVisibleVPixel: number;
+    lastVisibleVPixel: number;
+    private refreshInProgress;
+    private printLayout;
+    private embedFullWidthRows;
+    private stickyRowFeature?;
+    private dataFirstRenderedFired;
+    postConstruct(): void;
+    private initialise;
+    private initialiseCache;
+    private getKeepDetailRowsCount;
+    getStickyTopRowCtrls(): RowCtrl[];
+    getStickyBottomRowCtrls(): RowCtrl[];
+    private updateAllRowCtrls;
+    private onCellFocusChanged;
+    private onSuppressCellFocusChanged;
+    private registerCellEventListeners;
+    private setupRangeSelectionListeners;
+    private removeGridColumnListeners;
+    private refreshListenersToColumnsForCellComps;
+    private onDomLayoutChanged;
+    datasourceChanged(): void;
+    private onPageLoaded;
+    /**
+     * @param column AgColumn
+     * @returns An array with HTMLElement for every cell of the column passed as param.
+     * If the cell is spanning across multiple columns, it only returns the html element
+     * if the column passed is the first column of the span (used for auto width calculation).
+     */
+    getAllCellsNotSpanningForColumn(column: AgColumn): HTMLElement[];
+    refreshFloatingRowComps(): void;
+    /**
+     * 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.
+     *
+     * 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.
+     * All instances in `rowCtrls` must be in the same order as their corresponding nodes in `rowNodes`.
+     *
+     * @param rowCtrls The list of existing row controllers
+     * @param rowNodes The canonical list of row nodes that should have associated controllers
+     */
+    private refreshFloatingRows;
+    private onPinnedRowDataChanged;
+    redrawRow(rowNode: RowNode, suppressEvent?: boolean): void;
+    redrawRows(rowNodes?: IRowNode[]): void;
+    private getCellToRestoreFocusToAfterRefresh;
+    private redrawAfterModelUpdate;
+    private scrollToTopIfNewData;
+    private updateContainerHeights;
+    private getLockOnRefresh;
+    private releaseLockOnRefresh;
+    isRefreshInProgress(): boolean;
+    private restoreFocusedCell;
+    getAllCellCtrls(): CellCtrl[];
+    getAllRowCtrls(): RowCtrl[];
+    addRenderedRowListener(eventName: RenderedRowEvent, rowIndex: number, callback: IEventListener<RenderedRowEvent>): void;
+    refreshCells(params?: RefreshCellsParams): void;
+    private refreshFullWidth;
+    /**
+     * @param rowNodes if provided, returns the RowCtrls for the provided rowNodes. otherwise returns all RowCtrls.
+     */
+    getRowCtrls(rowNodes?: IRowNode[] | null): RowCtrl[];
+    getCellCtrls(rowNodes?: IRowNode[] | null, columns?: (string | AgColumn)[]): CellCtrl[];
+    destroy(): void;
+    private removeAllRowComps;
+    private getRowsToRecycle;
+    private removeRowCtrls;
+    private onBodyScroll;
+    redraw(params?: {
+        afterScroll?: boolean;
+    }): void;
+    private removeRowCompsNotToDraw;
+    private calculateIndexesToDraw;
+    private recycleRows;
+    private dispatchDisplayedRowsChanged;
+    private onDisplayedColumnsChanged;
+    private redrawFullWidthEmbeddedRows;
+    getFullWidthRowCtrls(rowNodes?: IRowNode[]): RowCtrl[];
+    private createOrUpdateRowCtrl;
+    private destroyRowCtrls;
+    private getRowBuffer;
+    private getRowBufferInPixels;
+    private workOutFirstAndLastRowsToRender;
+    /**
+     * This event will only be fired once, and is queued until after the browser next renders.
+     * This allows us to fire an event during the start of the render cycle, when we first see data being rendered
+     * but not execute the event until all of the data has finished being rendered to the dom.
+     */
+    dispatchFirstDataRenderedEvent(): void;
+    private ensureAllRowsInRangeHaveHeightsCalculated;
+    private doNotUnVirtualiseRow;
+    private isRowPresent;
+    private createRowCon;
+    getRenderedNodes(): RowNode<any>[];
+    getRowByPosition(rowPosition: RowPosition): RowCtrl | null;
+    isRangeInRenderedViewport(startIndex: number, endIndex: number): boolean;
+}
+export interface RefreshViewParams {
+    recycleRows?: boolean;
+    animate?: boolean;
+    suppressKeepFocus?: boolean;
+    onlyBody?: boolean;
+    newData?: boolean;
+    newPage?: boolean;
+    domLayoutChanged?: boolean;
+}
+export declare function mapRowNodes(rowNodes?: IRowNode[] | null): {
+    top: RowNodeMap;
+    bottom: RowNodeMap;
+    normal: RowNodeMap;
+} | undefined;
+export declare function isRowInMap(rowNode: RowNode, rowIdsMap: {
+    top: RowNodeMap;
+    bottom: RowNodeMap;
+    normal: RowNodeMap;
+}): boolean;
+export {};

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

@@ -0,0 +1,46 @@
+import { BeanStub } from '../context/beanStub';
+import type { AgColumn } from '../entities/agColumn';
+import type { IsRowSelectable } from '../entities/gridOptions';
+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 { ChangedPath } from '../utils/changedPath';
+import { CheckboxSelectionComponent } from './checkboxSelectionComponent';
+import { RowRangeSelectionContext } from './rowRangeSelectionContext';
+import { SelectAllFeature } from './selectAllFeature';
+export declare abstract class BaseSelectionService extends BeanStub {
+    protected isRowSelectable?: IsRowSelectable;
+    protected selectionCtx: RowRangeSelectionContext;
+    postConstruct(): void;
+    destroy(): void;
+    createCheckboxSelectionComponent(): CheckboxSelectionComponent;
+    createSelectAllFeature(column: AgColumn): SelectAllFeature;
+    protected isMultiSelect(): boolean;
+    onRowCtrlSelected(rowCtrl: RowCtrl, hasFocusFunc: (gui: RowGui) => void, gui?: RowGui): void;
+    announceAriaRowSelection(rowNode: RowNode): void;
+    protected dispatchSelectionChanged(source: SelectionEventSourceType): void;
+    updateGroupsFromChildrenSelections?(source: SelectionEventSourceType, changedPath?: ChangedPath): boolean;
+    abstract setNodesSelected(params: ISetNodesSelectedParams): number;
+    protected abstract updateSelectable(changedPath?: ChangedPath): void;
+    protected isRowSelectionBlocked(rowNode: RowNode): boolean;
+    updateRowSelectable(rowNode: RowNode, suppressSelectionUpdate?: boolean): boolean;
+    protected setRowSelectable(rowNode: RowNode, newVal: boolean, suppressSelectionUpdate?: boolean): void;
+    protected calculateSelectedFromChildren(rowNode: RowNode): boolean | undefined | null;
+    selectRowNode(rowNode: RowNode, newValue?: boolean, e?: Event, source?: SelectionEventSourceType): boolean;
+    isCellCheckboxSelection(column: AgColumn, rowNode: IRowNode): boolean;
+    protected inferNodeSelections(node: RowNode, shiftKey: boolean, metaKey: boolean, source: SelectionEventSourceType): null | NodeSelection;
+}
+interface SingleNodeSelection {
+    node: RowNode;
+    newValue: boolean;
+    clearSelection: boolean;
+}
+interface MultiNodeSelection {
+    select: readonly RowNode[];
+    deselect: readonly RowNode[];
+    reset: boolean;
+}
+type NodeSelection = SingleNodeSelection | MultiNodeSelection;
+export {};

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

@@ -0,0 +1,28 @@
+import type { AgColumn } from '../entities/agColumn';
+import type { CheckboxSelectionCallback } from '../entities/colDef';
+import type { RowNode } from '../entities/rowNode';
+import type { GroupCheckboxSelectionCallback } from '../interfaces/groupCellRenderer';
+import { Component } from '../widgets/component';
+export declare class CheckboxSelectionComponent extends Component {
+    private readonly eCheckbox;
+    private rowNode;
+    private column;
+    private overrides?;
+    constructor();
+    postConstruct(): void;
+    getCheckboxId(): string;
+    private onDataChanged;
+    private onSelectableChanged;
+    private onSelectionChanged;
+    init(params: {
+        rowNode: RowNode;
+        column?: AgColumn;
+        overrides?: {
+            isVisible: boolean | CheckboxSelectionCallback | GroupCheckboxSelectionCallback | undefined;
+            callbackParams: any;
+            removeHidden: boolean;
+        };
+    }): void;
+    private showOrHideSelect;
+    private getIsVisible;
+}

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

@@ -0,0 +1,50 @@
+import type { RowNode } from '../entities/rowNode';
+import type { IRowModel } from '../interfaces/iRowModel';
+interface RangePartition {
+    keep: readonly RowNode[];
+    discard: readonly RowNode[];
+}
+/**
+ * The context of a row range selection operation.
+ *
+ * Used to model the stateful range selection behaviour found in Excel, where
+ * a given cell/row represents the "root" of a selection range, and subsequent
+ * selections are based off that root.
+ *
+ * See AG-9620 for more
+ */
+export declare class RowRangeSelectionContext {
+    private rootId;
+    /**
+     * Note that the "end" `RowNode` may come before or after the "root" `RowNode` in the
+     * actual grid.
+     */
+    private endId;
+    private rowModel;
+    private cachedRange;
+    constructor(rowModel: IRowModel);
+    reset(): void;
+    setRoot(node: RowNode): void;
+    setEndRange(end: RowNode): void;
+    getRange(): readonly RowNode[];
+    isInRange(node: RowNode): boolean;
+    getRoot(): RowNode | null;
+    private getEnd;
+    /**
+     * Truncates the range to the given node (assumed to be within the current range).
+     * Returns nodes that remain in the current range and those that should be removed
+     *
+     * @param node - Node at which to truncate the range
+     * @returns Object of nodes to either keep or discard (i.e. deselect) from the range
+     */
+    truncate(node: RowNode): RangePartition;
+    /**
+     * Extends the range to the given node. Returns nodes that remain in the current range
+     * and those that should be removed.
+     *
+     * @param node - Node marking the new end of the range
+     * @returns Object of nodes to either keep or discard (i.e. deselect) from the range
+     */
+    extend(node: RowNode, groupSelectsChildren?: boolean): RangePartition;
+}
+export {};

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

@@ -0,0 +1,21 @@
+import type { BeanCollection } from '../context/context';
+import type { SelectAllMode } from '../entities/gridOptions';
+import type { SelectionEventSourceType } from '../events';
+import type { IRowNode } from '../interfaces/iRowNode';
+export declare function setNodesSelected(beans: BeanCollection, params: {
+    nodes: IRowNode[];
+    newValue: boolean;
+    source?: SelectionEventSourceType;
+}): void;
+export declare function selectAll(beans: BeanCollection, selectAll?: SelectAllMode, source?: SelectionEventSourceType): void;
+export declare function deselectAll(beans: BeanCollection, selectAll?: SelectAllMode, source?: SelectionEventSourceType): void;
+/** @deprecated v33 */
+export declare function selectAllFiltered(beans: BeanCollection, source?: SelectionEventSourceType): void;
+/** @deprecated v33 */
+export declare function deselectAllFiltered(beans: BeanCollection, source?: SelectionEventSourceType): void;
+/** @deprecated v33 */
+export declare function selectAllOnCurrentPage(beans: BeanCollection, source?: SelectionEventSourceType): void;
+/** @deprecated v33 */
+export declare function deselectAllOnCurrentPage(beans: BeanCollection, source?: SelectionEventSourceType): void;
+export declare function getSelectedNodes<TData = any>(beans: BeanCollection): IRowNode<TData>[];
+export declare function getSelectedRows<TData = any>(beans: BeanCollection): TData[];

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

@@ -0,0 +1,10 @@
+import type { _RowSelectionGridApi } from '../api/gridApi';
+import type { _ModuleWithApi, _ModuleWithoutApi } from '../interfaces/iModule';
+/**
+ * @internal
+ */
+export declare const SharedRowSelectionModule: _ModuleWithApi<_RowSelectionGridApi>;
+/**
+ * @feature Selection -> Row Selection
+ */
+export declare const RowSelectionModule: _ModuleWithoutApi;

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

@@ -0,0 +1,29 @@
+import { BeanStub } from '../context/beanStub';
+import type { AgColumn } from '../entities/agColumn';
+import type { HeaderCellCtrl } from '../headerRendering/cells/column/headerCellCtrl';
+export declare class SelectAllFeature extends BeanStub {
+    private readonly column;
+    private cbSelectAllVisible;
+    private processingEventFromCheckbox;
+    private headerCellCtrl;
+    private cbSelectAll;
+    constructor(column: AgColumn);
+    onSpaceKeyDown(e: KeyboardEvent): void;
+    getCheckboxGui(): HTMLElement;
+    setComp(ctrl: HeaderCellCtrl): void;
+    private onDisplayedColumnsChanged;
+    private showOrHideSelectAll;
+    private onModelChanged;
+    private onSelectionChanged;
+    private updateStateOfCheckbox;
+    private refreshSelectAllLabel;
+    private checkSelectionType;
+    private checkRightRowModelType;
+    private onCbSelectAll;
+    /**
+     * Checkbox is enabled when either the `headerCheckbox` option is enabled in the new selection API
+     * or `headerCheckboxSelection` is enabled in the legacy API.
+     */
+    private isCheckboxSelection;
+    private getSelectAllMode;
+}

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

@@ -0,0 +1,70 @@
+import type { NamedBean } from '../context/bean';
+import type { SelectAllMode } from '../entities/gridOptions';
+import { RowNode } from '../entities/rowNode';
+import type { SelectionEventSourceType } from '../events';
+import type { ISelectionService, ISetNodesSelectedParams } from '../interfaces/iSelectionService';
+import type { ServerSideRowGroupSelectionState, ServerSideRowSelectionState } from '../interfaces/selectionState';
+import { ChangedPath } from '../utils/changedPath';
+import { BaseSelectionService } from './baseSelectionService';
+export declare class SelectionService extends BaseSelectionService implements NamedBean, ISelectionService {
+    beanName: "selectionSvc";
+    private selectedNodes;
+    private groupSelectsDescendants;
+    private groupSelectsFiltered;
+    private mode?;
+    postConstruct(): void;
+    destroy(): void;
+    handleSelectionEvent(event: MouseEvent | KeyboardEvent, rowNode: RowNode, source: SelectionEventSourceType): number;
+    setNodesSelected({ newValue, clearSelection, suppressFinishActions, nodes, event, source, }: ISetNodesSelectedParams): number;
+    private selectRange;
+    private selectChildren;
+    getSelectedNodes(): RowNode[];
+    getSelectedRows(): any[];
+    getSelectionCount(): number;
+    /**
+     * This method is used by the CSRM to remove groups which are being disposed of,
+     * events do not need fired in this case
+     */
+    filterFromSelection(predicate: (node: RowNode) => boolean): void;
+    updateGroupsFromChildrenSelections(source: SelectionEventSourceType, changedPath?: ChangedPath): boolean;
+    private clearOtherNodes;
+    private onRowSelected;
+    syncInRowNode(rowNode: RowNode, oldNode?: RowNode): void;
+    createDaemonNode(rowNode: RowNode): RowNode | undefined;
+    private syncInOldRowNode;
+    private syncInNewRowNode;
+    reset(source: SelectionEventSourceType): void;
+    private resetNodes;
+    getBestCostNodeSelection(): RowNode[] | undefined;
+    isEmpty(): boolean;
+    deselectAllRowNodes(params: {
+        source: SelectionEventSourceType;
+        selectAll?: SelectAllMode;
+    }): void;
+    private getSelectedCounts;
+    getSelectAllState(selectAll?: SelectAllMode): boolean | null;
+    hasNodesToSelect(selectAll: SelectAllMode): boolean;
+    /**
+     * @param selectAll See `MultiRowSelectionOptions.selectAll`
+     * @returns all nodes including unselectable nodes which are the target of this selection attempt
+     */
+    private getNodesToSelect;
+    private forEachNodeOnPage;
+    selectAllRowNodes(params: {
+        source: SelectionEventSourceType;
+        selectAll?: SelectAllMode;
+    }): void;
+    getSelectionState(): string[] | null;
+    setSelectionState(state: string[] | ServerSideRowSelectionState | ServerSideRowGroupSelectionState, source: SelectionEventSourceType): void;
+    private canSelectAll;
+    /**
+     * Updates the selectable state for a node by invoking isRowSelectable callback.
+     * If the node is not selectable, it will be deselected.
+     *
+     * Callers:
+     *  - property isRowSelectable changed
+     *  - after grouping / treeData via `updateSelectableAfterGrouping`
+     */
+    protected updateSelectable(changedPath?: ChangedPath): void;
+    updateSelectableAfterGrouping(changedPath: ChangedPath | undefined): void;
+}

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

@@ -0,0 +1,18 @@
+import type { NamedBean } from '../context/bean';
+import { BeanStub } from '../context/beanStub';
+import type { RowNode } from '../entities/rowNode';
+import type { SortOption } from '../interfaces/iSortOption';
+export interface SortedRowNode {
+    currentPos: number;
+    rowNode: RowNode;
+}
+export declare class RowNodeSorter extends BeanStub implements NamedBean {
+    beanName: "rowNodeSorter";
+    private isAccentedSort;
+    private primaryColumnsSortGroups;
+    postConstruct(): void;
+    doFullSort(rowNodes: RowNode[], sortOptions: SortOption[]): RowNode[];
+    compareRowNodes(sortOptions: SortOption[], sortedNodeA: SortedRowNode, sortedNodeB: SortedRowNode): number;
+    private getComparator;
+    private getValue;
+}

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

@@ -0,0 +1,22 @@
+import type { AgColumn } from '../entities/agColumn';
+import type { ComponentSelector } from '../widgets/component';
+import { Component } from '../widgets/component';
+export declare class SortIndicatorComp extends Component {
+    private eSortOrder;
+    private eSortAsc;
+    private eSortDesc;
+    private eSortMixed;
+    private eSortNone;
+    private column;
+    private suppressOrder;
+    constructor(skipTemplate?: boolean);
+    attachCustomElements(eSortOrder: HTMLElement, eSortAsc: HTMLElement, eSortDesc: HTMLElement, eSortMixed: HTMLElement, eSortNone: HTMLElement): void;
+    setupSort(column: AgColumn, suppressOrder?: boolean): void;
+    private addInIcon;
+    private onSortChanged;
+    private updateIcons;
+    private setupMultiSortIndicator;
+    private updateMultiSortIndicator;
+    private updateSortOrder;
+}
+export declare const SortIndicatorSelector: ComponentSelector;

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

@@ -0,0 +1,7 @@
+import type { _SortGridApi } from '../api/gridApi';
+import type { _ModuleWithApi } from '../interfaces/iModule';
+/**
+ * @feature Rows -> Row Sorting
+ * @colDef sortable, sort, sortIndex
+ */
+export declare const SortModule: _ModuleWithApi<_SortGridApi>;