ag-grid-community 32.3.2 → 33.0.0

package/dist/types/src/interfaces/iCellEditor.d.ts

@@ -0,0 +1,97 @@
+import type { ColDef } from '../entities/colDef';
+import type { Column } from '../interfaces/iColumn';
+import type { GetCellsParams } from './iCellsParams';
+import type { AgGridCommon } from './iCommon';
+import type { IPopupComponent } from './iPopupComponent';
+import type { IRowNode } from './iRowNode';
+export interface BaseCellEditor {
+    /** Optional: Gets called once after initialised. If you return true, the editor will not be
+     * used and the grid will continue editing. Use this to make a decision on editing
+     * inside the init() function, eg maybe you want to only start editing if the user
+     * hits a numeric key, but not a letter, if the editor is for numbers.
+     */
+    isCancelBeforeStart?(): boolean;
+    /** Optional: Gets called once after editing is complete. If your return true, then the new
+     * value will not be used. The editing will have no impact on the record. Use this
+     * if you do not want a new value from your gui, i.e. you want to cancel the editing.
+     */
+    isCancelAfterEnd?(): boolean;
+    /**
+     * Optional: If doing full line edit, then gets called when focus should be put into the editor
+     */
+    focusIn?(): void;
+    /**
+     * Optional: If doing full line edit, then gets called when focus is leaving the editor
+     */
+    focusOut?(): void;
+}
+export interface ICellEditor<TValue = any> extends BaseCellEditor {
+    /**
+     * Return the final value - called by the grid once after editing is complete
+     */
+    getValue(): TValue | null | undefined;
+    /**
+     * Optional: Gets called with the latest cell editor params every time they update
+     */
+    refresh?(params: ICellEditorParams<any, TValue>): void;
+    /**
+     * Optional: A hook to perform any necessary operation just after the GUI for this component has been rendered on the screen.
+     * This method is called each time the edit component is activated.
+     * This is useful for any logic that requires attachment before executing, such as putting focus on a particular DOM element.
+     */
+    afterGuiAttached?(): void;
+    /** Optional: Gets called once after initialised. If you return true, the editor will
+     * appear in a popup, so is not constrained to the boundaries of the cell.
+     * This is great if you want to, for example, provide you own custom dropdown list
+     * for selection. Default is false (ie if you don't provide the method).
+     */
+    isPopup?(): boolean;
+    /** Optional: Gets called once, only if isPopup() returns true. Return "over" if the popup
+     * should cover the cell, or "under" if it should be positioned below leaving the
+     * cell value visible. If this method is not present, the default is "over".
+     */
+    getPopupPosition?(): 'over' | 'under' | undefined;
+}
+export interface ICellEditorParams<TData = any, TValue = any, TContext = any> extends AgGridCommon<TData, TContext> {
+    /** Current value of the cell */
+    value: TValue | null | undefined;
+    /** Key value of key that started the edit, eg 'Enter' or 'F2' - non-printable
+     *  characters appear here */
+    eventKey: string | null;
+    /** Grid column */
+    column: Column<TValue>;
+    /** Column definition */
+    colDef: ColDef<TData, TValue>;
+    /** Row node for the cell */
+    node: IRowNode<TData>;
+    /** Row data */
+    data: TData;
+    /** Editing row index */
+    rowIndex: number;
+    /** If doing full row edit, this is true if the cell is the one that started the edit
+     *  (eg it is the cell the use double clicked on, or pressed a key on etc). */
+    cellStartedEdit: boolean;
+    /** callback to tell grid a key was pressed - useful to pass control key events (tab,
+     *  arrows etc) back to grid - however you do */
+    onKeyDown: (event: KeyboardEvent) => void;
+    /** Callback to tell grid to stop editing the current cell. Call with input parameter
+     * true to prevent focus from moving to the next cell after editing stops in case the
+     * grid property `enterNavigatesVerticallyAfterEdit=true` */
+    stopEditing: (suppressNavigateAfterEdit?: boolean) => void;
+    /** A reference to the DOM element representing the grid cell that your component
+     *  will live inside. Useful if you want to add event listeners or classes at this level.
+     *  This is the DOM element that gets browser focus when selecting cells. */
+    eGridCell: HTMLElement;
+    /** Utility function to parse a value using the column's `colDef.valueParser` */
+    parseValue: (value: string) => TValue | null | undefined;
+    /** Utility function to format a value using the column's `colDef.valueFormatter` */
+    formatValue: (value: TValue | null | undefined) => string;
+}
+export interface ICellEditorComp<TData = any, TValue = any, TContext = any> extends ICellEditor<TValue>, IPopupComponent<ICellEditorParams<TData, TValue, TContext>> {
+}
+/** This is only used internally within the grid */
+export interface DefaultProvidedCellEditorParams {
+    suppressPreventDefault?: boolean;
+}
+export interface GetCellEditorInstancesParams<TData = any> extends GetCellsParams<TData> {
+}

package/dist/types/src/interfaces/iCellPosition.d.ts

@@ -0,0 +1,6 @@
+import type { Column } from './iColumn';
+import type { RowPosition } from './iRowPosition';
+export interface CellPosition extends RowPosition {
+    /** The grid column */
+    column: Column;
+}

package/dist/types/src/interfaces/iCellRangeFeature.d.ts

@@ -0,0 +1,8 @@
+import type { ICellComp } from '../rendering/cell/cellCtrl';
+export interface ICellRangeFeature {
+    setComp(cellComp: ICellComp, eGui: HTMLElement): void;
+    refreshHandle(): void;
+    updateRangeBordersIfRangeCount(): void;
+    onCellSelectionChanged(): void;
+    destroy(): void;
+}

package/dist/types/src/interfaces/iCellsParams.d.ts

@@ -0,0 +1,20 @@
+import type { Column } from './iColumn';
+import type { IRowNode } from './iRowNode';
+export interface GetCellsParams<TData = any> {
+    /** Optional list of row nodes to restrict operation to */
+    rowNodes?: IRowNode<TData>[];
+    /** Optional list of columns to restrict operation to */
+    columns?: (string | Column)[];
+}
+export interface RefreshCellsParams<TData = any> extends GetCellsParams<TData> {
+    /** Skip change detection, refresh everything. */
+    force?: boolean;
+    /** Skip cell flashing, if cell flashing is enabled. */
+    suppressFlash?: boolean;
+}
+export interface FlashCellsParams<TData = any> extends GetCellsParams<TData> {
+    /** The duration in milliseconds of how long a cell should remain in its "flashed" state. */
+    flashDuration?: number;
+    /** The duration in milliseconds of how long the "flashed" state animation takes to fade away after the timer set by `flashDuration` has completed. */
+    fadeDuration?: number;
+}

package/dist/types/src/interfaces/iChartOptions.d.ts

@@ -0,0 +1,62 @@
+export interface ChartGroupsDef {
+    columnGroup?: ('column' | 'stackedColumn' | 'normalizedColumn')[];
+    barGroup?: ('bar' | 'stackedBar' | 'normalizedBar')[];
+    pieGroup?: ('pie' | 'donut' | 'doughnut')[];
+    lineGroup?: ('line' | 'stackedLine' | 'normalizedLine')[];
+    areaGroup?: ('area' | 'stackedArea' | 'normalizedArea')[];
+    scatterGroup?: ('scatter' | 'bubble')[];
+    combinationGroup?: ('columnLineCombo' | 'areaColumnCombo' | 'customCombo')[];
+    polarGroup?: ('radarLine' | 'radarArea' | 'nightingale' | 'radialColumn' | 'radialBar')[];
+    statisticalGroup?: ('boxPlot' | 'histogram' | 'rangeBar' | 'rangeArea')[];
+    hierarchicalGroup?: ('treemap' | 'sunburst')[];
+    specializedGroup?: ('heatmap' | 'waterfall')[];
+}
+export type ChartToolPanelName = 'settings' | 'data' | 'format';
+/** Configuration for the `Chart` panel */
+export interface ChartSettingsPanel {
+    /** Chart groups customisations for which charts are displayed in the chart panel */
+    chartGroupsDef?: ChartGroupsDef;
+}
+export type ChartFormatPanelGroup = 'chart' | 'titles' | 'legend' | 'axis' | 'horizontalAxis' | 'verticalAxis' | 'series';
+export type ChartDataPanelGroup = 'categories' | 'series' | 'seriesChartType' | 'chartSpecific';
+export interface ChartPanelGroupDef<GroupType> {
+    /** The panel group type */
+    type: GroupType;
+    /** Whether the panel group is open by default. If not specified, it is closed */
+    isOpen?: boolean;
+}
+/** Configuration for the `Customize` panel */
+export interface ChartFormatPanel {
+    /** The customize panel group configurations, their order and whether they are shown. If not specified shows all groups */
+    groups?: ChartPanelGroupDef<ChartFormatPanelGroup>[];
+}
+/** Configuration for the `Set Up` panel */
+export interface ChartDataPanel {
+    /** The set up panel group configurations, their order and whether they are shown. If not specified shows all groups */
+    groups?: ChartPanelGroupDef<ChartDataPanelGroup>[];
+}
+export interface ChartToolPanelsDef {
+    /** Customisations for the chart panel and chart menu items in the Context Menu. */
+    settingsPanel?: ChartSettingsPanel;
+    /** Customisations for the customize panel */
+    formatPanel?: ChartFormatPanel;
+    /** Customisations for the set up panel */
+    dataPanel?: ChartDataPanel;
+    /** The ordered list of panels to show in the chart tool panels. If none specified, all panels are shown */
+    panels?: ChartToolPanelName[];
+    /** The panel to open by default when the chart loads. If none specified, the tool panel is hidden by default and the first panel is open when triggered. */
+    defaultToolPanel?: ChartToolPanelName;
+}
+export type CrossFilterChartType = 'column' | 'bar' | 'line' | 'scatter' | 'bubble' | 'pie' | 'donut' | 'doughnut' | 'area';
+export type ChartToolPanelMenuOptions = 'chartSettings' | 'chartData' | 'chartFormat';
+export type ChartToolbarMenuItemOptions = 'chartLink' | 'chartUnlink' | 'chartDownload' | 'chartMenu';
+export interface SeriesChartType {
+    colId: string;
+    chartType: ChartType;
+    secondaryAxis?: boolean;
+}
+export type ChartType = 'column' | 'groupedColumn' | 'stackedColumn' | 'normalizedColumn' | 'bar' | 'groupedBar' | 'stackedBar' | 'normalizedBar' | 'line' | 'stackedLine' | 'normalizedLine' | 'scatter' | 'bubble' | 'pie' | 'donut' | 'doughnut' | 'area' | 'stackedArea' | 'normalizedArea' | 'histogram' | 'radarLine' | 'radarArea' | 'nightingale' | 'radialColumn' | 'radialBar' | 'sunburst' | 'rangeBar' | 'rangeArea' | 'boxPlot' | 'treemap' | 'sunburst' | 'heatmap' | 'waterfall' | 'columnLineCombo' | 'areaColumnCombo' | 'customCombo';
+export type ComboChartType = 'columnLineCombo' | 'areaColumnCombo' | 'customCombo';
+export type ChartTypeExCombo = Exclude<ChartType, ComboChartType>;
+export type SeriesGroupType = 'grouped' | 'stacked' | 'normalized';
+export type DefaultChartMenuItem = 'chartEdit' | 'chartAdvancedSettings' | 'chartUnlink' | 'chartLink' | 'chartDownload';

package/dist/types/src/interfaces/iClientSideNodeManager.d.ts

@@ -0,0 +1,24 @@
+import type { RowNode } from '../entities/rowNode';
+import type { IChangedRowNodes, RefreshModelParams } from './iClientSideRowModel';
+import type { RowDataTransaction } from './rowDataTransaction';
+import type { RowNodeTransaction } from './rowNodeTransaction';
+export type RowDataChildrenGetter<TData = any> = (data: TData | null | undefined) => TData[] | null | undefined;
+/** Result of IClientSideNodeManager.updateRowData method */
+export interface ClientSideNodeManagerUpdateRowDataResult<TData = any> {
+    changedRowNodes: IChangedRowNodes<TData>;
+    /** The RowNodeTransaction containing all the removals, updates and additions */
+    rowNodeTransaction: RowNodeTransaction<TData>;
+    /** True if at least one row was inserted (and not just appended) */
+    rowsInserted: boolean;
+}
+export interface IClientSideNodeManager<TData = any> {
+    readonly treeData: boolean;
+    activate(rootNode: RowNode<TData> | null): void;
+    deactivate(): void;
+    getRowNode(id: string): RowNode<TData> | undefined;
+    extractRowData(): (TData | undefined)[] | null | undefined;
+    setNewRowData(rowData: TData[]): void;
+    setImmutableRowData(params: RefreshModelParams<TData>, rowData: TData[]): void;
+    updateRowData(rowDataTran: RowDataTransaction<TData>, changedRowNodes: IChangedRowNodes<TData>): ClientSideNodeManagerUpdateRowDataResult<TData>;
+    refreshModel?(params: RefreshModelParams<TData>): void;
+}

package/dist/types/src/interfaces/iClientSideRowModel.d.ts

@@ -0,0 +1,94 @@
+import type { GridOptions } from '../entities/gridOptions';
+import type { RowHighlightPosition, RowNode } from '../entities/rowNode';
+import type { ChangedPath } from '../utils/changedPath';
+import type { IRowModel } from './iRowModel';
+import type { IRowNode } from './iRowNode';
+import type { RowDataTransaction } from './rowDataTransaction';
+import type { RowNodeTransaction } from './rowNodeTransaction';
+export type ClientSideRowModelStep = 'everything' | 'group' | 'filter' | 'sort' | 'map' | 'aggregate' | 'filter_aggregates' | 'pivot' | 'nothing';
+export type ClientSideRowModelStage = 'group' | 'filter' | 'sort' | 'map' | 'aggregate' | 'filter_aggregates' | 'pivot' | 'nothing';
+export interface IClientSideRowModel<TData = any> extends IRowModel {
+    /** The root row containing all the rows */
+    readonly rootNode: RowNode | null;
+    onRowGroupOpened(): void;
+    updateRowData(rowDataTran: RowDataTransaction<TData>): RowNodeTransaction<TData> | null;
+    refreshModel(params: RefreshModelParams): void;
+    forEachLeafNode(callback: (node: RowNode, index: number) => void): void;
+    forEachNodeAfterFilter(callback: (node: RowNode, index: number) => void, includeFooterNodes?: boolean): void;
+    forEachNodeAfterFilterAndSort(callback: (node: RowNode, index: number) => void, includeFooterNodes?: boolean): void;
+    forEachPivotNode(callback: (node: RowNode, index: number) => void, includeFooterNodes?: boolean): void;
+    resetRowHeights(): void;
+    onRowHeightChanged(): void;
+    onRowHeightChangedDebounced(): void;
+    batchUpdateRowData(rowDataTransaction: RowDataTransaction<TData>, callback?: (res: RowNodeTransaction<TData>) => void): void;
+    flushAsyncTransactions(): void;
+    doAggregate(changedPath?: ChangedPath): void;
+    getTopLevelNodes(): RowNode[] | null;
+    ensureRowsAtPixel(rowNode: RowNode[], pixel: number, increment: number): boolean;
+    highlightRowAtPixel(rowNode: RowNode | null, pixel?: number): void;
+    getHighlightPosition(pixel: number, rowNode?: RowNode): RowHighlightPosition;
+    getLastHighlightedRowNode(): RowNode | null;
+    isRowDataLoaded(): boolean;
+}
+export interface IChangedRowNodes<TData = any> {
+    /**
+     * The set of removed nodes.
+     * Mutually exclusive, if a node is here, it cannot be in the updates map.
+     */
+    readonly removals: ReadonlySet<RowNode<TData>>;
+    /**
+     * Map of row nodes that have been updated.
+     * The value is true if the row node is a new node. is false if it was just updated.
+     */
+    readonly updates: ReadonlyMap<RowNode<TData>, boolean>;
+    /** Marks a row as removed. Order of operations is: remove, update, add */
+    remove(node: IRowNode<TData>): void;
+    /** Marks a row as updated. Order of operations is: remove, update, add */
+    update(node: IRowNode<TData>): void;
+    /** Marks a row as added. Order of operation is: remove, update, add */
+    add(node: IRowNode<TData>): void;
+}
+export interface RefreshModelParams<TData = any> {
+    /** how much of the pipeline to execute */
+    step: ClientSideRowModelStage;
+    /** The set of changed grid options, if any */
+    changedProps?: Set<keyof GridOptions<TData>>;
+    /**
+     * true if the row data changed, due to a setRowData, immutable row data or a transaction, or an update of the row data.
+     */
+    rowDataUpdated?: boolean;
+    /**
+     * Indicates a completely new rowData array is loaded.
+     * Is true if user called setRowData() (or a new page in pagination). the grid scrolls back to the top when this is true.
+     */
+    newData?: boolean;
+    /**
+     * true if the order of root.allLeafChildren has changed.
+     * This can happen if order of root.allLeafChildren is updated or rows are inserted (and not just appended at the end)
+     */
+    rowNodesOrderChanged?: boolean;
+    /**
+     * A data structure that holds the affected row nodes, if this was an update and not a full reload.
+     */
+    changedRowNodes?: IChangedRowNodes<TData>;
+    /** The changedPath, if any */
+    changedPath?: ChangedPath;
+    /**
+     * List of transactions being executed for a delta update.
+     * To see the affected nodes for a delta update, use `changedRowNodes` instead.
+     */
+    rowNodeTransactions?: RowNodeTransaction<TData>[];
+    /**
+     * if NOT new data, then this flag tells grid to check if rows already
+     * exist for the nodes (matching by node id) and reuses the row if it does.
+     */
+    keepRenderedRows?: boolean;
+    /**
+     * if true, rows that are kept are animated to the new position
+     */
+    animate?: boolean;
+    /** true if this update is due to columns changing, ie no rows were changed */
+    afterColumnsChanged?: boolean;
+    /** true if all we did is changed row height, data still the same, no need to clear the undo/redo stacks */
+    keepUndoRedoStack?: boolean;
+}

package/dist/types/src/interfaces/iColsService.d.ts

@@ -0,0 +1,49 @@
+import type { ColumnChangedEventType } from '../columns/columnApi';
+import type { ColKey, Maybe } from '../columns/columnModel';
+import type { ColumnState, ColumnStateParams } from '../columns/columnStateUtils';
+import type { AgColumn } from '../entities/agColumn';
+import type { ColDef, IAggFunc } from '../entities/colDef';
+import type { ColumnEventType } from '../events';
+type ColumnProcessorKeys = 'add' | 'remove' | 'set';
+export type ColumnProcessor = (column: AgColumn, added: boolean, source: ColumnEventType) => void;
+export type ColumnProcessors = Record<ColumnProcessorKeys, ColumnProcessor>;
+export type ColumnOrdering = {
+    enableProp: 'rowGroup' | 'pivot';
+    initialEnableProp: 'initialRowGroup' | 'initialPivot';
+    indexProp: 'rowGroupIndex' | 'pivotIndex';
+    initialIndexProp: 'initialRowGroupIndex' | 'initialPivotIndex';
+};
+export type ColumnExtractors = {
+    setFlagFunc: (col: AgColumn, flag: boolean, source: ColumnEventType) => void;
+    getIndexFunc: (colDef: ColDef) => number | null | undefined;
+    getInitialIndexFunc: (colDef: ColDef) => number | null | undefined;
+    getValueFunc: (colDef: ColDef) => boolean | null | undefined;
+    getInitialValueFunc: (colDef: ColDef) => boolean | undefined;
+};
+export interface IColsService {
+    columns: AgColumn[];
+    eventName: ColumnChangedEventType;
+    columnProcessors?: ColumnProcessors;
+    columnOrdering?: ColumnOrdering;
+    columnExtractors?: ColumnExtractors;
+    setColumns(colKeys: ColKey[] | undefined, source: ColumnEventType): void;
+    addColumns(keys: Maybe<ColKey>[] | undefined, source: ColumnEventType): void;
+    removeColumns(keys: Maybe<ColKey>[] | undefined, source: ColumnEventType): void;
+    extractCols(source: ColumnEventType, oldProvidedCols: AgColumn[] | undefined): void;
+    syncColumnWithState(column: AgColumn, source: ColumnEventType, getValue: <U extends keyof ColumnStateParams, S extends keyof ColumnStateParams>(key1: U, key2?: S) => {
+        value1: ColumnStateParams[U] | undefined;
+        value2: ColumnStateParams[S] | undefined;
+    }, rowIndex?: {
+        [key: string]: number;
+    } | null): void;
+    sortColumns(compareFn?: (a: AgColumn, b: AgColumn) => number): void;
+    restoreColumnOrder(columnStateAccumulator: {
+        [colId: string]: ColumnState;
+    }, incomingColumnState: {
+        [colId: string]: ColumnState;
+    }): {
+        [colId: string]: ColumnState;
+    };
+    setColumnAggFunc?(key: ColKey | undefined, aggFunc: string | IAggFunc | null | undefined, source: ColumnEventType): void;
+}
+export {};

package/dist/types/src/interfaces/iColumn.d.ts

@@ -0,0 +1,242 @@
+import type { AgProvidedColumnGroupEvent } from '../entities/agProvidedColumnGroup';
+import type { AbstractColDef, ColDef, ColGroupDef, IAggFunc, SortDirection } from '../entities/colDef';
+import type { ColumnEvent } from '../events';
+import type { BrandedType } from '../interfaces/brandedType';
+import type { IEventEmitter } from './iEventEmitter';
+import type { IRowNode } from './iRowNode';
+export type HeaderColumnId = BrandedType<string, 'HeaderColumnId'>;
+interface IHeaderColumn<TValue, TEventType extends string> extends IEventEmitter<TEventType> {
+    /**
+     * Returns the unique ID for the column.
+     *
+     */
+    getUniqueId(): HeaderColumnId;
+    /** Returns the current width of the column. If the column is resized, the actual width is the new size. */
+    getActualWidth(): number;
+    /** Returns the minWidth of the column or the default min width. */
+    getMinWidth(): number;
+    /** Returns the left position of the column. */
+    getLeft(): number | null;
+    /** Returns the underlying definition. */
+    getDefinition(): AbstractColDef<any, TValue> | null;
+    /** Returns whether this column should be shown when the group is open / closed or undefined if its always shown. */
+    getColumnGroupShow(): ColumnGroupShowType | undefined;
+    /** Returns the parent column group, if column grouping is active. */
+    getParent(): ColumnGroup | null;
+    /** Returns `true` if this group is resizable. */
+    isResizable(): boolean;
+    /** Returns `true` if this is an empty group. */
+    isEmptyGroup(): boolean;
+    /** Returns `true` while the column is being moved. */
+    isMoving(): boolean;
+    /** Returns the pinned state of the column. */
+    getPinned(): ColumnPinnedType;
+}
+interface IProvidedColumn {
+    /** Returns `true` if the column is visible. */
+    isVisible(): boolean;
+    /** @deprecated v32 Internal method no longer to be exposed on Column interface. */
+    getInstanceId(): ColumnInstanceId;
+    /** Returns whether this column should be shown when the group is open / closed or undefined if its always shown. */
+    getColumnGroupShow(): ColumnGroupShowType | undefined;
+    /**
+     * Returns the parent column group, if this column is part of a column group.
+     */
+    getOriginalParent(): ProvidedColumnGroup | null;
+    /** Returns the unique ID for the column. */
+    getId(): string;
+}
+export type ColumnPinnedType = 'left' | 'right' | boolean | null | undefined;
+export type ColumnEventName = 'movingChanged' | 'leftChanged' | 'widthChanged' | 'lastLeftPinnedChanged' | 'firstRightPinnedChanged' | 'visibleChanged' | 'filterChanged' | 'filterActiveChanged' | 'headerHighlightChanged' | 'sortChanged' | 'colDefChanged' | 'menuVisibleChanged' | 'columnRowGroupChanged' | 'columnPivotChanged' | 'columnValueChanged' | 'columnStateUpdated';
+export type ColumnInstanceId = BrandedType<number, 'ColumnInstanceId'>;
+export declare enum ColumnHighlightPosition {
+    Before = 0,
+    After = 1
+}
+export interface Column<TValue = any> extends IHeaderColumn<TValue, ColumnEventName>, IProvidedColumn, IEventEmitter<ColumnEventName> {
+    /**
+     * Returns the column definition provided by the application.
+     * This may not be correct, as items can be superseded by default column options.
+     * However it's useful for comparison, eg to know which application column definition matches that column.
+     */
+    getUserProvidedColDef(): ColDef<any, TValue> | null;
+    /** Returns `true` if this column group is being used to display a row group value. */
+    isRowGroupDisplayed(colId: string): boolean;
+    /** Returns `true` if column is a primary column, `false` if secondary. Secondary columns are used for pivoting. */
+    isPrimary(): boolean;
+    /** Returns `true` if column filtering is allowed. */
+    isFilterAllowed(): boolean;
+    /** @deprecated v32 Internal method no longer to be exposed on Column interface. */
+    isFieldContainsDots(): boolean;
+    /** Returns `true` if a tooltip is enabled for this column. */
+    isTooltipEnabled(): boolean;
+    /** @deprecated v32 Internal method no longer to be exposed on Column interface. */
+    isTooltipFieldContainsDots(): boolean;
+    /** Add an event listener to the column. */
+    addEventListener<T extends ColumnEventName>(eventType: T, userListener: (params: ColumnEvent<T>) => void): void;
+    /** Remove event listener from the column. */
+    removeEventListener<T extends ColumnEventName>(eventType: T, userListener: (params: ColumnEvent<T>) => void): void;
+    /** Returns `true` if navigation is suppressed for the given column and rowNode. */
+    isSuppressNavigable(rowNode: IRowNode): boolean;
+    /**
+     * Returns `true` if the cell for this column is editable for the given `rowNode`, otherwise `false`.
+     */
+    isCellEditable(rowNode: IRowNode): boolean;
+    /** Returns `true` if the fill handle is suppressed. */
+    isSuppressFillHandle(): boolean;
+    /** Returns `true` if the column has autoHeight enabled. */
+    isAutoHeight(): boolean;
+    /** Returns `true` if the column header has autoHeight enabled. */
+    isAutoHeaderHeight(): boolean;
+    /** Returns `true` if this column and row node can be dragged. */
+    isRowDrag(rowNode: IRowNode): boolean;
+    /** Returns `true` if this column and row node allows dragging for native drag and drop. */
+    isDndSource(rowNode: IRowNode): boolean;
+    /** Returns `true` if this column and row node has checkbox selection. */
+    isCellCheckboxSelection(rowNode: IRowNode): boolean;
+    /** Returns `true` if paste is suppress for this column and row node. */
+    isSuppressPaste(rowNode: IRowNode): boolean;
+    /** Returns `true` if a menu is visible for this column. */
+    isMenuVisible(): boolean;
+    /** If sorting is active, returns the sort direction e.g. `'asc'` or `'desc'`. */
+    getSort(): SortDirection | undefined;
+    /** Returns `true` if sorting is enabled for this column via the `sortable` property. */
+    isSortable(): boolean;
+    /** @deprecated v32 use col.getSort() === 'asc */
+    isSortAscending(): boolean;
+    /** @deprecated v32 use col.getSort() === 'desc */
+    isSortDescending(): boolean;
+    /** @deprecated v32 use col.getSort() === undefined */
+    isSortNone(): boolean;
+    /** @deprecated v32 use col.getSort() !== undefined */
+    isSorting(): boolean;
+    /** Returns the sort index for this column. */
+    getSortIndex(): number | null | undefined;
+    /** If aggregation is set for the column, returns the aggregation function. */
+    getAggFunc(): string | IAggFunc | null | undefined;
+    /** @deprecated v32 Use col.getLeft() + col.getActualWidth() instead. */
+    getRight(): number;
+    /** Returns `true` if filter is active on the column. */
+    isFilterActive(): boolean;
+    /** @deprecated v33 Use `api.isColumnHovered(column)` instead. */
+    isHovered(): boolean;
+    /** Returns `true` if this column is the first right pinned column. */
+    isFirstRightPinned(): boolean;
+    /** Returns `true` if this column is the last left pinned column. */
+    isLastLeftPinned(): boolean;
+    /** Returns `true` if this column is pinned either left of right. */
+    isPinned(): boolean;
+    /** Returns `true` if this column is pinned left. */
+    isPinnedLeft(): boolean;
+    /** Returns `true` if this column is pinned right. */
+    isPinnedRight(): boolean;
+    /** Returns `true` if this column spans the header height. */
+    isSpanHeaderHeight(): boolean;
+    /** Returns column group padding info. */
+    getColumnGroupPaddingInfo(): {
+        numberOfParents: number;
+        isSpanningTotal: boolean;
+    };
+    /** Returns the column definition for this column.
+     * The column definition will be the result of merging the application provided column definition with any provided defaults
+     * (e.g. `defaultColDef` grid option, or column types.
+     *
+     * Equivalent: `getDefinition` */
+    getColDef(): ColDef<any, TValue>;
+    /**
+     * Returns the unique ID for the column.
+     *
+     * Equivalent: `getId`, `getUniqueId` */
+    getColId(): string;
+    /** Returns the auto header height. */
+    getAutoHeaderHeight(): number | null;
+    /** Returns the column span for this column and row node. */
+    getColSpan(rowNode: IRowNode): number;
+    /** Returns the row span for this column and row node. */
+    getRowSpan(rowNode: IRowNode): number;
+    /** @deprecated v32 Internal method no longer to be exposed on Column interface. */
+    isGreaterThanMax(width: number): boolean;
+    /** Returns the max width for the column. */
+    getMaxWidth(): number;
+    /** Returns the `flex` value of the column or null if not set.  */
+    getFlex(): number | null;
+    /** Returns `true` if row group is currently active for this column. */
+    isRowGroupActive(): boolean;
+    /** Returns `true` if pivot is currently active for this column. */
+    isPivotActive(): boolean;
+    /** @deprecated v32 Internal method no longer to be exposed on Column interface. */
+    isAnyFunctionActive(): boolean;
+    /** @deprecated v32 Internal method no longer to be exposed on Column interface. */
+    isAnyFunctionAllowed(): boolean;
+    /** Returns `true` if value (aggregation) is currently active for this column. */
+    isValueActive(): boolean;
+    /** Returns `true` if pivoting is allowed for this column */
+    isAllowPivot(): boolean;
+    /** Returns `true` if this column can be used as a value column. */
+    isAllowValue(): boolean;
+    /** Returns `true` if this column can be used as a row group column. */
+    isAllowRowGroup(): boolean;
+    /** isColumn is always `true`. Used to distinguish between columns and column groups.  */
+    isColumn: true;
+}
+export type ColumnGroupShowType = 'open' | 'closed';
+export type AgColumnGroupEvent = 'leftChanged' | 'displayedChildrenChanged';
+export interface ColumnGroup<TValue = any> extends IHeaderColumn<TValue, AgColumnGroupEvent> {
+    /** Returns the group column id. */
+    getGroupId(): string;
+    /** @deprecated v32 Internal method no longer to be exposed on Column interface. */
+    getPartId(): number;
+    /** Returns `true` if this group is resizable. */
+    isResizable(): boolean;
+    /** Returns the displayed children of this group. */
+    getDisplayedChildren(): (Column | ColumnGroup)[] | null;
+    /** Returns the leaf columns of this group. */
+    getLeafColumns(): Column[];
+    /** Returns the displayed leaf columns of this group. */
+    getDisplayedLeafColumns(): Column[];
+    /** Returns the column group definition for this column.
+     * The column group definition will be the result of merging the application provided column group definition with any provided defaults
+     * (e.g. `defaultColGroupDef` grid option.
+     */
+    getColGroupDef(): ColGroupDef | null;
+    /** Returns `true` if this column group is a padding group that is used to correctly align column groups / children. */
+    isPadding(): boolean;
+    /** Returns the padding level of this padding group. */
+    getPaddingLevel(): number;
+    /** Returns `true` if this column group is expandable. */
+    isExpandable(): boolean;
+    /** Returns `true` if this column group is expanded. */
+    isExpanded(): boolean;
+    /** Returns the children of this group if they exist or `null` */
+    getChildren(): (Column | ColumnGroup)[] | null;
+    /** Returns the provided column group */
+    getProvidedColumnGroup(): ProvidedColumnGroup;
+    /** Returns the padding level of this padding group. */
+    getPaddingLevel(): number;
+    /** isColumn is always `false`. Used to distinguish between columns and column groups.  */
+    isColumn: false;
+}
+export interface ProvidedColumnGroup extends IProvidedColumn, IEventEmitter<AgProvidedColumnGroupEvent> {
+    /** Returns the level of this group. */
+    getLevel(): number;
+    /** Returns `true` if this column group is a padding group that is used to correctly align column groups / children. */
+    isPadding(): boolean;
+    /** Returns `true` if this column group is expandable. */
+    isExpandable(): boolean;
+    /** Returns `true` if this column group is expanded. */
+    isExpanded(): boolean;
+    /** Returns the group column id. */
+    getGroupId(): string;
+    /** Returns the children of this group. */
+    getChildren(): (Column | ProvidedColumnGroup)[];
+    /** Returns the column group definition for this column.
+     * The column group definition will be the result of merging the application provided column group definition with any provided defaults
+     * (e.g. `defaultColGroupDef` grid option.
+     */
+    getColGroupDef(): ColGroupDef | null;
+    /** Returns the leaf columns of this group. */
+    getLeafColumns(): Column[];
+    /** isColumn is always `false`. Used to distinguish between columns and column groups.  */
+    isColumn: false;
+}
+export {};

package/dist/types/src/interfaces/iContextMenu.d.ts

@@ -0,0 +1,38 @@
+import type { AgColumn } from '../entities/agColumn';
+import type { RowNode } from '../entities/rowNode';
+import type { CellCtrl } from '../rendering/cell/cellCtrl';
+import type { RowCtrl } from '../rendering/row/rowCtrl';
+import type { Column } from './iColumn';
+import type { IRowNode } from './iRowNode';
+export interface IContextMenuService {
+    hideActiveMenu(): void;
+    getContextMenuPosition(rowNode?: RowNode | null, column?: AgColumn | null): {
+        x: number;
+        y: number;
+    };
+    showContextMenu(params: EventShowContextMenuParams & {
+        anchorToElement?: HTMLElement;
+    }): void;
+    handleContextMenuMouseEvent(mouseEvent: MouseEvent | undefined, touchEvent: TouchEvent | undefined, rowComp: RowCtrl | null, cellCtrl: CellCtrl): void;
+}
+export interface ShowContextMenuParams {
+    /** The row node associated with the Context Menu */
+    rowNode?: IRowNode | null;
+    /** The column associated with the Context Menu */
+    column?: Column | null;
+    /** The value that will be passed to the Context Menu (useful with `getContextMenuItems`). If none is passed, and `rowNode` and `column` are provided, this will be the respective Cell value */
+    value: any;
+}
+export interface IContextMenuParams extends ShowContextMenuParams {
+    /** The x position for the Context Menu, if no value is given and `rowNode` and `column` are provided, this will default to be middle of the cell, otherwise it will be `0`. */
+    x?: number;
+    /** The y position for the Context Menu, if no value is given and `rowNode` and `column` are provided, this will default to be middle of the cell, otherwise it will be `0`. */
+    y?: number;
+}
+export interface MouseShowContextMenuParams {
+    mouseEvent: MouseEvent;
+}
+export interface TouchShowContextMenuParam {
+    touchEvent: TouchEvent;
+}
+export type EventShowContextMenuParams = (MouseShowContextMenuParams | TouchShowContextMenuParam) & ShowContextMenuParams;