ag-grid-community 32.3.2 → 33.0.0

package/dist/types/src/navigation/cellNavigationService.d.ts

@@ -0,0 +1,25 @@
+import type { NamedBean } from '../context/bean';
+import { BeanStub } from '../context/beanStub';
+import type { AgColumn } from '../entities/agColumn';
+import type { CellPosition } from '../interfaces/iCellPosition';
+import type { IRowNode } from '../interfaces/iRowNode';
+import type { RowPosition } from '../interfaces/iRowPosition';
+export declare class CellNavigationService extends BeanStub implements NamedBean {
+    beanName: "cellNavigation";
+    getNextCellToFocus(key: string, focusedCell: CellPosition, ctrlPressed?: boolean): CellPosition | null;
+    private getNextCellToFocusWithCtrlPressed;
+    private getNextCellToFocusWithoutCtrlPressed;
+    private isCellGoodToFocusOn;
+    private getCellToLeft;
+    private getCellToRight;
+    getRowBelow(rowPosition: RowPosition): RowPosition | null;
+    private getNextStickyPosition;
+    private getCellBelow;
+    private isLastRowInContainer;
+    getRowAbove(rowPosition: RowPosition): RowPosition | null;
+    private getCellAbove;
+    getNextTabbedCell(gridCell: CellPosition, backwards: boolean): CellPosition | null;
+    getNextTabbedCellForwards(gridCell: CellPosition): CellPosition | null;
+    getNextTabbedCellBackwards(gridCell: CellPosition): CellPosition | null;
+    isSuppressNavigable(column: AgColumn, rowNode: IRowNode): boolean;
+}

package/dist/types/src/navigation/headerNavigationService.d.ts

@@ -0,0 +1,22 @@
+import type { NamedBean } from '../context/bean';
+import { BeanStub } from '../context/beanStub';
+import type { AgColumn } from '../entities/agColumn';
+import type { AgColumnGroup } from '../entities/agColumnGroup';
+import type { Column, ColumnGroup } from '../interfaces/iColumn';
+import type { HeaderPosition } from '../interfaces/iHeaderPosition';
+export type HeaderNavigationDirection = 'UP' | 'DOWN' | 'LEFT' | 'RIGHT';
+export declare function getHeaderIndexToFocus(column: AgColumn | AgColumnGroup, currentIndex: number): HeaderPosition;
+export declare class HeaderNavigationService extends BeanStub implements NamedBean {
+    beanName: "headerNavigation";
+    private gridBodyCon;
+    currentHeaderRowWithoutSpan: number;
+    postConstruct(): void;
+    getHeaderPositionForColumn(colKey: string | Column | ColumnGroup, floatingFilter: boolean): HeaderPosition | null;
+    navigateVertically(direction: HeaderNavigationDirection, fromHeader: HeaderPosition | null, event: KeyboardEvent): boolean;
+    navigateHorizontally(direction: HeaderNavigationDirection, fromTab: boolean | undefined, event: KeyboardEvent): boolean;
+    private focusNextHeaderRow;
+    scrollToColumn(column: AgColumn | AgColumnGroup, direction?: 'Before' | 'After' | null): void;
+    private findHeader;
+    private getHeaderRowType;
+    private findColAtEdgeForHeaderRow;
+}

package/dist/types/src/navigation/navigationApi.d.ts

@@ -0,0 +1,10 @@
+import type { BeanCollection } from '../context/context';
+import type { CellPosition } from '../interfaces/iCellPosition';
+import type { Column, ColumnGroup } from '../interfaces/iColumn';
+import type { RowPinnedType } from '../interfaces/iRowNode';
+export declare function getFocusedCell(beans: BeanCollection): CellPosition | null;
+export declare function clearFocusedCell(beans: BeanCollection): void;
+export declare function setFocusedCell(beans: BeanCollection, rowIndex: number, colKey: string | Column, rowPinned?: RowPinnedType): void;
+export declare function tabToNextCell(beans: BeanCollection, event?: KeyboardEvent): boolean;
+export declare function tabToPreviousCell(beans: BeanCollection, event?: KeyboardEvent): boolean;
+export declare function setFocusedHeader(beans: BeanCollection, colKey: string | Column | ColumnGroup, floatingFilter?: boolean): void;

package/dist/types/src/navigation/navigationModule.d.ts

@@ -0,0 +1,6 @@
+import type { _KeyboardNavigationGridApi } from '../api/gridApi';
+import type { _ModuleWithApi } from '../interfaces/iModule';
+/**
+ * @feature Interactivity -> Keyboard Navigation
+ */
+export declare const KeyboardNavigationModule: _ModuleWithApi<_KeyboardNavigationGridApi>;

package/dist/types/src/navigation/navigationService.d.ts

@@ -0,0 +1,44 @@
+import type { NamedBean } from '../context/bean';
+import { BeanStub } from '../context/beanStub';
+import type { CellPosition } from '../interfaces/iCellPosition';
+import type { RowPosition } from '../interfaces/iRowPosition';
+import { CellCtrl } from '../rendering/cell/cellCtrl';
+import { RowCtrl } from '../rendering/row/rowCtrl';
+export declare class NavigationService extends BeanStub implements NamedBean {
+    beanName: "navigation";
+    private gridBodyCon;
+    constructor();
+    postConstruct(): void;
+    handlePageScrollingKey(event: KeyboardEvent, fromFullWidth?: boolean): boolean;
+    private handlePageUpDown;
+    private navigateTo;
+    private onPageDown;
+    private onPageUp;
+    private navigateToNextPage;
+    private navigateToNextPageWithAutoHeight;
+    private getNextFocusIndexForAutoHeight;
+    private getViewportHeight;
+    private isRowTallerThanView;
+    private onCtrlUpDownLeftRight;
+    private onHomeOrEndKey;
+    onTabKeyDown(previous: CellCtrl | RowCtrl, keyboardEvent: KeyboardEvent): void;
+    tabToNextCell(backwards: boolean, event?: KeyboardEvent): boolean;
+    private tabToNextCellCommon;
+    private moveToNextEditingCell;
+    private moveToNextEditingRow;
+    private moveToNextCellNotEditing;
+    /**
+     * called by the cell, when tab is pressed while editing.
+     * @return: RenderedCell when navigation successful, false if navigation should not be performed, otherwise null
+     */
+    private findNextCellToFocusOn;
+    private isCellEditable;
+    private lookupRowNodeForCell;
+    navigateToNextCell(event: KeyboardEvent | null, key: string, currentCell: CellPosition, allowUserOverride: boolean): void;
+    private getNormalisedPosition;
+    tryToFocusFullWidthRow(position: CellPosition | RowPosition, backwards?: boolean): boolean;
+    private focusPosition;
+    private isValidNavigateCell;
+    private getLastCellOfColSpan;
+    ensureCellVisible(gridCell: CellPosition): void;
+}

package/dist/types/src/pagination/pageBoundsListener.d.ts

@@ -0,0 +1,8 @@
+import type { NamedBean } from '../context/bean';
+import { BeanStub } from '../context/beanStub';
+export declare class PageBoundsListener extends BeanStub implements NamedBean {
+    beanName: "pageBoundsListener";
+    postConstruct(): void;
+    private onModelUpdated;
+    private calculatePages;
+}

package/dist/types/src/pagination/pageBoundsService.d.ts

@@ -0,0 +1,18 @@
+import type { NamedBean } from '../context/bean';
+import { BeanStub } from '../context/beanStub';
+export declare class PageBoundsService extends BeanStub implements NamedBean {
+    beanName: "pageBounds";
+    private topRowBounds?;
+    private bottomRowBounds?;
+    private pixelOffset;
+    getFirstRow(): number;
+    getLastRow(): number;
+    getCurrentPageHeight(): number;
+    getCurrentPagePixelRange(): {
+        pageFirstPixel: number;
+        pageLastPixel: number;
+    };
+    calculateBounds(topDisplayedRowIndex: number, bottomDisplayedRowIndex: number): void;
+    getPixelOffset(): number;
+    private calculatePixelOffset;
+}

package/dist/types/src/pagination/pageSizeSelector/pageSizeSelectorComp.d.ts

@@ -0,0 +1,24 @@
+import type { BeanCollection } from '../../context/context';
+import type { ComponentSelector } from '../../widgets/component';
+import { Component } from '../../widgets/component';
+export declare class PageSizeSelectorComp extends Component {
+    private pagination;
+    wireBeans(beans: BeanCollection): void;
+    private selectPageSizeComp;
+    private hasEmptyOption;
+    private pageSizeOptions?;
+    constructor();
+    postConstruct(): void;
+    private handlePageSizeItemSelected;
+    private handlePaginationChanged;
+    toggleSelectDisplay(show: boolean): void;
+    private reset;
+    private onPageSizeSelectorValuesChange;
+    shouldShowPageSizeSelector(): boolean;
+    private reloadPageSizesSelector;
+    private createPageSizeSelectOptions;
+    private createPageSizeSelectorComp;
+    private getPageSizeSelectorValues;
+    destroy(): void;
+}
+export declare const PageSizeSelectorSelector: ComponentSelector;

package/dist/types/src/pagination/paginationAutoPageSizeService.d.ts

@@ -0,0 +1,11 @@
+import type { NamedBean } from '../context/bean';
+import { BeanStub } from '../context/beanStub';
+export declare class PaginationAutoPageSizeService extends BeanStub implements NamedBean {
+    beanName: "paginationAutoPageSizeSvc";
+    private centerRowsCtrl;
+    private isBodyRendered;
+    postConstruct(): void;
+    private notActive;
+    private onPaginationAutoSizeChanged;
+    private checkPageSize;
+}

package/dist/types/src/pagination/paginationComp.css-GENERATED.d.ts

@@ -0,0 +1 @@
+export declare const paginationCompCSS = ".ag-paging-panel{align-items:center;border-top:var(--ag-footer-row-border);display:flex;gap:calc(var(--ag-spacing)*4);height:max(var(--ag-row-height),22px);justify-content:flex-end;padding:0 var(--ag-cell-horizontal-padding)}:where(.ag-paging-page-size) .ag-wrapper{min-width:50px}.ag-paging-page-summary-panel{align-items:center;display:flex;gap:var(--ag-cell-widget-spacing);.ag-disabled &{pointer-events:none}}.ag-paging-button{cursor:pointer;position:relative;&.ag-disabled{cursor:default;opacity:.5}}.ag-paging-number,.ag-paging-row-summary-panel-number{font-weight:500}";

package/dist/types/src/pagination/paginationComp.d.ts

@@ -0,0 +1,46 @@
+import type { BeanCollection } from '../context/context';
+import type { FocusableContainer } from '../interfaces/iFocusableContainer';
+import type { ComponentSelector } from '../widgets/component';
+import { TabGuardComp } from '../widgets/tabGuardComp';
+export declare class PaginationComp extends TabGuardComp implements FocusableContainer {
+    private rowModel;
+    private pagination;
+    private ariaAnnounce?;
+    wireBeans(beans: BeanCollection): void;
+    private readonly btFirst;
+    private readonly btPrevious;
+    private readonly btNext;
+    private readonly btLast;
+    private readonly lbRecordCount;
+    private readonly lbFirstRowOnPage;
+    private readonly lbLastRowOnPage;
+    private readonly lbCurrent;
+    private readonly lbTotal;
+    private readonly pageSizeComp;
+    private previousAndFirstButtonsDisabled;
+    private nextButtonDisabled;
+    private lastButtonDisabled;
+    private areListenersSetup;
+    private allowFocusInnerElement;
+    private ariaRowStatus;
+    private ariaPageStatus;
+    constructor();
+    postConstruct(): void;
+    setAllowFocus(allowFocus: boolean): void;
+    private onPaginationChanged;
+    private onPageSizeRelatedOptionsChange;
+    private setupListeners;
+    private onBtFirst;
+    private formatNumber;
+    private getTemplate;
+    private onBtNext;
+    private onBtPrevious;
+    private onBtLast;
+    private enableOrDisableButtons;
+    private toggleButtonDisabled;
+    private isZeroPagesToDisplay;
+    private updateLabels;
+    private announceAriaStatus;
+    private setTotalLabelsToZero;
+}
+export declare const PaginationSelector: ComponentSelector;

package/dist/types/src/pagination/paginationModule.d.ts

@@ -0,0 +1,7 @@
+import type { _PaginationGridApi } from '../api/gridApi';
+import type { _ModuleWithApi } from '../interfaces/iModule';
+/**
+ * @feature Rows -> Row Pagination
+ * @gridOption pagination
+ */
+export declare const PaginationModule: _ModuleWithApi<_PaginationGridApi>;

package/dist/types/src/pagination/paginationService.d.ts

@@ -0,0 +1,50 @@
+import type { NamedBean } from '../context/bean';
+import { BeanStub } from '../context/beanStub';
+import type { RowNode } from '../entities/rowNode';
+import type { RowPosition } from '../interfaces/iRowPosition';
+import type { ComponentSelector } from '../widgets/component';
+export declare class PaginationService extends BeanStub implements NamedBean {
+    beanName: "pagination";
+    private active;
+    private paginateChildRows;
+    private pageSizeAutoCalculated?;
+    private pageSizeFromPageSizeSelector?;
+    private pageSizeFromInitialState?;
+    private pageSizeFromGridOptions?;
+    private defaultPageSize;
+    private totalPages;
+    private currentPage;
+    private topDisplayedRowIndex;
+    private bottomDisplayedRowIndex;
+    private masterRowCount;
+    postConstruct(): void;
+    getPaginationSelector(): ComponentSelector;
+    private isPaginateChildRows;
+    private onPaginationGridOptionChanged;
+    private onPageSizeGridOptionChanged;
+    goToPage(page: number): void;
+    isRowPresent(rowNode: RowNode): boolean;
+    private getPageForIndex;
+    goToPageWithIndex(index: any): void;
+    isRowInPage(row: RowPosition): boolean;
+    getCurrentPage(): number;
+    goToNextPage(): void;
+    goToPreviousPage(): void;
+    goToFirstPage(): void;
+    goToLastPage(): void;
+    getPageSize(): number;
+    getTotalPages(): number;
+    /** This is only for state setting before data has been loaded */
+    setPage(page: number): void;
+    private get pageSize();
+    calculatePages(): void;
+    unsetAutoCalculatedPageSize(): void;
+    setPageSize(size: number | undefined, source: 'autoCalculated' | 'pageSizeSelector' | 'initialState' | 'gridOptions'): void;
+    private setZeroRows;
+    private adjustCurrentPageIfInvalid;
+    private calculatePagesMasterRowsOnly;
+    getMasterRowCount(): number;
+    private calculatePagesAllRows;
+    private calculatedPagesNotActive;
+    private dispatchPaginationChangedEvent;
+}

package/dist/types/src/pinnedColumns/pinnedColumnModule.css-GENERATED.d.ts

@@ -0,0 +1 @@
+export declare const pinnedColumnModuleCSS = ".ag-pinned-left-floating-bottom,.ag-pinned-left-floating-top,.ag-pinned-right-floating-bottom,.ag-pinned-right-floating-top{display:inline-block;min-width:0;overflow:hidden;position:relative}.ag-pinned-left-sticky-top,.ag-pinned-right-sticky-top{height:100%;overflow:hidden;position:relative}.ag-sticky-bottom-full-width-container,.ag-sticky-top-full-width-container{height:100%;overflow:hidden;width:100%}.ag-pinned-left-header,.ag-pinned-right-header{display:inline-block;height:100%;overflow:hidden;position:relative}.ag-body-horizontal-scroll:not(.ag-scrollbar-invisible){.ag-horizontal-left-spacer:not(.ag-scroller-corner){border-right:var(--ag-pinned-column-border)}.ag-horizontal-right-spacer:not(.ag-scroller-corner){border-left:var(--ag-pinned-column-border)}}.ag-pinned-right-header{border-left:var(--ag-pinned-column-border)}.ag-pinned-left-header{border-right:var(--ag-pinned-column-border)}.ag-cell.ag-cell-first-right-pinned:not(.ag-cell-range-left,.ag-cell-range-single-cell,.ag-cell-focus:not(.ag-cell-range-selected):focus-within){border-left:var(--ag-pinned-column-border)}.ag-cell.ag-cell-last-left-pinned:not(.ag-cell-range-right,.ag-cell-range-single-cell,.ag-cell-focus:not(.ag-cell-range-selected):focus-within){border-right:var(--ag-pinned-column-border)}.ag-pinned-left-header .ag-header-cell-resize:after{left:calc(50% - var(--ag-header-column-resize-handle-width))}.ag-pinned-right-header .ag-header-cell-resize:after{left:50%}.ag-pinned-left-header .ag-header-cell-resize{right:-3px}.ag-pinned-right-header .ag-header-cell-resize{left:-3px}";

package/dist/types/src/pinnedColumns/pinnedColumnModule.d.ts

@@ -0,0 +1,6 @@
+import type { _ModuleWithoutApi } from '../interfaces/iModule';
+/**
+ * @feature Columns -> Column Pinning
+ * @colDef pinned
+ */
+export declare const PinnedColumnModule: _ModuleWithoutApi;

package/dist/types/src/pinnedColumns/pinnedColumnService.d.ts

@@ -0,0 +1,25 @@
+import type { ColKey } from '../columns/columnModel';
+import type { NamedBean } from '../context/bean';
+import { BeanStub } from '../context/beanStub';
+import type { AgColumn } from '../entities/agColumn';
+import type { AgColumnGroup } from '../entities/agColumnGroup';
+import type { ColumnEventType } from '../events';
+import { SetPinnedWidthFeature } from '../gridBodyComp/rowContainer/setPinnedWidthFeature';
+import type { HeaderRowContainerCtrl } from '../headerRendering/rowContainer/headerRowContainerCtrl';
+import type { ColumnPinnedType } from '../interfaces/iColumn';
+export declare class PinnedColumnService extends BeanStub implements NamedBean {
+    beanName: "pinnedCols";
+    private gridBodyCtrl;
+    leftWidth: number;
+    rightWidth: number;
+    postConstruct(): void;
+    private checkContainerWidths;
+    keepPinnedColumnsNarrowerThanViewport(): void;
+    createPinnedWidthFeature(element: HTMLElement, isLeft: boolean): SetPinnedWidthFeature;
+    setColsPinned(keys: ColKey[], pinned: ColumnPinnedType, source: ColumnEventType): void;
+    initCol(column: AgColumn): void;
+    setColPinned(column: AgColumn, pinned: ColumnPinnedType): void;
+    setupHeaderPinnedWidth(ctrl: HeaderRowContainerCtrl): void;
+    getHeaderResizeDiff(diff: number, column: AgColumn | AgColumnGroup): number;
+    private getPinnedColumnsOverflowingViewport;
+}

package/dist/types/src/pinnedRowModel/pinnedRowModel.d.ts

@@ -0,0 +1,32 @@
+import type { NamedBean } from '../context/bean';
+import { BeanStub } from '../context/beanStub';
+import { RowNode } from '../entities/rowNode';
+import type { RowPinnedType } from '../interfaces/iRowNode';
+export declare class PinnedRowModel extends BeanStub implements NamedBean {
+    beanName: "pinnedRowModel";
+    private nextId;
+    private pinnedTopRows;
+    private pinnedBottomRows;
+    postConstruct(): void;
+    isEmpty(floating: RowPinnedType): boolean;
+    isRowsToRender(floating: RowPinnedType): boolean;
+    private onGridStylesChanges;
+    ensureRowHeightsValid(): boolean;
+    private setPinnedRowData;
+    /**
+     * Updates existing RowNode instances and creates new ones if necessary
+     *
+     * Setting data as `undefined` will clear row nodes
+     */
+    private updateNodesFromRowData;
+    private setRowTopAndRowIndex;
+    getPinnedTopTotalHeight(): number;
+    getPinnedBottomTotalHeight(): number;
+    getPinnedTopRowCount(): number;
+    getPinnedBottomRowCount(): number;
+    getPinnedTopRow(index: number): RowNode | undefined;
+    getPinnedBottomRow(index: number): RowNode | undefined;
+    getPinnedRowById(id: string, floating: NonNullable<RowPinnedType>): RowNode | undefined;
+    forEachPinnedRow(floating: NonNullable<RowPinnedType>, callback: (node: RowNode, index: number) => void): void;
+    private getCache;
+}

package/dist/types/src/pinnedRowModel/pinnedRowModule.d.ts

@@ -0,0 +1,7 @@
+import type { _PinnedRowGridApi } from '../api/gridApi';
+import type { _ModuleWithApi } from '../interfaces/iModule';
+/**
+ * @feature Rows -> Row Pinning
+ * @gridOption pinnedTopRowData, pinnedBottomRowData
+ */
+export declare const PinnedRowModule: _ModuleWithApi<_PinnedRowGridApi>;

package/dist/types/src/propertyKeys.d.ts

@@ -0,0 +1,33 @@
+import type { GridOptions } from './entities/gridOptions';
+import type { AgGridCommon } from './interfaces/iCommon';
+type GridOptionKey = keyof GridOptions;
+type GetKeys<T, U> = {
+    [K in keyof T]: U extends T[K] ? K : T[K] extends U | null | undefined ? K : never;
+}[keyof T];
+/**
+ *  Get the GridProperties that are of type `any`.
+ *  Works by finding the properties that can extend a non existing string.
+ *  This will only be the properties of type `any`.
+ */
+export type AnyGridOptions = {
+    [K in keyof GridOptions]: GridOptions[K] extends 'NO_MATCH' ? K : never;
+}[keyof GridOptions];
+/**
+ * Get all the GridOptions properties of the provided type.
+ * Will also include `any` properties.
+ */
+type KeysLike<U> = Exclude<GetKeys<GridOptions, U>, undefined>;
+/**
+ * Get all the GridOption properties that strictly contain the provided type.
+ * Does not include `any` properties.
+ */
+type KeysOfType<U> = Exclude<GetKeys<GridOptions, U>, AnyGridOptions>;
+type CallbackKeys = KeysOfType<(any: AgGridCommon<any, any>) => any>;
+/** All function properties excluding those explicity match the common callback interface. */
+type FunctionKeys = Exclude<KeysLike<Function>, CallbackKeys>;
+export declare const _NUMBER_GRID_OPTIONS: KeysOfType<number>[];
+export declare const _BOOLEAN_MIXED_GRID_OPTIONS: KeysOfType<boolean>[];
+export declare const _BOOLEAN_GRID_OPTIONS: KeysOfType<boolean>[];
+export declare const _FUNCTION_GRID_OPTIONS: (CallbackKeys | FunctionKeys)[];
+export declare const _ALL_GRID_OPTIONS: GridOptionKey[];
+export {};

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

@@ -0,0 +1,16 @@
+import type { NamedBean } from '../context/bean';
+import { BeanStub } from '../context/beanStub';
+export declare class AriaAnnouncementService extends BeanStub implements NamedBean {
+    beanName: "ariaAnnounce";
+    private descriptionContainer;
+    private pendingAnnouncements;
+    private lastAnnouncement;
+    constructor();
+    postConstruct(): void;
+    /**
+     * @param key used for debouncing calls
+     */
+    announceValue(value: string, key: string): void;
+    private updateAnnouncement;
+    destroy(): void;
+}

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

@@ -0,0 +1,5 @@
+import type { _ModuleWithoutApi } from '../interfaces/iModule';
+/**
+ * @feature Interactivity -> Accessibility (ARIA)
+ */
+export declare const AriaModule: _ModuleWithoutApi;

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

@@ -0,0 +1,14 @@
+import type { NamedBean } from '../context/bean';
+import { BeanStub } from '../context/beanStub';
+import type { AgColumn } from '../entities/agColumn';
+import type { AgColumnGroup } from '../entities/agColumnGroup';
+export declare class AutoWidthCalculator extends BeanStub implements NamedBean {
+    beanName: "autoWidthCalc";
+    private centerRowContainerCtrl;
+    postConstruct(): void;
+    getPreferredWidthForColumn(column: AgColumn, skipHeader?: boolean): number;
+    getPreferredWidthForColumnGroup(columnGroup: AgColumnGroup): number;
+    private addElementsToContainerAndGetWidth;
+    private getHeaderCellForColumn;
+    private cloneItemIntoDummy;
+}

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

@@ -0,0 +1,5 @@
+import type { _ModuleWithoutApi } from '../interfaces/iModule';
+/**
+ * @internal
+ */
+export declare const AutoWidthModule: _ModuleWithoutApi;

package/dist/types/src/rendering/cell/cellComp.d.ts

@@ -0,0 +1,50 @@
+import type { BeanCollection } from '../../context/context';
+import { Component } from '../../widgets/component';
+import type { CellCtrl } from './cellCtrl';
+export declare class CellComp extends Component {
+    readonly cellCtrl: CellCtrl;
+    private eCellWrapper;
+    private eCellValue;
+    private readonly column;
+    private readonly rowNode;
+    private eRow;
+    private includeSelection;
+    private includeRowDrag;
+    private includeDndSource;
+    private forceWrapper;
+    private checkboxSelectionComp;
+    private dndSourceComp;
+    private rowDraggingComp;
+    private hideEditorPopup;
+    private cellEditorPopupWrapper;
+    private cellEditor;
+    private cellEditorGui;
+    private cellRenderer;
+    private cellRendererGui;
+    private cellRendererClass;
+    private firstRender;
+    private rendererVersion;
+    private editorVersion;
+    constructor(beans: BeanCollection, cellCtrl: CellCtrl, printLayout: boolean, eRow: HTMLElement, editingRow: boolean);
+    private getParentOfValue;
+    private setRenderDetails;
+    private setEditDetails;
+    private removeControls;
+    private refreshWrapper;
+    private addControls;
+    private createCellEditorInstance;
+    private insertValueWithoutCellRenderer;
+    private destroyEditorAndRenderer;
+    private destroyRenderer;
+    private destroyEditor;
+    private refreshCellRenderer;
+    private createCellRendererInstance;
+    private afterCellRendererCreated;
+    private afterCellEditorCreated;
+    private refreshEditStyles;
+    private addInCellEditor;
+    private addPopupCellEditor;
+    detach(): void;
+    destroy(): void;
+    private clearParentOfValue;
+}

package/dist/types/src/rendering/cell/cellCtrl.d.ts

@@ -0,0 +1,143 @@
+import { BeanStub } from '../../context/beanStub';
+import type { BeanCollection } from '../../context/context';
+import type { RowDragComp } from '../../dragAndDrop/rowDragComp';
+import type { AgColumn } from '../../entities/agColumn';
+import type { CellStyle } from '../../entities/colDef';
+import type { RowNode } from '../../entities/rowNode';
+import type { AgEventType } from '../../eventTypes';
+import type { CellEvent, CellFocusedEvent } from '../../events';
+import type { GridOptionsService } from '../../gridOptionsService';
+import type { BrandedType } from '../../interfaces/brandedType';
+import type { ICellEditor } from '../../interfaces/iCellEditor';
+import type { CellPosition } from '../../interfaces/iCellPosition';
+import type { CellChangedEvent } from '../../interfaces/iRowNode';
+import type { RowPosition } from '../../interfaces/iRowPosition';
+import type { UserCompDetails } from '../../interfaces/iUserCompDetails';
+import type { CheckboxSelectionComponent } from '../../selection/checkboxSelectionComponent';
+import type { ICellRenderer } from '../cellRenderers/iCellRenderer';
+import type { DndSourceComp } from '../dndSourceComp';
+import type { RowCtrl } from '../row/rowCtrl';
+export interface ICellComp {
+    addOrRemoveCssClass(cssClassName: string, on: boolean): void;
+    setUserStyles(styles: CellStyle): void;
+    getFocusableElement(): HTMLElement;
+    setIncludeSelection(include: boolean): void;
+    setIncludeRowDrag(include: boolean): void;
+    setIncludeDndSource(include: boolean): void;
+    getCellEditor(): ICellEditor | null;
+    getCellRenderer(): ICellRenderer | null;
+    getParentOfValue(): HTMLElement | null;
+    setRenderDetails(compDetails: UserCompDetails | undefined, valueToDisplay: any, forceNewCellRendererInstance: boolean): void;
+    setEditDetails(compDetails?: UserCompDetails, popup?: boolean, position?: 'over' | 'under', reactiveCustomComponents?: boolean): void;
+}
+export declare const DOM_DATA_KEY_CELL_CTRL = "cellCtrl";
+export declare function _getCellCtrlForEventTarget(gos: GridOptionsService, eventTarget: EventTarget | null): CellCtrl | null;
+export type CellCtrlInstanceId = BrandedType<string, 'CellCtrlInstanceId'>;
+export declare class CellCtrl extends BeanStub {
+    readonly column: AgColumn;
+    readonly rowNode: RowNode;
+    readonly rowCtrl: RowCtrl;
+    readonly instanceId: CellCtrlInstanceId;
+    readonly colIdSanitised: string;
+    eGui: HTMLElement;
+    comp: ICellComp;
+    editCompDetails?: UserCompDetails;
+    private focusEventToRestore;
+    printLayout: boolean;
+    value: any;
+    valueFormatted: any;
+    private rangeFeature;
+    private positionFeature;
+    private customStyleFeature;
+    private tooltipFeature;
+    private mouseListener;
+    private keyboardListener;
+    cellPosition: CellPosition;
+    editing: boolean;
+    private includeSelection;
+    private includeDndSource;
+    private includeRowDrag;
+    private isAutoHeight;
+    suppressRefreshCell: boolean;
+    private customRowDragComp;
+    onCompAttachedFuncs: (() => void)[];
+    onEditorAttachedFuncs: (() => void)[];
+    constructor(column: AgColumn, rowNode: RowNode, beans: BeanCollection, rowCtrl: RowCtrl);
+    shouldRestoreFocus(): boolean;
+    onFocusOut(): void;
+    private addFeatures;
+    private removeFeatures;
+    private enableTooltipFeature;
+    private disableTooltipFeature;
+    setComp(comp: ICellComp, eGui: HTMLElement, eCellWrapper: HTMLElement | undefined, printLayout: boolean, startEditing: boolean, compBean: BeanStub | undefined): void;
+    private setupAutoHeight;
+    getCellAriaRole(): string;
+    isCellRenderer(): boolean;
+    getValueToDisplay(): any;
+    private showValue;
+    private setupControlComps;
+    isForceWrapper(): boolean;
+    private isIncludeControl;
+    private isCheckboxSelection;
+    private refreshShouldDestroy;
+    onPopupEditorClosed(): void;
+    /**
+     * Ends the Cell Editing
+     * @param cancel `True` if the edit process is being canceled.
+     * @returns `True` if the value of the `GridCell` has been updated, otherwise `False`.
+     */
+    stopEditing(cancel?: boolean): boolean;
+    private createCellRendererParams;
+    onCellChanged(event: CellChangedEvent): void;
+    refreshOrDestroyCell(params?: {
+        suppressFlash?: boolean;
+        newData?: boolean;
+        forceRefresh?: boolean;
+    }): void;
+    refreshCell(params?: {
+        suppressFlash?: boolean;
+        newData?: boolean;
+        forceRefresh?: boolean;
+    }): void;
+    stopEditingAndFocus(suppressNavigateAfterEdit?: boolean, shiftKey?: boolean): void;
+    isCellEditable(): boolean;
+    formatValue(value: any): any;
+    private callValueFormatter;
+    updateAndFormatValue(compareValues: boolean): boolean;
+    private valuesAreEqual;
+    private addDomData;
+    createEvent<T extends AgEventType>(domEvent: Event | null, eventType: T): CellEvent<T>;
+    processCharacter(event: KeyboardEvent): void;
+    onKeyDown(event: KeyboardEvent): void;
+    onMouseEvent(eventName: string, mouseEvent: MouseEvent): void;
+    getColSpanningList(): AgColumn[];
+    onLeftChanged(): void;
+    onDisplayedColumnsChanged(): void;
+    private refreshFirstAndLastStyles;
+    private refreshAriaColIndex;
+    onWidthChanged(): void;
+    getRowPosition(): RowPosition;
+    updateRangeBordersIfRangeCount(): void;
+    onCellSelectionChanged(): void;
+    isRangeSelectionEnabled(): boolean;
+    focusCell(forceBrowserFocus?: boolean): void;
+    onRowIndexChanged(): void;
+    onSuppressCellFocusChanged(suppressCellFocus: boolean): void;
+    onFirstRightPinnedChanged(): void;
+    onLastLeftPinnedChanged(): void;
+    onCellFocused(event?: CellFocusedEvent): void;
+    private createCellPosition;
+    setInlineEditingCss(): void;
+    private applyStaticCssClasses;
+    onColumnHover(): void;
+    onColDefChanged(): void;
+    private setWrapText;
+    dispatchCellContextMenuEvent(event: Event | null): void;
+    getCellRenderer(): ICellRenderer | null;
+    destroy(): void;
+    createSelectionCheckbox(): CheckboxSelectionComponent | undefined;
+    createDndSource(): DndSourceComp | undefined;
+    registerRowDragger(customElement: HTMLElement, dragStartPixels?: number, suppressVisibilityChange?: boolean): void;
+    createRowDragComp(customElement?: HTMLElement, dragStartPixels?: number, suppressVisibilityChange?: boolean): RowDragComp | undefined;
+    cellEditorAttached(): void;
+}