@adaptabletools/adaptable 19.0.1 → 19.0.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adaptabletools/adaptable",
-  "version": "19.0.1",
+  "version": "19.0.3",
   "description": "Powerful data-agnostic HTML5 AG Grid extension which provides advanced, cutting-edge functionality to meet all DataGrid requirements",
   "keywords": [
     "web-components",

package/src/AdaptableInterfaces/IAdaptable.d.ts

@@ -186,7 +186,6 @@ export interface IAdaptable {
     getPluginProperty(pluginId: string, propertyName: string, ...args: any): any;
     getPlugin(pluginId: string): AdaptablePlugin;
     setDataValue(value: any, column: AdaptableColumn, primaryKeyValue: any, rowNode?: IRowNode): void;
-    isCellEditable(rowNode: IRowNode, column: Column): boolean;
     getFirstRowNode(): IRowNode | undefined;
     getFirstDisplayedRowNode(): IRowNode | undefined;
     forAllRowNodesDo(func: (rowNode: IRowNode) => void, config?: {
@@ -236,6 +235,7 @@ export interface IAdaptable {
     getChartModels(): ChartModel[];
     getAgGridRowModelType(): RowModelType;
     getRowCount(): number;
+    getVisibleRowCount(): number;
     getColumnCount(): number;
     getVisibleColumnCount(): number;
     isGridRangeSelectable(): boolean;

package/src/AdaptableOptions/ActionRowOptions.d.ts

@@ -79,11 +79,11 @@ export interface ActionRowFormOptions<TData = any> {
      */
     formFieldLabel?: (context: ActionRowParamFieldContext<TData>) => string;
     /**
-     * Custom form buttons provider. If provided, the custom implementation is responsible for firing the 'ActionRowSubmitted' and/or invoking the 'onFormSubmit' callback (if necessary).
+     * Custom form buttons; if provided, need to handle form submission explicitly
      */
     formButtons?: AdaptableButton<ActionRowFormContext<TData>>[];
     /**
-     * Event published when the form in an Action Row is submitted via a standard button (provided by AdapTable). This is not invoked when custom form buttons are provided!
+     * Event fired when an Action Row Form is submitted via a standard button provided by AdapTable; this is not invoked when custom form buttons are provided
      *
      * @param actionRowSubmittedInfo the form submitted info
      * @defaultValue undefined

package/src/AdaptableOptions/DataChangeHistoryOptions.d.ts

@@ -5,7 +5,7 @@ import { ActionColumnContext, AdaptableApi, AdaptableButton } from '../types';
  */
 export interface DataChangeHistoryOptions<TData = any> {
     /**
-     * Whether data change history should be active by default
+     * Make Data Change History active by default
      *
      * @defaultValue false
      * @gridInfoItem
@@ -26,7 +26,7 @@ export interface DataChangeHistoryOptions<TData = any> {
      */
     changeHistoryButton?: DataChangeHistoryButton<TData> | DataChangeHistoryButton<TData>[];
     /**
-     * Show all changes for each Cell or just the last one
+     * Show all changes for a Cell or just the last one
      * @defaultValue true
      */
     showLastDataChangeOnly?: boolean;

package/src/AdaptableOptions/UserInterfaceOptions.d.ts

@@ -55,13 +55,17 @@ export interface UserInterfaceOptions<TData = any> {
      */
     colorPalette?: string[] | ((currentTheme: string) => string[]);
     /**
-     * Style to set for editable cells
+     * Style to set for editable Cells
      */
     editableCellStyle?: AdaptableStyle;
     /**
-     * Style to set for non-editable cells
+     * Style to set for non-editable Cells
      */
     readOnlyCellStyle?: AdaptableStyle;
+    /**
+      * Style to set for Cells which have been edited
+      */
+    editedCellStyle?: AdaptableStyle;
     /**
      * Optional list of CSS styles that can be used when creating Adaptable Styles in Adaptable (e.g. in Format Column and other Modules)
      *

package/src/Api/ColumnApi.d.ts

@@ -280,20 +280,6 @@ export interface ColumnApi {
      * Returns all columns currently Row Grouped
      */
     getRowGroupedColumns(): AdaptableColumn[];
-    /**
-     * Updates the Column Configuration for a given Column. It will update the current Layout with the new configuration.
-     * @param columnConfiguration - the Column Configuration to set
-     */
-    updateColumnConfiguration(columnConfiguration: ColumnConfig): void;
-    /**
-     * Updates the Column Configurations for a list of Columns. It will update the current Layout with the new configurations.
-     * @param columnConfigurations - the Column Configurations to set
-     */
-    updateColumnConfigurations(columnConfigurations: ColumnConfig[]): void;
-    /**
-     * Sets the Column Definitions for the Grid
-     */
-    setColumnDefinitions(columnDefinitions: (ColDef | ColGroupDef)[]): void;
     /**
      * Returns all the distinct display values in a given Column
      * @param columnId Column to Check
@@ -305,9 +291,22 @@ export interface ColumnApi {
      * @param caption New Caption to display
      */
     setColumnCaption(columnId: string, caption: string): void;
+    /**
+     * @deprecated use `GridApi.setAgGridColumnDefinitions()` instead
+     */
+    setColumnDefinitions(columnDefinitions: (ColDef | ColGroupDef)[]): void;
+    /**
+     * @deprecated use `GridApi.updateAgGridColumnState()` instead
+     */
+    updateColumnConfiguration(columnConfiguration: ColumnConfig): void;
+    /**
+     * @deprecated use `GridApi.updateAgGridColumnState()` instead
+     */
+    updateColumnConfigurations(columnConfigurations: ColumnConfig[]): void;
 }
 /**
- * Configuration of an AG Grid Column, used for runtime updating of ColDefs
+ * Column State is stateful information and represents changing properties of the grid columns.
+ * @deprecated use `ColumnState` from `@ag-grid-community/core` instead
  */
 export interface ColumnConfig {
     /** Column Id (mandatory) */

package/src/Api/DataChangeHistoryApi.d.ts

@@ -1,4 +1,5 @@
 import { CellDataChangedInfo } from '../PredefinedConfig/Common/CellDataChangedInfo';
+import { GridCell } from '../types';
 /**
  * Provides run-time access to the Data Change History Module
  **/
@@ -25,6 +26,10 @@ export interface DataChangeHistoryApi {
      * Retrieves all data changes which are currently available
      */
     getDataChangeHistoryLog(): CellDataChangedInfo[];
+    /**
+     * Retrieves last data change for a given Cell
+     */
+    getDataChangeForGridCell(gridCell: GridCell): CellDataChangedInfo | undefined;
     /**
      * Adds item to Data Change History log
      *

package/src/Api/Events/GridSorted.d.ts

@@ -11,15 +11,15 @@ export interface GridSortedInfo extends BaseEventInfo {
     adaptableSortState: AdaptableSortState;
 }
 /**
- * Overview of current sorting state in the grid
+ * Overview of current sorting state in AG Grid
  */
 export interface AdaptableSortState {
     /**
-     * Which columns have sorting applied and,if so, which direction
+     * Which Columns have sorting applied and,if so, in which direction
      */
     columnSorts: ColumnSort[];
     /**
-     * All the Custom Sorts in State; this is always sent even if no custom sorts are active
+     * All Custom Sorts in State (note: this is always sent, even if no custom sorts are active)
      */
     customSorts: CustomSort[];
 }

package/src/Api/GridApi.d.ts

@@ -7,7 +7,7 @@ import { DataUpdateConfig } from '../PredefinedConfig/Common/DataUpdateConfig';
 import { CellDataChangedInfo } from '../PredefinedConfig/Common/CellDataChangedInfo';
 import { CellHighlightInfo } from '../PredefinedConfig/Common/CellHighlightInfo';
 import { RowHighlightInfo } from '../PredefinedConfig/Common/RowHighlightInfo';
-import { Column, IRowNode, RowModelType } from '@ag-grid-community/core';
+import { ColDef, ColGroupDef, Column, ColumnState, IRowNode, RowModelType } from '@ag-grid-community/core';
 import { GridCellRange } from '../PredefinedConfig/Selection/GridCellRange';
 import { RowsHighlightInfo } from '../PredefinedConfig/Common/RowsHighlightInfo';
 import { TransposeConfig } from '../PredefinedConfig/Common/TransposeConfig';
@@ -457,6 +457,16 @@ export interface GridApi {
      * @param columnIds ColumnIds which contain cells to refresh
      */
     refreshCells(rowNodes: IRowNode[], columnIds: string[]): void;
+    /**
+     * Refreshes a single Grid Cell
+     * @param gridCell GridCell to refresh
+     */
+    refreshGridCell(gridCell: GridCell): void;
+    /**
+     * Refreshes a single Grid Cell
+     * @param gridCells GridCells to refresh
+     */
+    refreshGridCells(gridCells: GridCell[]): void;
     /**
      * Forces a re-render of the row with the given primary key value
      * @param primaryKey row primary key
@@ -480,6 +490,10 @@ export interface GridApi {
      * Returns number of rows in Data Source
      */
     getRowCount(): number;
+    /**
+     * Returns number of rows in Data Source
+     */
+    getVisibleRowCount(): number;
     /**
      * Returns number of columns in Data Source
      */
@@ -494,9 +508,14 @@ export interface GridApi {
     destroy(): void;
     /**
      * Checks if given Grid Cell is editable
-     * @param gridCell cell to check
+     * @param gridCell Cell to check
      */
     isCellEditable(gridCell: GridCell): boolean;
+    /**
+     * Checks if given Grid Cell has been edited (uses Data Change History)
+     * @param gridCell Cell to check
+     */
+    isCellEdited(gridCell: GridCell): boolean;
     /**
      * Checks if all of given Grid Cells are editable
      * @param gridCells cells to check
@@ -530,4 +549,46 @@ export interface GridApi {
      * Return all AG Grid columns
      */
     getAllAgGridColumns(): Column<any>[];
+    /**
+     * Updates the Column State for a given Column. Column State is stateful information and represents changing values of the grid. It will update the current Layout with the new state.
+     * @param columnState - the AG Grid ColumnState to set
+     */
+    updateAgGridColumnState(columnState: ColumnState): void;
+    /**
+     * Updates the Column State for a given Columns. Column State is stateful information and represents changing values of the grid. It will update the current Layout with the new state.
+     * @param columnStates - the AG Grid ColumnState to set
+     */
+    updateAgGridColumnStates(columnStates: ColumnState[]): void;
+    /**
+     * Sets the Column Definitions for the Grid
+     */
+    setAgGridColumnDefinitions(columnDefinitions: (ColDef | ColGroupDef)[]): void;
+    /**
+     * Updates the Column Definition for a given Column. The provided column properties are merged with the existing Column Definition.
+     * @param columnId - the ColumnId to update
+     * @param columnDefinition - the new Column Definition
+     */
+    updateAgGridColumnDefinition(columnDefinition: ColDefWithId): void;
+    /**
+     * Updates the Column Definitions for the given Columns. The provided column properties are merged with the existing Column Definitions.
+     * @param columnId - the ColumnId to update
+     * @param columnDefinition - the new Column Definition
+     */
+    updateAgGridColumnDefinitions(columnDefinitions: ColDefWithId[]): void;
+    /**
+     * Removes the Column Definition for a given Column.
+     * @param columnId - the ColumnId to remove
+     */
+    removeAgGridColumnDefinition(columnId: string): void;
+    /**
+     * Adds a Column Definition to the Grid
+     * @param columnDefinition - the new Column Definition
+     */
+    addAgGridColumnDefinition(columnDefinition: ColDefWithId): void;
 }
+/**
+ * Column Definition with a mandatory `colId` property
+ */
+export type ColDefWithId = Omit<ColDef, 'colId'> & {
+    colId: string;
+};

package/src/Api/Implementation/ColumnApiImpl.d.ts

@@ -70,9 +70,9 @@ export declare class ColumnApiImpl extends ApiBase implements ColumnApi {
     getColumnTypes(): string[];
     getColumnsByColumnType(columnType: string): AdaptableColumn[];
     getRowGroupedColumns(): AdaptableColumn[];
+    getDistinctDisplayValuesForColumn(columnId: string): any[];
+    setColumnCaption(columnId: string, caption: string): void;
     updateColumnConfiguration(columnConfig: ColumnConfig): void;
     updateColumnConfigurations(columnConfigs: ColumnConfig[]): void;
     setColumnDefinitions(columnDefinitions: (ColDef | ColGroupDef)[]): void;
-    getDistinctDisplayValuesForColumn(columnId: string): any[];
-    setColumnCaption(columnId: string, caption: string): void;
 }

package/src/Api/Implementation/ColumnApiImpl.js

@@ -4,6 +4,7 @@ import * as ModuleConstants from '../../Utilities/Constants/ModuleConstants';
 import { ColumnInternalApi } from '../Internal/ColumnInternalApi';
 import { createBaseContext } from '../../Utilities/ObjectFactory';
 import ArrayExtensions from '../../Utilities/Extensions/ArrayExtensions';
+import { logDeprecationExternal } from '../../Utilities/logDeprecation';
 export function isAutoRowGroupColumn(columnId) {
     // put this here as there might be other indicators we are not aware of
     // perhaps with non auto groups ?
@@ -369,40 +370,22 @@ export class ColumnApiImpl extends ApiBase {
             return this.getColumnWithColumnId(n);
         });
     }
-    updateColumnConfiguration(columnConfig) {
-        const columnExists = this.doesColumnExist(columnConfig.colId);
-        if (!columnExists) {
-            this.logWarn(`Column with id ${columnConfig.colId} does not exist, could NOT update configuration`);
-            return;
-        }
-        const columnState = columnConfig;
-        const agGridApi = this.adaptable.agGridAdapter.getAgGridApi();
-        agGridApi.applyColumnState({
-            state: [columnState],
-        });
-    }
-    updateColumnConfigurations(columnConfigs) {
-        const existingColumnConfigs = columnConfigs.filter((cc) => this.doesColumnExist(cc.colId));
-        const notExistingColumnIds = columnConfigs
-            .filter((cc) => !this.doesColumnExist(cc.colId))
-            .map((cc) => cc.colId);
-        notExistingColumnIds.forEach((colId) => {
-            this.logWarn(`Column with id ${colId} does not exist, could NOT update configuration`);
-        });
-        const columnStates = existingColumnConfigs;
-        const agGridApi = this.adaptable.agGridAdapter.getAgGridApi();
-        agGridApi.applyColumnState({
-            state: columnStates,
-        });
-    }
-    setColumnDefinitions(columnDefinitions) {
-        const agGridApi = this.adaptable.agGridAdapter.getAgGridApi();
-        agGridApi.setGridOption('columnDefs', columnDefinitions);
-    }
     getDistinctDisplayValuesForColumn(columnId) {
         return this.getAdaptableApi().gridApi.internalApi.getDistinctDisplayValuesForColumn(columnId);
     }
     setColumnCaption(columnId, caption) {
         return this.getAdaptableApi().layoutApi.setColumnCaption(columnId, caption);
     }
+    updateColumnConfiguration(columnConfig) {
+        logDeprecationExternal(this.adaptable.logger, 'ColumnApi', 'updateColumnConfiguration', 'GridApi', 'updateAgGridColumnState');
+        this.getGridApi().updateAgGridColumnState(columnConfig);
+    }
+    updateColumnConfigurations(columnConfigs) {
+        logDeprecationExternal(this.adaptable.logger, 'ColumnApi', 'updateColumnConfigurations', 'GridApi', 'updateAgGridColumnStates');
+        this.getGridApi().updateAgGridColumnStates(columnConfigs);
+    }
+    setColumnDefinitions(columnDefinitions) {
+        logDeprecationExternal(this.adaptable.logger, 'ColumnApi', 'setColumnDefinitions', 'GridApi', 'setColumnDefinitions');
+        this.getGridApi().setAgGridColumnDefinitions(columnDefinitions);
+    }
 }

package/src/Api/Implementation/DataChangeHistoryApiImpl.d.ts

@@ -1,12 +1,14 @@
 import { DataChangeHistoryApi } from '../DataChangeHistoryApi';
 import { ApiBase } from './ApiBase';
 import { CellDataChangedInfo } from '../../PredefinedConfig/Common/CellDataChangedInfo';
+import { GridCell } from '../../types';
 export declare class DataChangeHistoryApiImpl extends ApiBase implements DataChangeHistoryApi {
     getDataChangeHistoryMode(): 'ACTIVE' | 'INACTIVE' | 'SUSPENDED';
     activateDataChangeHistory(forceReset?: boolean): void;
     deactivateDataChangeHistory(): void;
     suspendDataChangeHistory(): void;
     getDataChangeHistoryLog(): CellDataChangedInfo[];
+    getDataChangeForGridCell(gridCell: GridCell): CellDataChangedInfo | undefined;
     addDataChangeHistoryEntry(dataChangeInfo: CellDataChangedInfo): void;
     undoDataChangeHistoryEntry(dataChangeInfo: CellDataChangedInfo): void;
     clearDataChangeHistoryEntry(dataChangeInfo: CellDataChangedInfo): void;

package/src/Api/Implementation/DataChangeHistoryApiImpl.js

@@ -48,6 +48,11 @@ export class DataChangeHistoryApiImpl extends ApiBase {
         const changeLog = (_a = this.getAdaptableState().System.DataChangeHistory.logs) !== null && _a !== void 0 ? _a : {};
         return Object.values(changeLog);
     }
+    getDataChangeForGridCell(gridCell) {
+        const allChanges = this.getDataChangeHistoryLog();
+        return allChanges.find((c) => c.primaryKeyValue == gridCell.primaryKeyValue &&
+            c.column.columnId == gridCell.column.columnId);
+    }
     addDataChangeHistoryEntry(dataChangeInfo) {
         const uniqueKey = this.getDataChangeHistoryKey(dataChangeInfo);
         this.dispatchAction(SystemDataChangeHistoryAdd(dataChangeInfo, uniqueKey));

package/src/Api/Implementation/GridApiImpl.d.ts

@@ -1,5 +1,5 @@
 import { ApiBase } from './ApiBase';
-import { GridApi } from '../GridApi';
+import { ColDefWithId, GridApi } from '../GridApi';
 import { GridState } from '../../PredefinedConfig/GridState';
 import { SelectedCellInfo } from '../../PredefinedConfig/Selection/SelectedCellInfo';
 import { SelectedRowInfo } from '../../PredefinedConfig/Selection/SelectedRowInfo';
@@ -8,7 +8,7 @@ import { ColumnSort } from '../../PredefinedConfig/Common/ColumnSort';
 import { DataUpdateConfig } from '../../PredefinedConfig/Common/DataUpdateConfig';
 import { CellHighlightInfo } from '../../PredefinedConfig/Common/CellHighlightInfo';
 import { RowHighlightInfo } from '../../PredefinedConfig/Common/RowHighlightInfo';
-import { Column, IRowNode, RowModelType } from '@ag-grid-community/core';
+import { ColDef, ColGroupDef, Column, ColumnState, IRowNode, RowModelType } from '@ag-grid-community/core';
 import { GridCellRange } from '../../PredefinedConfig/Selection/GridCellRange';
 import { CellDataChangedInfo } from '../../PredefinedConfig/Common/CellDataChangedInfo';
 import { RowsHighlightInfo } from '../../PredefinedConfig/Common/RowsHighlightInfo';
@@ -115,6 +115,8 @@ export declare class GridApiImpl extends ApiBase implements GridApi {
     unHighlightRows(primaryKeyValues: RowsHighlightInfo['primaryKeyValues']): void;
     unHighlightAllRows(): void;
     refreshCells(rowNodes: IRowNode[], columnIds: string[]): void;
+    refreshGridCell(gridCell: GridCell): void;
+    refreshGridCells(gridCells: GridCell[]): void;
     refreshColumn(columnId: string): void;
     refreshColumns(columnIds: string[]): void;
     refreshRowByPrimaryKey(primaryKey: any): void;
@@ -122,8 +124,10 @@ export declare class GridApiImpl extends ApiBase implements GridApi {
     refreshRowNodes(rowNodes: IRowNode[]): void;
     refreshGroupRowNodes(): void;
     isCellEditable(gridCell: GridCell): boolean;
+    isCellEdited(gridCell: GridCell): boolean;
     isEveryCellEditable(gridCells: GridCell[]): boolean;
     getRowCount(): number;
+    getVisibleRowCount(): number;
     getRowsInViewport(): IRowNode[];
     getColumnCount(): number;
     getVisibleColumnCount(): number;
@@ -135,4 +139,11 @@ export declare class GridApiImpl extends ApiBase implements GridApi {
     getAgGridRowModelType(): RowModelType;
     showTransposedView(transposeConfig?: TransposeConfig): void;
     getAllAgGridColumns(): Column<any>[];
+    updateAgGridColumnState(columnState: ColumnState): void;
+    updateAgGridColumnStates(columnStates: ColumnState[]): void;
+    setAgGridColumnDefinitions(columnDefinitions: (ColDef | ColGroupDef)[]): void;
+    updateAgGridColumnDefinition(columnDefinitionToBeUpdated: ColDefWithId): void;
+    updateAgGridColumnDefinitions(columnDefinitionsToBeUpdated: ColDefWithId[]): void;
+    removeAgGridColumnDefinition(columnId: string): void;
+    addAgGridColumnDefinition(newColumnDefinition: ColDefWithId): void;
 }

package/src/Api/Implementation/GridApiImpl.js

@@ -98,6 +98,7 @@ export class GridApiImpl extends ApiBase {
             return;
         }
         this.adaptable.setDataValue(cellUpdateRequest.newValue, abColumn, cellUpdateRequest.primaryKeyValue, rowNode);
+        this.refreshCells([rowNode], [abColumn.columnId]);
     }
     setCellValues(cellUpdateRequests) {
         cellUpdateRequests === null || cellUpdateRequests === void 0 ? void 0 : cellUpdateRequests.forEach((cellUpdateRequest) => this.setCellValue(cellUpdateRequest));
@@ -459,6 +460,14 @@ export class GridApiImpl extends ApiBase {
     refreshCells(rowNodes, columnIds) {
         this.adaptable.refreshCells(rowNodes, columnIds, true);
     }
+    refreshGridCell(gridCell) {
+        this.refreshCells([gridCell.rowNode], [gridCell.column.columnId]);
+    }
+    refreshGridCells(gridCells) {
+        gridCells.forEach((gc) => {
+            this.refreshGridCell(gc);
+        });
+    }
     refreshColumn(columnId) {
         this.adaptable.refreshCells(null, [columnId], true);
     }
@@ -491,7 +500,22 @@ export class GridApiImpl extends ApiBase {
         if (gridCell.column.readOnly) {
             return false;
         }
-        return this.adaptable.isCellEditable(gridCell.rowNode, this.adaptable.getAgGridColumnForColumnId(gridCell.column.columnId));
+        if (gridCell.rowNode && this.isSummaryNode(gridCell.rowNode)) {
+            return false;
+        }
+        const cellEditableFn = this.getEditOptions().isCellEditable;
+        if (cellEditableFn) {
+            const cellEditableContext = Object.assign({ gridCell }, this.getAdaptableApi().internalApi.buildBaseContext());
+            return cellEditableFn(cellEditableContext);
+        }
+        return true;
+    }
+    isCellEdited(gridCell) {
+        if (!gridCell) {
+            return false;
+        }
+        const cellDataChangedInfo = this.getDataChangeHistoryApi().getDataChangeForGridCell(gridCell);
+        return cellDataChangedInfo != null;
     }
     isEveryCellEditable(gridCells) {
         for (let gridCell of gridCells) {
@@ -504,6 +528,9 @@ export class GridApiImpl extends ApiBase {
     getRowCount() {
         return this.adaptable.getRowCount();
     }
+    getVisibleRowCount() {
+        return this.adaptable.getVisibleRowCount();
+    }
     getRowsInViewport() {
         return this.adaptable.getRowsInViewport();
     }
@@ -555,4 +582,90 @@ export class GridApiImpl extends ApiBase {
     getAllAgGridColumns() {
         return this.adaptable.getAllGridColumns();
     }
+    updateAgGridColumnState(columnState) {
+        const columnExists = this.getColumnApi().doesColumnExist(columnState.colId);
+        if (!columnExists) {
+            this.logWarn(`Column with id ${columnState.colId} does not exist, could NOT update configuration`);
+            return;
+        }
+        const agGridApi = this.adaptable.agGridAdapter.getAgGridApi();
+        agGridApi.applyColumnState({
+            state: [columnState],
+        });
+    }
+    updateAgGridColumnStates(columnStates) {
+        const existingColumnStates = columnStates.filter((cc) => this.getColumnApi().doesColumnExist(cc.colId));
+        const notExistingColumnIds = columnStates
+            .filter((cc) => !this.getColumnApi().doesColumnExist(cc.colId))
+            .map((cc) => cc.colId);
+        notExistingColumnIds.forEach((colId) => {
+            this.logWarn(`Column with id ${colId} does not exist, could NOT update configuration`);
+        });
+        const agGridApi = this.adaptable.agGridAdapter.getAgGridApi();
+        agGridApi.applyColumnState({
+            state: existingColumnStates,
+        });
+    }
+    setAgGridColumnDefinitions(columnDefinitions) {
+        const agGridApi = this.adaptable.agGridAdapter.getAgGridApi();
+        agGridApi.setGridOption('columnDefs', columnDefinitions);
+        this.adaptable.updateColumnModelAndRefreshGrid({ skipColDefsRefresh: true });
+    }
+    updateAgGridColumnDefinition(columnDefinitionToBeUpdated) {
+        const currentColDefs = [...this.adaptable.agGridAdapter.getAgGridApi().getColumnDefs()];
+        const columnId = columnDefinitionToBeUpdated.colId;
+        const doesColumnExist = this.getColumnApi().doesColumnExist(columnId);
+        if (!doesColumnExist) {
+            this.logWarn(`Column with id ${columnId} does not exist, will add it instead!`);
+            const newColDefs = [...currentColDefs, columnDefinitionToBeUpdated];
+            this.setAgGridColumnDefinitions(newColDefs);
+            return;
+        }
+        const updatedColDefs = this.adaptable.agGridAdapter.traverseColDefs(currentColDefs, (colDef) => {
+            return colDef.colId === columnId ? Object.assign(Object.assign({}, colDef), columnDefinitionToBeUpdated) : colDef;
+        });
+        this.setAgGridColumnDefinitions(updatedColDefs);
+    }
+    updateAgGridColumnDefinitions(columnDefinitionsToBeUpdated) {
+        const currentColDefs = [...this.adaptable.agGridAdapter.getAgGridApi().getColumnDefs()];
+        const updatedColDefs = this.adaptable.agGridAdapter.traverseColDefs(currentColDefs, (colDef) => {
+            const newColDef = newColumnDefinitions.find((c) => c.colId === colDef.colId);
+            return newColDef ? Object.assign(Object.assign({}, colDef), newColDef) : colDef;
+        });
+        // find out new columns which are not in the current column definitions
+        const currentColIds = [];
+        this.adaptable.agGridAdapter.traverseColDefs(currentColDefs, (colDef) => {
+            currentColIds.push(colDef.colId);
+            return colDef;
+        });
+        const newColumnDefinitions = columnDefinitionsToBeUpdated.filter((c) => !currentColIds.includes(c.colId));
+        if (newColumnDefinitions.length) {
+            this.logWarn(`Columns with ids ${newColumnDefinitions.map((c) => c.colId).join(', ')} do not exist, will add them instead!`);
+        }
+        this.setAgGridColumnDefinitions([...updatedColDefs, ...newColumnDefinitions]);
+    }
+    removeAgGridColumnDefinition(columnId) {
+        const doesColumnExist = this.getColumnApi().doesColumnExist(columnId);
+        if (!doesColumnExist) {
+            this.logWarn(`Column with id ${columnId} does not exist!`);
+            return;
+        }
+        const currentColDefs = this.adaptable.agGridAdapter.getAgGridApi().getColumnDefs();
+        const updatedColDefs = this.adaptable.agGridAdapter
+            .traverseColDefs(currentColDefs, (colDef) => {
+            return colDef.colId === columnId ? null : colDef;
+        })
+            .filter(Boolean);
+        this.setAgGridColumnDefinitions(updatedColDefs);
+    }
+    addAgGridColumnDefinition(newColumnDefinition) {
+        const currentColDefs = this.adaptable.agGridAdapter.getAgGridApi().getColumnDefs();
+        // just in case check of there is not already an existing column with the same id and eliminate it
+        const sanitizedColDefs = this.adaptable.agGridAdapter
+            .traverseColDefs(currentColDefs, (colDef) => {
+            return colDef.colId === newColumnDefinition.colId ? null : colDef;
+        })
+            .filter(Boolean);
+        this.setAgGridColumnDefinitions([...sanitizedColDefs, newColumnDefinition]);
+    }
 }

package/src/Api/Implementation/UserInterfaceApiImpl.d.ts

@@ -26,6 +26,7 @@ export declare class UserInterfaceApiImpl extends ApiBase implements UserInterfa
     getEditLookUpItemForColumn(column: AdaptableColumn): EditLookUpPermittedValues | undefined;
     getEditLookUpValuesForEditLookUpItem(editLookUpItem: EditLookUpPermittedValues, gridCell: GridCell): any[] | undefined;
     getEditableCellStyle(): AdaptableStyle | undefined;
+    getEditedCellStyle(): AdaptableStyle | undefined;
     getReadOnlyCellStyle(): AdaptableStyle | undefined;
     getAdaptableObjectTags(): AdaptableObjectTag[] | undefined;
     getCustomIconDefinition(iconName: string): import("../../types").AdaptableIcon | import("../../types").CustomIcon;

package/src/Api/Implementation/UserInterfaceApiImpl.js

@@ -142,6 +142,9 @@ export class UserInterfaceApiImpl extends ApiBase {
     getEditableCellStyle() {
         return this.getUserInterfaceOptions().editableCellStyle;
     }
+    getEditedCellStyle() {
+        return this.getUserInterfaceOptions().editedCellStyle;
+    }
     getReadOnlyCellStyle() {
         return this.getUserInterfaceOptions().readOnlyCellStyle;
     }

package/src/Api/Internal/ActionRowInternalApi.d.ts

@@ -18,7 +18,7 @@ export declare class ActionRowInternalApi extends ApiBase {
     private buidActionRowButtons;
     private prepareCreateData;
     private prepareEditData;
-    private isColumnEditable;
+    private isCellEditable;
     private buildFormField;
     private getFormFieldLabel;
     private buildFormFieldLabelContext;

package/src/Api/Internal/ActionRowInternalApi.js

@@ -49,7 +49,7 @@ export class ActionRowInternalApi extends ApiBase {
             .columnApi.getColumns()
             .filter((column) => {
             // if there is NO rowNode, do NOT display the non-editable fields as they will be empty
-            return !!rowNode || this.isColumnEditable(column, rowNode);
+            return !!rowNode || this.isCellEditable(column, rowNode);
         })
             .filter((column) => !this.getAdaptableApi().columnApi.internalApi.isActionRowButtonColumn(column.columnId) &&
             this.showColumnInActionRowForm(column, actionRowType));
@@ -116,21 +116,23 @@ export class ActionRowInternalApi extends ApiBase {
         dataToSave[this.getOptions().primaryKey] = pkValue;
         return dataToSave;
     }
-    isColumnEditable(column, rowNode) {
-        return rowNode
-            ? this.adaptableInstance.isCellEditable(rowNode, this.adaptableInstance.getAgGridColumnForColumnId(column.columnId))
-            : !column.readOnly;
+    isCellEditable(column, rowNode) {
+        if (!rowNode) {
+            return !column.readOnly;
+        }
+        const gridCell = this.getAdaptableApi().gridApi.getGridCellFromRowNode(rowNode, column.columnId);
+        return this.getAdaptableApi().gridApi.isCellEditable(gridCell);
     }
     buildFormField(type, column, rowNode) {
-        const isColumnEditable = this.isColumnEditable(column, rowNode);
+        const isCellEditable = this.isCellEditable(column, rowNode);
         const fieldValueOptions = this.getFieldValueOptions(column, rowNode);
-        const fieldType = isColumnEditable
+        const fieldType = isCellEditable
             ? !!(fieldValueOptions === null || fieldValueOptions === void 0 ? void 0 : fieldValueOptions.length)
                 ? 'select'
                 : this.getFieldTypeFromColumnType(column)
             : 'textOutput';
         const defaultValue = rowNode
-            ? isColumnEditable
+            ? isCellEditable
                 ? this.getAdaptableApi().gridApi.getRawValueFromRowNode(rowNode, column.columnId)
                 : this.getAdaptableApi().gridApi.getDisplayValueFromRowNode(rowNode, column.columnId)
             : null;

package/src/Api/Internal/GridFilterInternalApi.js

@@ -14,6 +14,9 @@ export class GridFilterInternalApi extends ApiBase {
      * Compares to Grid Filter to see if they are identical
      */
     isGridFilterDifferent(oldFilter, newFilter) {
-        return (oldFilter === null || oldFilter === void 0 ? void 0 : oldFilter.Expression) === (newFilter === null || newFilter === void 0 ? void 0 : newFilter.Expression);
+        if (oldFilter == undefined && newFilter == undefined) {
+            return false;
+        }
+        return (oldFilter === null || oldFilter === void 0 ? void 0 : oldFilter.Expression) !== (newFilter === null || newFilter === void 0 ? void 0 : newFilter.Expression);
     }
 }