@adaptabletools/adaptable
Version:
Powerful data-agnostic HTML5 AG Grid extension which provides advanced, cutting-edge functionality to meet all DataGrid requirements
270 lines (269 loc) • 13.4 kB
TypeScript
/// <reference types="react" />
import { ChartModel, ChartRef, Column, GridApi, GridOptions, IRowNode, Module, RowModelType, StatusPanelDef } from 'ag-grid-enterprise';
import { AdaptableApi, DestroyConfig } from '../Api/AdaptableApi';
import { AdaptableColumn } from '../AdaptableState/Common/AdaptableColumn';
import { ColumnSort } from '../AdaptableState/Common/ColumnSort';
import { DataUpdateConfig } from '../AdaptableState/Common/DataUpdateConfig';
import { Layout } from '../AdaptableState/LayoutState';
import { GridCell } from '../AdaptableState/Selection/GridCell';
import { SelectedCellInfo } from '../AdaptableState/Selection/SelectedCellInfo';
import { AdaptableTheme } from '../AdaptableState/ThemeState';
import { IAdaptableStore } from '../Redux/Store/Interface/IAdaptableStore';
import { IModuleCollection } from '../Strategy/Interface/IModule';
import { AdaptableMenuItem, AdaptableOptions, AdaptablePlugin, AdaptableState, ChartDefinition, SelectedRowInfo } from '../types';
import { ICalculatedColumnExpressionService } from '../Utilities/Services/Interface/ICalculatedColumnExpressionService';
import { IDataService } from '../Utilities/Services/Interface/IDataService';
import { AnnotationsService } from '../Utilities/Services/AnnotationsService';
import { IValidationService } from '../Utilities/Services/Interface/IValidationService';
import { IModuleService } from '../Utilities/Services/Interface/IModuleService';
import { ContextMenuContext } from '../AdaptableState/Common/Menu';
import { IQueryLanguageService } from '../Utilities/Services/Interface/IQueryLanguageService';
import { IAlertService } from '../Utilities/Services/Interface/IAlertService';
import { ITeamSharingService } from '../Utilities/Services/Interface/ITeamSharingService';
import { AdaptableFrameworkComponent } from '../agGrid/AdaptableFrameworkComponent';
import { IMetamodelService } from '../Utilities/Services/Interface/IMetamodelService';
import { RenderReactRootFn } from '../renderReactRoot';
import { AdaptableLogger } from '../agGrid/AdaptableLogger';
import { Fdc3Service } from '../Utilities/Services/Fdc3Service';
import { AgGridAdapter } from '../agGrid/AgGridAdapter';
import { AgGridColumnAdapter } from '../agGrid/AgGridColumnAdapter';
import { AgGridMenuAdapter } from '../agGrid/AgGridMenuAdapter';
import { RowFormService } from '../Utilities/Services/RowFormService';
import { FlashingCellService } from '../Utilities/Services/FlashingCellService';
import { AgGridExportAdapter } from '../agGrid/AgGridExportAdapter';
import { AgGridThemeAdapter } from '../agGrid/AgGridThemeAdapter';
/**
* Contains AG Grid Options and Modules - used when instantiating AdapTable vanilla
*/
export interface AgGridConfig {
/**
* AG Grid GridOptions object
*/
gridOptions: GridOptions;
/**
* AG Grid Modules to use; provide empty array if using CJS
*/
modules: Module[];
}
export type AdaptableVariant = 'vanilla' | 'react' | 'angular' | 'vue';
/**
* The only interface for Adaptable
*
* Contains all properties and methods that each implemenation must include
*
* Should only be used internally as all external access is via the Api
*/
export interface IAdaptable {
logger: AdaptableLogger;
variant: AdaptableVariant;
isReady: boolean;
isDestroyed: boolean;
isAgGridInitialising: boolean;
api: AdaptableApi;
adaptableOptions: AdaptableOptions;
adaptableStore: IAdaptableStore;
adaptableModules: IModuleCollection;
agGridAdapter: AgGridAdapter;
agGridMenuAdapter: AgGridMenuAdapter;
agGridColumnAdapter: AgGridColumnAdapter;
agGridExportAdapter: AgGridExportAdapter;
agGridThemeAdapter: AgGridThemeAdapter;
hasAdaptableToolPanel: boolean;
renderReactRoot: RenderReactRootFn;
/**
* Adaptable contains a number of 'Services' which are created at Startup
*
* Each takes an instance of Adaptable and is used when it is preferable to accessing a Module directly
*/
DataService: IDataService;
ValidationService: IValidationService;
CalculatedColumnExpressionService: ICalculatedColumnExpressionService;
ModuleService: IModuleService;
QueryLanguageService: IQueryLanguageService;
AlertService: IAlertService;
TeamSharingService: ITeamSharingService;
MetamodelService: IMetamodelService;
RowFormService: RowFormService;
Fdc3Service: Fdc3Service;
AnnotationsService: AnnotationsService;
FlashingCellService: FlashingCellService;
_PRIVATE_adaptableJSXElement: React.JSX.Element;
/**
* INTERNAL ADAPTABLE EVENTS
* These are not called externally - for that we use eventapi
*/
_on(eventName: 'CellsSelected', callback: () => void): () => void;
_on(eventName: 'GridRefreshed', callback: () => void): () => void;
_on(eventName: 'AdapTableFiltersApplied', callback: () => void): () => void;
_on(eventName: 'KeyDown', callback: (keyDownEvent: any) => void): () => void;
_on(eventName: 'MouseEnter', callback: (event: MouseEvent) => void): () => void;
_on(eventName: 'MouseLeave', callback: (event: MouseEvent) => void): () => void;
_on(eventname: 'FirstDataRendered', callback: () => void): () => void;
_on(eventName: 'CellEditorKeyDown', callback: (param: {
keyDownEvent: KeyboardEvent;
cellValue: any;
columnId: string;
updateValueCallback: (updatedValue: any) => void;
}) => void): () => void;
_onIncludeFired(eventName: 'FrameworkComponentChange', callback: (param: {
command: 'create' | 'destroy';
containerDomNode: HTMLElement;
frameworkComponent: AdaptableFrameworkComponent;
componentType: string;
}) => void): () => void;
_on(eventName: 'CreateAdaptableContextMenuItems', callback: (param: {
items: AdaptableMenuItem[];
menuContext: ContextMenuContext;
}) => void): () => void;
_emit(eventName: 'CellEditorKeyDown', data: {
keyDownEvent: KeyboardEvent;
cellValue: any;
columnId: string;
updateValueCallback: (updatedValue: any) => void;
}): Promise<any>;
_emitSync(eventName: 'FrameworkComponentChange', data: {
command: 'create' | 'destroy';
containerDomNode: HTMLElement;
frameworkComponent: AdaptableFrameworkComponent;
componentType: string;
}): Promise<any>;
_emitSync(eventName: 'CreateAdaptableContextMenuItems', data?: any): Promise<any>;
/**
*
*/
getAgGridContainerElement(): HTMLElement | null;
redrawBody(): void;
refreshHeader(): void;
redrawRow(rowNode: IRowNode): void;
redrawRows(rowNodes?: IRowNode[]): void;
refreshCell(rowNode: IRowNode, column: string | any, forceUpdate: boolean, suppressFlash?: boolean): void;
refreshCells(rowNode: IRowNode, columns: (string | any)[], forceUpdate: boolean, suppressFlash?: boolean): void;
refreshAllCells(forceUpdate?: boolean): void;
refreshColumns(columns: (string | Column)[], forceUpdate: boolean, suppressFlash?: boolean): void;
refreshSelectedCellsState(): SelectedCellInfo | undefined;
refreshSelectedRowsState(): SelectedRowInfo | undefined;
selectColumn(columnId: string, config?: {
keepExistingSelection?: boolean;
}): void;
selectColumns(columnIds: string[], config?: {
keepExistingSelection?: boolean;
}): void;
selectAll(): void;
deselectAll(): void;
selectNodes(rowNodes: IRowNode[], clearSelection: boolean): void;
deSelectNodes(rowNodes: IRowNode[], clearSelection: boolean): void;
selectNode(rowNode: IRowNode, clearSelection: boolean): void;
deSelectNode(rowNode: IRowNode, clearSelection: boolean): void;
selectCells(columnIds: string[], startNode: IRowNode, endNode: IRowNode, clearSelection?: boolean): void;
jumpToRow(rowNode: IRowNode): void;
jumpToColumn(columnId: string): void;
jumpToCell(columnId: string, rowNode: IRowNode): void;
setGridData(dataSource: any): void;
getGridData(): any[];
getFilteredData(): any[];
updateRows(dataRows: any[], dataUpdateConfig?: DataUpdateConfig): Promise<IRowNode[]>;
addRows(dataRows: any[], dataUpdateConfig?: DataUpdateConfig): Promise<IRowNode[]>;
addOrUpdateRows(dataRows: any[], dataUpdateConfig?: DataUpdateConfig): Promise<{
added: IRowNode[];
updated: IRowNode[];
}>;
deleteRows(dataRows: any[], dataUpdateConfig?: DataUpdateConfig): Promise<IRowNode[]>;
getPrimaryKeyValueFromRowNode(rowNode: IRowNode, gridApi?: GridApi): any;
getDistinctGridCellsForColumn(column: AdaptableColumn): GridCell[];
getDistinctValuesForColumn(column: AdaptableColumn): Promise<GridCell[]>;
getDistinctEditValuesForColumn(options: {
column: AdaptableColumn;
gridCell?: GridCell;
currentSearchValue: string;
}): Promise<GridCell[]>;
getDistinctFilterValuesForColumn(options: {
column: AdaptableColumn;
currentSearchValue: string;
}): Promise<GridCell[]>;
getGridCellFromRowNode(rowNode: IRowNode, columnId: string): GridCell | undefined;
getRawValueFromRowNode(rowNode: IRowNode, columnId: string): any;
getDisplayValueFromRowNode(rowNode: IRowNode, columnId: string): string | undefined;
getDisplayValueFromRawValue(rowNode: IRowNode, columnId: string, rawValue: any): string | undefined;
getNormalisedValueFromRawValue(rawValue: any, column: AdaptableColumn): string | number | boolean | Date | unknown;
getGridCellsForColumn(columnId: string, onlyVisibleRows?: boolean): GridCell[] | undefined;
getRowNodesForPrimaryKeys(primaryKeyValues: any[]): IRowNode[];
getRowNodeForPrimaryKey(primaryKeyValue: any): IRowNode;
getRowNodeByIndex(index: number): IRowNode;
getAgGridStatusPanels(): StatusPanelDef[];
forPlugins(callback: (plugin: AdaptablePlugin) => any): void;
getPluginProperty(pluginId: string, propertyName: string, ...args: any): any;
getPlugin(pluginId: string): AdaptablePlugin;
setDataValue(value: any, column: AdaptableColumn, primaryKeyValue: any, rowNode?: IRowNode): void;
getFirstRowNode(): IRowNode | undefined;
getFirstDisplayedRowNode(): IRowNode | undefined;
forAllRowNodesDo(func: (rowNode: IRowNode) => void, config?: {
includeGroupRows?: boolean;
filterFn?: (rowNode: IRowNode) => boolean;
}): void;
forAllVisibleRowNodesDo(func: (rowNode: IRowNode, rowIndex: number) => void, config?: {
includeGroupRows?: boolean;
filterFn?: (rowNode: IRowNode) => boolean;
}): void;
getAllRowNodes(config?: {
includeGroupRows?: boolean;
filterFn?: (rowNode: IRowNode) => boolean;
}): IRowNode[];
getGroupRowNodes(config?: {
filterFn?: (rowNode: IRowNode) => boolean;
}): IRowNode[];
updateRowGroupsExpandedState(layout?: Layout): void;
getRowsInViewport(): IRowNode[];
isGroupRowNode(rowNode: IRowNode): boolean;
isRowNodeVisible(rowNode: IRowNode): boolean;
getAgGridColumnType(columnId: string): string | string[];
hideColumn(columnId: string): void;
showColumn(columnId: string): void;
autoSizeColumn(columnId: string): void;
autoSizeColumns(columnIds: string[]): void;
autoSizeAllColumns(): void;
setColumnSort(columnSorts: ColumnSort[]): void;
clearColumnSort(): void;
clearColumnFiltering(): void;
clearColumnFilteringForColumns(columnIds: string[]): void;
applyFiltering(): void;
showQuickFilter(): void;
hideQuickFilter(): void;
isQuickFilterAvailable(): boolean;
setAgGridQuickSearch(query: string): void;
clearAgGridQuickSearch(): void;
canGenerateCharts(): boolean;
canDisplaySparklines(): boolean;
showCharts(charts: ChartDefinition[]): ChartRef[];
showChart(chart: ChartDefinition, container?: HTMLElement): ChartRef;
getChartRef(chardId: string): ChartRef;
updateChart(chart: ChartDefinition): void;
getChartModels(): ChartModel[];
getAgGridRowModelType(): RowModelType;
getRowCount(): number;
getVisibleRowCount(): number;
getColumnCount(): number;
getVisibleColumnCount(): number;
isGridRangeSelectable(): boolean;
isGridRowSelectable(): boolean;
isGridGroupingActive(): boolean;
applyAdaptableTheme(theme: AdaptableTheme | string): void;
setRowGroupColumns(columnIds: string[]): void;
getAllGridColumns(): Column<any>[];
clearRowGroupColumns(): void;
expandAllRowGroups(): void;
collapseAllRowGroups(): void;
expandRowGroupsForValues(columnValues: any[]): void;
getAdaptableContainerElement(): HTMLElement | null;
getAgGridContainerElement(): HTMLElement | null;
updateColumnModelAndRefreshGrid(): void;
getAgGridColumnForColumnId(columnId: string): Column;
getMinMaxCachedValueForColumn(column: AdaptableColumn, minMax: 'min' | 'max'): number | undefined;
getAgGridRegisteredModules(): Module[];
destroy(config?: DestroyConfig): void;
setLayout(layout?: Layout): void;
canExportToExcel(): boolean;
canExportToCsv(): boolean;
normalizeAdaptableState(state: AdaptableState, options: NormalizeAdaptableStateOptions): AdaptableState;
refreshLayout(): void;
}
export type NormalizeAdaptableStateOptions = Pick<GridOptions, 'rowModelType' | 'treeData' | 'columnDefs' | 'autoGroupColumnDef'>;