JavaScript Data Grid: Grid Callbacks

getContextMenuItems = (
    params: GetContextMenuItemsParams
) => (string | MenuItemDef)[];

interface GetContextMenuItemsParams {
  // Names of the items that would be provided by default. 
  defaultItems: string[] | undefined;
  // The column, if a cell was clicked, otherwise null. 
  column: Column | null;
  // The row node, if a cell was clicked, otherwise null. 
  node: RowNode | null;
  // The value, if a cell was clicked, otherwise null. 
  value: any;
  api: GridApi;
  columnApi: ColumnApi;
  // The context as provided on `gridOptions.context` 
  context: any;
}

interface MenuItemDef {
  // If this item is a sub menu, contains a list of menu item definitions 
  subMenu?: (MenuItemDef | string)[];
  // Name of the menu item 
  name: string;
  // It the item should be enabled / disabled 
  disabled?: boolean;
  // Shortcut (just display text, saying the shortcut here does nothing) 
  shortcut?: string;
  // Function that gets executed when item is chosen 
  action?: () => void;
  // Set to true to provide a check beside the option 
  checked?: boolean;
  // The icon to display, either a DOM element or HTML string 
  icon?: HTMLElement | string;
  // CSS classes to apply to the menu item 
  cssClasses?: string[];
  // Tooltip for the menu item 
  tooltip?: string;
}

getMainMenuItems = (
    params: GetMainMenuItemsParams
) => (string | MenuItemDef)[];

interface GetMainMenuItemsParams {
  // The column that was clicked 
  column: Column;
  // List of the items that would be displayed by default 
  defaultItems: string[];
  api: GridApi;
  columnApi: ColumnApi;
  // The context as provided on `gridOptions.context` 
  context: any;
}

interface MenuItemDef {
  // If this item is a sub menu, contains a list of menu item definitions 
  subMenu?: (MenuItemDef | string)[];
  // Name of the menu item 
  name: string;
  // It the item should be enabled / disabled 
  disabled?: boolean;
  // Shortcut (just display text, saying the shortcut here does nothing) 
  shortcut?: string;
  // Function that gets executed when item is chosen 
  action?: () => void;
  // Set to true to provide a check beside the option 
  checked?: boolean;
  // The icon to display, either a DOM element or HTML string 
  icon?: HTMLElement | string;
  // CSS classes to apply to the menu item 
  cssClasses?: string[];
  // Tooltip for the menu item 
  tooltip?: string;
}

postProcessPopup = (
    params: PostProcessPopupParams
) => void;

interface PostProcessPopupParams {
  // If popup is for a column, this gives the Column 
  column?: Column | null;
  // If popup is for a row, this gives the RowNode 
  rowNode?: RowNode | null;
  // The popup we are showing 
  ePopup: HTMLElement;
  // The different types are:
  // 'contextMenu', 'columnMenu', 'aggFuncSelect', 'popupCellEditor' 
  type: string;
  // If the popup is as a result of a button click (eg menu button),
  // this is the component that the user clicked 
  eventSource?: HTMLElement | null;
  // If the popup is as a result of a click or touch,
  // this is the event - eg user showing context menu 
  mouseEvent?: MouseEvent | Touch | null;
}

processCellForClipboard = (
    params: ProcessCellForExportParams
) => any;

interface ProcessCellForExportParams {
  value: any;
  accumulatedRowIndex?: number;
  node?: RowNode | null;
  column: Column;
  api: GridApi;
  columnApi: ColumnApi;
  // The context as provided on `gridOptions.context` 
  context: any;
  type: string;
}

processHeaderForClipboard = (
    params: ProcessHeaderForExportParams
) => any;

interface ProcessHeaderForExportParams {
  column: Column;
  api: GridApi;
  columnApi: ColumnApi;
  // The context as provided on `gridOptions.context` 
  context: any;
}

processGroupHeaderForClipboard = (
    params: ProcessGroupHeaderForExportParams
) => any;

interface ProcessGroupHeaderForExportParams {
  columnGroup: ColumnGroup;
  api: GridApi;
  columnApi: ColumnApi;
  // The context as provided on `gridOptions.context` 
  context: any;
}

processCellFromClipboard = (
    params: ProcessCellForExportParams
) => any;

interface ProcessCellForExportParams {
  value: any;
  accumulatedRowIndex?: number;
  node?: RowNode | null;
  column: Column;
  api: GridApi;
  columnApi: ColumnApi;
  // The context as provided on `gridOptions.context` 
  context: any;
  type: string;
}

sendToClipboard = (
    params: SendToClipboardParams
) => void;

interface SendToClipboardParams {
  data: string;
}

processDataFromClipboard = (
    params: ProcessDataFromClipboardParams
) => string[][] | null;

interface ProcessDataFromClipboardParams {
  // 2D array of all cells from the clipboard 
  data: string[][];
}

isExternalFilterPresent = () => boolean;

doesExternalFilterPass = (node: RowNode) => boolean;

getChartToolbarItems = (
    params: GetChartToolbarItemsParams
) => ChartMenuOptions[];

interface GetChartToolbarItemsParams {
  defaultItems?: ChartMenuOptions[];
  api: GridApi;
  columnApi: ColumnApi;
}

type ChartMenuOptions = 
      'chartSettings' 
    | 'chartData' 
    | 'chartFormat' 
    | 'chartLink' 
    | 'chartUnlink' 
    | 'chartDownload'

createChartContainer = (params: ChartRef) => void;

interface ChartRef {
  // The id of the created chart. 
  chartId: string;
  // The chart instance that is produced by AG Charts which can be used to interact with the chart directly. 
  chart: any;
  // The chart DOM element, which the application is responsible for placing into the DOM. 
  chartElement: HTMLElement;
  // The application is responsible for calling this when the chart is no longer needed. 
  destroyChart: () => void;
}

navigateToNextHeader = (
    params: NavigateToNextHeaderParams
) => (HeaderPosition | null);

interface NavigateToNextHeaderParams {
  // The key for the arrow key pressed,
  // left = 'ArrowLeft', up = 'ArrowUp', right = 'ArrowRight', down = 'ArrowDown' 
  key: string;
  // The header that currently has focus 
  previousHeaderPosition: HeaderPosition | null;
  // The header the grid would normally pick as the next header for this navigation 
  nextHeaderPosition: HeaderPosition | null;
  // The number of header rows present in the grid 
  headerRowCount: number;
  event: KeyboardEvent;
  api: GridApi;
  columnApi: ColumnApi;
}

interface HeaderPosition {
  // A number from 0 to n, where n is the last header row the grid is rendering 
  headerRowIndex: number;
  // The grid column or column group 
  column: Column | ColumnGroup;
}

tabToNextHeader = (
    params: TabToNextHeaderParams
) => (HeaderPosition | null);

interface TabToNextHeaderParams {
  // True if the Shift key is also down 
  backwards: boolean;
  // The header that currently has focus 
  previousHeaderPosition: HeaderPosition | null;
  // The header the grid would normally pick as the next header for this navigation 
  nextHeaderPosition: HeaderPosition | null;
  // The number of header rows present in the grid 
  headerRowCount: number;
  api: GridApi;
  columnApi: ColumnApi;
}

interface HeaderPosition {
  // A number from 0 to n, where n is the last header row the grid is rendering 
  headerRowIndex: number;
  // The grid column or column group 
  column: Column | ColumnGroup;
}

navigateToNextCell = (
    params: NavigateToNextCellParams
) => (CellPosition | null);

interface NavigateToNextCellParams {
  // The keycode for the arrow key pressed:
  // left = 'ArrowLeft', up = 'ArrowUp', right = 'ArrowRight', down = 'ArrowDown' 
  key: string;
  // The cell that currently has focus 
  previousCellPosition: CellPosition;
  // The cell the grid would normally pick as the next cell for navigation 
  nextCellPosition: CellPosition | null;
  event: KeyboardEvent | null;
  api: GridApi;
  columnApi: ColumnApi;
}

interface CellPosition {
  // The grid column 
  column: Column;
  // A positive number from 0 to n, where n is the last row the grid is rendering
  // or -1 if you want to navigate to the grid header 
  rowIndex: number;
  // Either 'top', 'bottom' or null (for not pinned) 
  rowPinned: string | null;
}

tabToNextCell = (
    params: TabToNextCellParams
) => (CellPosition | null);

interface TabToNextCellParams {
  // True if the Shift key is also down 
  backwards: boolean;
  // True if the current cell is editing
  // (you may want to skip cells that are not editable, as the grid will enter the next cell in editing mode also if tabbing) 
  editing: boolean;
  // The cell that currently has focus 
  previousCellPosition: CellPosition;
  // The cell the grid would normally pick as the next cell for navigation. 
  nextCellPosition: CellPosition | null;
  api: GridApi;
  columnApi: ColumnApi;
}

interface CellPosition {
  // The grid column 
  column: Column;
  // A positive number from 0 to n, where n is the last row the grid is rendering
  // or -1 if you want to navigate to the grid header 
  rowIndex: number;
  // Either 'top', 'bottom' or null (for not pinned) 
  rowPinned: string | null;
}

suppressKeyboardEvent = (
    params: SuppressKeyboardEventParams
) => boolean;

interface SuppressKeyboardEventParams {
  // The keyboard event the grid received 
  event: KeyboardEvent;
  // Whether the cell is editing or not 
  editing: boolean;
  // Row node for the given row 
  node: RowNode;
  // Data associated with the node 
  data: any;
  // Column for this callback 
  column: Column;
  // ColDef provided for this column 
  colDef: ColDef;
  api: GridApi;
  columnApi: ColumnApi;
  // The context as provided on `gridOptions.context` 
  context: any;
}

localeTextFunc = (
    key: string,
    defaultValue: string,
    variableValues?: string[]
) => string;

getDocument = () => Document;

paginationNumberFormatter = (
    params: PaginationNumberFormatterParams
) => string;

interface PaginationNumberFormatterParams {
  value: number;
}

groupRowAggNodes = (nodes: RowNode[]) => any;

isGroupOpenByDefault = (
    params: IsGroupOpenByDefaultParams
) => boolean;

interface IsGroupOpenByDefaultParams {
  // The row node being considered. 
  rowNode: RowNode;
  // The Column for which this row is grouping. 
  rowGroupColumn: Column;
  // Same as `rowNode.level` - what level the group is at, e.g. 0 for top level, 1 for second etc 
  level: number;
  // Same as `rowNode.field` - the field we are grouping on, e.g. 'country' 
  field: string;
  // Same as `rowNode.key`, the value of this group, e.g. 'Ireland' 
  key: string;
}

defaultGroupOrderComparator = (
    nodeA: RowNode,
    nodeB: RowNode
) => number;

processSecondaryColDef = (colDef: ColDef) => void;

processSecondaryColGroupDef = (
    colGroupDef: ColGroupDef
) => void;

getDataPath = (data: any) => string[];

getChildCount = (dataItem: any) => number;

getServerSideStoreParams = (
    params: GetServerSideStoreParamsParams
) => ServerSideStoreParams;

interface GetServerSideStoreParamsParams {
  // The level of the store. Top level is 0. 
  level: number;
  // The Row Node for the group that got expanded, or undefined if top level (ie no parent) 
  parentRowNode?: RowNode;
  // Active Row Group Columns, if any. 
  rowGroupColumns: Column[];
  // Active Pivot Columns, if any. 
  pivotColumns: Column[];
  // true if pivot mode is active. 
  pivotMode: boolean;
}

interface ServerSideStoreParams {
  // What store type to use.
  // If missing, then defaults to grid option `serverSideStoreType`. 
  storeType?: ServerSideStoreType;
  // For Partial Store only.
  // How many blocks to keep in cache.
  // If missing, defaults to grid options `maxBlocksInCache`. 
  maxBlocksInCache?: number;
  // For Partial Store only.
  // Cache block size.
  // If missing, defaults to grid options `cacheBlockSize`. 
  cacheBlockSize?: number;
}

type ServerSideStoreType = 'full' | 'partial'

isServerSideGroupOpenByDefault = (
    params: IsServerSideGroupOpenByDefaultParams
) => boolean;

interface IsServerSideGroupOpenByDefaultParams {
  data: any;
  rowNode: RowNode;
}

isApplyServerSideTransaction = (
    params: IsApplyServerSideTransactionParams
) => boolean;

interface IsApplyServerSideTransactionParams {
  // The transaction getting applied. 
  transaction: ServerSideTransaction;
  // The parent RowNode, if transaction is applied to a group. 
  parentNode: RowNode;
  storeInfo: any;
}

isServerSideGroup = (dataItem: any) => boolean;

getServerSideGroupKey = (dataItem: any) => string;

getBusinessKeyForNode = (node: RowNode) => string;

getRowId = (params: GetRowIdParams) => string;

interface GetRowIdParams {
  // Grid's API 
  api: GridApi;
  // Grid's Column API 
  columnApi: ColumnApi;
  // The data item provided to the grid for the row in question 
  data: any;
  // If grouping, the level, ie how many levels from the top. Used by ServerSide Row Model only 
  level: number;
  // If grouping, provides the keys of the parent groups. Used by ServerSide Row Model only 
  parentKeys?: string[];
}

processRowPostCreate = (
    params: ProcessRowParams
) => void;

interface ProcessRowParams {
  eRow: HTMLElement;
  ePinnedLeftRow: HTMLElement;
  ePinnedRightRow: HTMLElement;
  rowIndex: number;
  node: RowNode;
  api: GridApi;
  columnApi: ColumnApi;
  addRenderedRowListener: (eventType: string, listener: Function) => void;
  // The context as provided on `gridOptions.context` 
  context: any;
}

isRowSelectable = (node: RowNode) => boolean;

isRowMaster = (dataItem: any) => boolean;

fillOperation = (
    params: FillOperationParams
) => any;

interface FillOperationParams {
  // The mouse event for the fill operation. 
  event: MouseEvent;
  // The values that have been processed by the fill operation. 
  values: any[];
  // The RowNode of the current cell being changed. 
  rowNode: RowNode;
  // The Column of the current cell being changed. 
  column: Column;
  // The values that were present before processing started. 
  initialValues: any[];
  // The index of the current processed value. 
  currentIndex: number;
  // The value of the cell being currently processed by the Fill Operation. 
  currentCellValue: any;
  // The direction of the Fill Operation. 
  direction: 'up' | 'down' | 'left' | 'right';
  api: GridApi;
  columnApi: ColumnApi;
  // The context as provided on `gridOptions.context` 
  context: any;
}

postSort = (nodes: RowNode[]) => void;

getRowClass = (params: RowClassParams) => string | string[] | undefined;

interface RowClassParams {
  // The data associated with this row from rowData 
  data: any;
  // The RowNode associated with this row 
  node: RowNode;
  // The index of the row 
  rowIndex: number;
  api: GridApi;
  columnApi: ColumnApi;
  // The context as provided on `gridOptions.context` 
  context: any;
  // If using AngularJs, is the row's child scope, otherwise null 
  $scope: any;
}

getRowStyle = (params: RowClassParams) => RowStyle | undefined;

interface RowClassParams {
  // The data associated with this row from rowData 
  data: any;
  // The RowNode associated with this row 
  node: RowNode;
  // The index of the row 
  rowIndex: number;
  api: GridApi;
  columnApi: ColumnApi;
  // The context as provided on `gridOptions.context` 
  context: any;
  // If using AngularJs, is the row's child scope, otherwise null 
  $scope: any;
}

interface RowStyle {
  [cssProperty: string]: string | number;
}

getRowHeight = (
    params: RowHeightParams
) => number | undefined | null;

interface RowHeightParams {
  data: any;
  node: RowNode;
  api: GridApi;
  // The context as provided on `gridOptions.context` 
  context: any;
}

isFullWidthCell = (rowNode: RowNode) => boolean;