@adaptabletools/adaptable 11.0.9 → 11.1.1-canary.1

package/src/Api/Implementation/AlertApiImpl.js

@@ -9,6 +9,7 @@ const ApiBase_1 = require("./ApiBase");
 const LoggingHelper_1 = require("../../Utilities/Helpers/LoggingHelper");
 const ModuleConstants = tslib_1.__importStar(require("../../Utilities/Constants/ModuleConstants"));
 const ObjectFactory_1 = tslib_1.__importDefault(require("../../Utilities/ObjectFactory"));
+const AdaptableAlert_1 = require("../../PredefinedConfig/Common/AdaptableAlert");
 const AdaptableQuery_1 = require("../../PredefinedConfig/Common/AdaptableQuery");
 class AlertApiImpl extends ApiBase_1.ApiBase {
     getAlertState() {
@@ -61,22 +62,24 @@ class AlertApiImpl extends ApiBase_1.ApiBase {
                 buttonOnClick === null || buttonOnClick === void 0 ? void 0 : buttonOnClick.handler(button, context);
                 this.adaptable.api.alertApi.executeAlertAction(action, {
                     alertDefinition: context.alert.alertDefinition,
-                    dataChangedInfo: context.alert.dataChangedInfo,
+                    cellDataChangedInfo: AdaptableAlert_1.isAdaptableCellChangedAlert(context.alert)
+                        ? context.alert.cellDataChangedInfo
+                        : null,
+                    gridDataChangedInfo: AdaptableAlert_1.isAdaptableRowChangedAlert(context.alert)
+                        ? context.alert.gridDataChangedInfo
+                        : null,
                     formData: context.formData,
                 });
             });
         }
     }
     executeAlertAction(actionName, details) {
-        var _a;
-        const { alertDefinition, dataChangedInfo } = details;
-        if (!dataChangedInfo) {
-            return;
-        }
-        if (actionName === 'highlight-cell') {
-            const highhlightType = (_a = alertDefinition.MessageType) !== null && _a !== void 0 ? _a : 'Info';
+        const { alertDefinition, cellDataChangedInfo: cellDataChangedInfo, gridDataChangedInfo, } = details;
+        const getBackgroundColor = (alertDefinition) => {
+            var _a;
+            const highlightType = (_a = alertDefinition.MessageType) !== null && _a !== void 0 ? _a : 'Info';
             let backgroundColor = '';
-            switch (highhlightType) {
+            switch (highlightType) {
                 case 'Error':
                     backgroundColor = 'var(--ab-color-error)';
                     break;
@@ -89,48 +92,59 @@ class AlertApiImpl extends ApiBase_1.ApiBase {
                 case 'Warning':
                     backgroundColor = 'var(--ab-color-warn)';
             }
+            return backgroundColor;
+        };
+        if (actionName === 'highlight-cell' && cellDataChangedInfo) {
+            const backgroundColor = getBackgroundColor(alertDefinition);
             this.adaptable.api.gridApi.highlightCell({
-                columnId: dataChangedInfo.column.columnId,
-                primaryKeyValue: dataChangedInfo.primaryKeyValue,
+                columnId: cellDataChangedInfo.column.columnId,
+                primaryKeyValue: cellDataChangedInfo.primaryKeyValue,
                 highlightStyle: {
                     BackColor: backgroundColor,
                 },
                 timeout: this.getAlertOptions().cellHighlightDuration,
             });
-            return;
         }
-        if (actionName === 'jump-to-cell') {
-            this.adaptable.api.gridApi.jumpToCell(dataChangedInfo.primaryKeyValue, dataChangedInfo.column.columnId);
-            return;
+        if (actionName === 'highlight-row' &&
+            gridDataChangedInfo &&
+            // no sense to highlight a deleted(non-existing) row
+            (gridDataChangedInfo === null || gridDataChangedInfo === void 0 ? void 0 : gridDataChangedInfo.rowTrigger) !== 'Delete') {
+            const backgroundColor = getBackgroundColor(alertDefinition);
+            const primaryKeyValues = this.adaptable.api.gridApi.getPrimaryKeyValuesForRowNodes(gridDataChangedInfo.rowNodes);
+            const rowsHighlightInfo = {
+                primaryKeyValues,
+                highlightStyle: {
+                    BackColor: backgroundColor,
+                },
+                timeout: this.getAlertOptions().cellHighlightDuration,
+            };
+            this.adaptable.api.gridApi.highlightRows(rowsHighlightInfo);
+        }
+        if (actionName === 'jump-to-cell' && cellDataChangedInfo) {
+            this.adaptable.api.gridApi.jumpToCell(cellDataChangedInfo.primaryKeyValue, cellDataChangedInfo.column.columnId);
+        }
+        if (actionName === 'jump-to-row' &&
+            gridDataChangedInfo &&
+            // no sense to jump to a deleted(non-existing) row
+            (gridDataChangedInfo === null || gridDataChangedInfo === void 0 ? void 0 : gridDataChangedInfo.rowTrigger) !== 'Delete') {
+            const [firstRowNode] = gridDataChangedInfo.rowNodes;
+            const targetRowNodePrimaryKeyValue = this.adaptable.api.gridApi.getPrimaryKeyValueForRowNode(firstRowNode);
+            if (targetRowNodePrimaryKeyValue) {
+                this.adaptable.api.gridApi.jumpToRow(targetRowNodePrimaryKeyValue);
+            }
         }
-        if (actionName === 'jump-to-column') {
-            this.adaptable.api.gridApi.jumpToColumn(dataChangedInfo.column.columnId);
-            return;
+        if (actionName === 'jump-to-column' && cellDataChangedInfo) {
+            this.adaptable.api.gridApi.jumpToColumn(cellDataChangedInfo.column.columnId);
         }
         if (actionName === 'suspend') {
             this.adaptable.api.alertApi.suspendAlertDefinition(alertDefinition);
-            return;
-        }
-        if (actionName === 'jump-to-row') {
-            this.adaptable.api.gridApi.jumpToRow(dataChangedInfo.primaryKeyValue);
-            return;
-        }
-        if (actionName === 'undo') {
-            this.adaptable.api.gridApi.undoCellEdit(dataChangedInfo);
         }
-        // we no longer overwrite through an Alert Action
-        /*
-        if (actionName === 'overwrite' && formData && Object.keys(formData).length === 1) {
-          const value = formData[Object.keys(formData)[0]];
-          this.adaptable.api.gridApi.setCellValue(
-            dataChangedInfo.columnId,
-            value,
-            dataChangedInfo.primaryKeyValue
-          );
+        if (actionName === 'undo' && cellDataChangedInfo) {
+            this.adaptable.api.gridApi.undoCellEdit(cellDataChangedInfo);
         }
-        */
     }
     async displayAlert(alertToShow) {
+        var _a, _b;
         // 3 things we always do with an alert are:
         // 1. Dispatch the Alert (so it appears in the toolbar)
         this.addUidToAdaptableObject(alertToShow);
@@ -147,12 +161,16 @@ class AlertApiImpl extends ApiBase_1.ApiBase {
         if (alertToShow.alertDefinition && alertToShow.alertDefinition.AlertProperties != undefined) {
             const alertDefinition = alertToShow.alertDefinition;
             const alertProperties = alertDefinition.AlertProperties;
-            const dataChangedInfo = alertToShow.dataChangedInfo;
             // There are 4 possible other actions that could happen
+            // alertProperties.PreventEdit is handled separately, in the Adaptable.setupColumnValueSetter() function
             // 1. Show a Popup
             if (alertProperties.DisplayNotification && showPopup) {
                 this.dispatchAction(PopupRedux.PopupShowAlert(alertToShow));
             }
+            // 2. Log to console
+            if (alertProperties.LogToConsole) {
+                LoggingHelper_1.ConsoleLogByMessageType(alertToShow.header + ': ' + alertToShow.message, alertDefinition.MessageType);
+            }
             // 3. Show it in a Div (if one has been set)
             if (alertProperties.ShowInDiv) {
                 let alertDiv;
@@ -166,37 +184,46 @@ class AlertApiImpl extends ApiBase_1.ApiBase {
                     alertDiv.innerHTML = alertString;
                 }
             }
+            // 4.JumpToCell and 5.JumpToRow are exclusive, based on alertType!
             // 4: Jump to the Cell
-            if (alertProperties.JumpToCell && dataChangedInfo) {
-                this.adaptable.jumpToCell(dataChangedInfo.column.columnId, dataChangedInfo.rowNode);
+            if (alertProperties.JumpToCell &&
+                AdaptableAlert_1.isAdaptableCellChangedAlert(alertToShow) &&
+                alertToShow.cellDataChangedInfo) {
+                this.adaptable.jumpToCell(alertToShow.cellDataChangedInfo.column.columnId, alertToShow.cellDataChangedInfo.rowNode);
             }
-            // 5: Hight the cell - though that is taken care of in the Style Service
-            if (alertProperties.HighlightCell && dataChangedInfo) {
-                let alertNode = dataChangedInfo.rowNode;
-                if (!alertNode) {
-                    alertNode = this.adaptable.getRowNodeForPrimaryKey(dataChangedInfo.primaryKeyValue);
-                }
-                if (alertNode) {
-                    this.adaptable.api.gridApi.refreshCells([alertNode], [dataChangedInfo.column.columnId]);
-                    setTimeout(() => {
-                        this.dispatchAction(SystemRedux.SystemAlertRemoveHighlight(alertToShow));
-                    }, this.adaptable.adaptableOptions.alertOptions.cellHighlightDuration);
+            // 5: Jump to the Row
+            else if (alertProperties.JumpToRow &&
+                AdaptableAlert_1.isAdaptableRowChangedAlert(alertToShow) &&
+                ((_a = alertToShow.gridDataChangedInfo) === null || _a === void 0 ? void 0 : _a.rowTrigger) === 'Add') {
+                const [firstRowNode] = alertToShow.gridDataChangedInfo.rowNodes;
+                if (firstRowNode) {
+                    this.adaptable.jumpToRow(firstRowNode);
                 }
             }
-            if (alertProperties.HighlightRow && dataChangedInfo) {
-                let alertNode = dataChangedInfo.rowNode;
+            // 6.HighlightCell and 7.HighlightRow are exclusive, based on alertType!
+            // 6: Highlight the cell - we just refresh the cells to trigger a re-evaluation of the Adaptable.setupColumn[Style/Class]
+            if (alertProperties.HighlightCell &&
+                AdaptableAlert_1.isAdaptableCellChangedAlert(alertToShow) &&
+                alertToShow.cellDataChangedInfo) {
+                let alertNode = alertToShow.cellDataChangedInfo.rowNode;
                 if (!alertNode) {
-                    alertNode = this.adaptable.getRowNodeForPrimaryKey(dataChangedInfo.primaryKeyValue);
+                    alertNode = this.adaptable.getRowNodeForPrimaryKey(alertToShow.cellDataChangedInfo.primaryKeyValue);
                 }
                 if (alertNode) {
-                    this.adaptable.api.gridApi.refreshRowNode(alertNode);
+                    this.adaptable.api.gridApi.refreshCells([alertNode], [alertToShow.cellDataChangedInfo.column.columnId]);
                     setTimeout(() => {
                         this.dispatchAction(SystemRedux.SystemAlertRemoveHighlight(alertToShow));
                     }, this.adaptable.adaptableOptions.alertOptions.cellHighlightDuration);
                 }
             }
-            if (alertProperties.LogToConsole) {
-                LoggingHelper_1.ConsoleLogByMessageType(alertToShow.header + ': ' + alertToShow.message, alertDefinition.MessageType);
+            // 7. Highlight the row - we just refresh the rows to trigger a re-evaluation of the Adaptable.setupColumn[Style/Class]
+            else if (alertProperties.HighlightRow &&
+                AdaptableAlert_1.isAdaptableRowChangedAlert(alertToShow) &&
+                ((_b = alertToShow.gridDataChangedInfo) === null || _b === void 0 ? void 0 : _b.rowTrigger) === 'Add') {
+                this.adaptable.api.gridApi.refreshRowNodes(alertToShow.gridDataChangedInfo.rowNodes);
+                setTimeout(() => {
+                    this.dispatchAction(SystemRedux.SystemAlertRemoveHighlight(alertToShow));
+                }, this.adaptable.adaptableOptions.alertOptions.cellHighlightDuration);
             }
         }
     }
@@ -212,7 +239,7 @@ class AlertApiImpl extends ApiBase_1.ApiBase {
     }
     showAlert(alertHeader, alertMessage, messageType, alertProperties) {
         const alertDefinition = ObjectFactory_1.default.CreateInternalAlertDefinitionForMessages(messageType, alertProperties);
-        let alertToShow = ObjectFactory_1.default.CreateAlert(alertHeader, alertMessage, alertDefinition);
+        let alertToShow = ObjectFactory_1.default.CreateGenericAlert(alertHeader, alertMessage, alertDefinition);
         this.displayAlert(alertToShow);
     }
     showAlertInfo(alertHeader, alertMessage, alertProperties) {
@@ -248,11 +275,11 @@ class AlertApiImpl extends ApiBase_1.ApiBase {
         this.dispatchAction(AlertRedux.AlertDefinitionUnSuspend(alertDefinition));
         return this.getAlertDefinitionById(alertDefinition.Uuid);
     }
-    getAlertDescription(alertDefinition, dataChangedInfo) {
+    getAlertDescription(alertDefinition, cellDataChangedInfo) {
         var _a;
         const alertMessageFunction = (_a = this.adaptable.adaptableOptions.alertOptions) === null || _a === void 0 ? void 0 : _a.alertMessageText;
         if (alertMessageFunction) {
-            const returnText = alertMessageFunction(alertDefinition, dataChangedInfo);
+            const returnText = alertMessageFunction(alertDefinition, cellDataChangedInfo);
             if (returnText) {
                 return returnText;
             }

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

@@ -5,4 +5,5 @@ export declare class BulkUpdateApiImpl extends ApiBase implements BulkUpdateApi
     getBulkUpdateValue(): string;
     showBulkUpdatePopup(): void;
     applyBulkUpdate(gridCells: GridCell[]): void;
+    setBulkUpdateValue(bulkUpdateValue: string): void;
 }

package/src/Api/Implementation/BulkUpdateApiImpl.js

@@ -5,6 +5,7 @@ const tslib_1 = require("tslib");
 const ApiBase_1 = require("./ApiBase");
 const ModuleConstants = tslib_1.__importStar(require("../../Utilities/Constants/ModuleConstants"));
 const BulkUpdateRedux = tslib_1.__importStar(require("../../Redux/ActionsReducers/BulkUpdateRedux"));
+const SystemRedux = tslib_1.__importStar(require("../../Redux/ActionsReducers/SystemRedux"));
 class BulkUpdateApiImpl extends ApiBase_1.ApiBase {
     getBulkUpdateValue() {
         return this.getAdaptableState().System.BulkUpdateValue;
@@ -15,5 +16,8 @@ class BulkUpdateApiImpl extends ApiBase_1.ApiBase {
     applyBulkUpdate(gridCells) {
         this.dispatchAction(BulkUpdateRedux.BulkUpdateApply(gridCells));
     }
+    setBulkUpdateValue(bulkUpdateValue) {
+        this.dispatchAction(SystemRedux.BulkUpdateChangeValue(bulkUpdateValue));
+    }
 }
 exports.BulkUpdateApiImpl = BulkUpdateApiImpl;

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

@@ -45,7 +45,7 @@ export declare class ConfigApiImpl extends ApiBase implements ConfigApi {
     getDescriptionForModule(module: AdaptableModule): string;
     getHelpPageForModule(module: AdaptableModule): string;
     getUserStateByStateKey(stateKey: AdaptableStateKey, returnJson?: boolean): ConfigState | string;
-    incrementUerStateRevision(stateKey: AdaptableStateKey): void;
+    incrementUserStateRevision(stateKey: AdaptableStateKey): void;
     getAlertState(returnJson?: boolean): AlertState;
     getApplicationState(returnJson?: boolean): ApplicationState;
     getCalculatedColumnState(returnJson?: boolean): CalculatedColumnState;

package/src/Api/Implementation/ConfigApiImpl.js

@@ -242,9 +242,14 @@ class ConfigApiImpl extends ApiBase_1.ApiBase {
                     : this.getAdaptableState().ToolPanel;
         }
     }
-    incrementUerStateRevision(stateKey) {
+    incrementUserStateRevision(stateKey) {
         let state = this.getUserStateByStateKey(stateKey);
-        state.Revision += 1;
+        if (typeof state.Revision === 'number') {
+            state.Revision += 1;
+        }
+        else {
+            state.Revision.Key += 1;
+        }
         // need to save it...
     }
     getAlertState(returnJson = false) {

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

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

package/src/Api/Implementation/EventApiImpl.js

@@ -10,7 +10,7 @@ class EventApiImpl extends ApiBase_1.ApiBase {
         this.on = (eventName, callback) => {
             let result;
             if (eventName === 'AdaptableReady') {
-                result = this.emitter.onIncludeFired(eventName, callback);
+                result = this.emitter.onIncludeFiredOnce(eventName, callback);
             }
             else {
                 result = this.emitter.on(eventName, callback);

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

@@ -2,7 +2,7 @@ import { ExportApi } from '../ExportApi';
 import { ExportState, Report, ReportData, ReportSchedule, SystemReportNames } from '../../PredefinedConfig/ExportState';
 import { ApiBase } from './ApiBase';
 import { AdaptableForm } from '../../PredefinedConfig/Common/AdaptableForm';
-import { DataChangedInfo } from '../../PredefinedConfig/Common/DataChangedInfo';
+import { CellDataChangedInfo } from '../../PredefinedConfig/Common/CellDataChangedInfo';
 import { CustomDestination, ExportButtonContext } from '../../AdaptableOptions/ExportOptions';
 import { ExportDestination } from '../../PredefinedConfig/Common/Enums';
 export declare class ExportApiImpl extends ApiBase implements ExportApi {
@@ -25,7 +25,7 @@ export declare class ExportApiImpl extends ApiBase implements ExportApi {
     showExportPopup(): void;
     editReport(report: Report): Report;
     editReports(reports: Report[]): Report[];
-    isDataChangeInReport(dataChangedInfo: DataChangedInfo, report: Report): boolean;
+    isDataChangeInReport(cellDataChangedInfo: CellDataChangedInfo, report: Report): boolean;
     exportVisualDataToExcel(): void;
     runCustomReport(customReportName: string): ReportData | undefined;
     getReportDataForReport(reportName: string): ReportData | undefined;

package/src/Api/Implementation/ExportApiImpl.js

@@ -95,7 +95,7 @@ class ExportApiImpl extends ApiBase_1.ApiBase {
         });
         return reports === null || reports === void 0 ? void 0 : reports.map((report) => this.getReportById(report.Uuid));
     }
-    isDataChangeInReport(dataChangedInfo, report) {
+    isDataChangeInReport(cellDataChangedInfo, report) {
         // for All Data Report any data change is true so get out asap
         if (report.Name == 'All Data') {
             return true;
@@ -111,22 +111,21 @@ class ExportApiImpl extends ApiBase_1.ApiBase {
                 break;
             case 'ScopeColumns':
                 // use the Scope object which will tell us if the Column is relevant
-                if (!this.adaptable.api.scopeApi.isColumnInScopeColumns(dataChangedInfo.column, report.Scope)) {
+                if (!this.adaptable.api.scopeApi.isColumnInScopeColumns(cellDataChangedInfo.column, report.Scope)) {
                     return false;
                 }
                 break;
             case 'SelectedColumns':
                 let selectedCellInfo = this.adaptable.api.gridApi.getSelectedCellInfo();
                 if (selectedCellInfo) {
-                    if (selectedCellInfo.columns.find((c) => c.columnId == dataChangedInfo.column.columnId) ==
-                        null) {
+                    if (selectedCellInfo.columns.find((c) => c.columnId == cellDataChangedInfo.column.columnId) == null) {
                         return false;
                     }
                 }
                 break;
             case 'VisibleColumns':
                 //  hope that visibile column property is updated whenever the layout changes... (need to check!)
-                if (!dataChangedInfo.column.visible) {
+                if (!cellDataChangedInfo.column.visible) {
                     return false;
                 }
                 break;
@@ -140,7 +139,7 @@ class ExportApiImpl extends ApiBase_1.ApiBase {
             case 'SelectedCellRows':
                 let selectedCellInfo = this.adaptable.api.gridApi.getSelectedCellInfo();
                 if (selectedCellInfo && selectedCellInfo.gridCells) {
-                    if (selectedCellInfo.gridCells.find((gc) => gc.primaryKeyValue == dataChangedInfo.primaryKeyValue)) {
+                    if (selectedCellInfo.gridCells.find((gc) => gc.primaryKeyValue == cellDataChangedInfo.primaryKeyValue)) {
                         return true;
                     }
                 }
@@ -148,13 +147,13 @@ class ExportApiImpl extends ApiBase_1.ApiBase {
             case 'SelectedRows':
                 let selectedRowInfo = this.adaptable.api.gridApi.getSelectedRowInfo();
                 if (selectedRowInfo && selectedRowInfo.gridRows) {
-                    if (selectedRowInfo.gridRows.find((gr) => gr.primaryKeyValue == dataChangedInfo.primaryKeyValue)) {
+                    if (selectedRowInfo.gridRows.find((gr) => gr.primaryKeyValue == cellDataChangedInfo.primaryKeyValue)) {
                         return true;
                     }
                 }
                 return false;
             case 'VisibleRows':
-                return this.adaptable.isRowNodeVisible(dataChangedInfo.rowNode);
+                return this.adaptable.isRowNodeVisible(cellDataChangedInfo.rowNode);
         }
     }
     exportVisualDataToExcel() {

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

@@ -1,7 +1,7 @@
 import { ApiBase } from './ApiBase';
 import { FreeTextColumnApi } from '../FreeTextColumnApi';
 import { FreeTextColumnState, FreeTextColumn, FreeTextStoredValue } from '../../PredefinedConfig/FreeTextColumnState';
-import { DataChangedInfo } from '../../PredefinedConfig/Common/DataChangedInfo';
+import { CellDataChangedInfo } from '../../PredefinedConfig/Common/CellDataChangedInfo';
 import { RowNode } from '@ag-grid-community/all-modules';
 export declare class FreeTextColumnApiImpl extends ApiBase implements FreeTextColumnApi {
     getFreeTextColumnState(): FreeTextColumnState;
@@ -16,6 +16,6 @@ export declare class FreeTextColumnApiImpl extends ApiBase implements FreeTextCo
     deleteFreeTextColumn(columnId: string): void;
     showFreeTextColumnPopup(): void;
     getFreeTextColumnValueFromRowNode(freeTextColumn: FreeTextColumn, rowNode: RowNode): any;
-    checkFreeTextColumnForDataChange(dataChangedInfo: DataChangedInfo): void;
+    checkFreeTextColumnForDataChange(cellDataChangedInfo: CellDataChangedInfo): void;
     getFreeTextColumnModuleReferences(freeTextColumn: FreeTextColumn): string[];
 }

package/src/Api/Implementation/FreeTextColumnApiImpl.js

@@ -94,20 +94,20 @@ class FreeTextColumnApiImpl extends ApiBase_1.ApiBase {
             return null;
         }
     }
-    checkFreeTextColumnForDataChange(dataChangedInfo) {
-        let freeTextColumn = this.getAllFreeTextColumn().find((fc) => fc.ColumnId == dataChangedInfo.column.columnId);
+    checkFreeTextColumnForDataChange(cellDataChangedInfo) {
+        let freeTextColumn = this.getAllFreeTextColumn().find((fc) => fc.ColumnId == cellDataChangedInfo.column.columnId);
         if (freeTextColumn) {
             let freeTextStoredValue = {
-                PrimaryKey: dataChangedInfo.primaryKeyValue,
-                FreeText: dataChangedInfo.newValue,
+                PrimaryKey: cellDataChangedInfo.primaryKeyValue,
+                FreeText: cellDataChangedInfo.newValue,
             };
             this.addEditFreeTextColumnStoredValue(freeTextColumn, freeTextStoredValue);
-            var colsToRefresh = [dataChangedInfo.column.columnId];
-            const refencedCalcColumns = this.adaptable.api.calculatedColumnApi.getCalculatedColumnsReferencingColumnId(dataChangedInfo.column.columnId);
+            var colsToRefresh = [cellDataChangedInfo.column.columnId];
+            const refencedCalcColumns = this.adaptable.api.calculatedColumnApi.getCalculatedColumnsReferencingColumnId(cellDataChangedInfo.column.columnId);
             refencedCalcColumns.forEach((calculatedColumn) => {
                 colsToRefresh.push(calculatedColumn.ColumnId);
             });
-            this.adaptable.refreshCells([dataChangedInfo.rowNode], colsToRefresh, false);
+            this.adaptable.refreshCells([cellDataChangedInfo.rowNode], colsToRefresh, false);
         }
     }
     getFreeTextColumnModuleReferences(freeTextColumn) {

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

@@ -6,11 +6,14 @@ import { SelectedRowInfo } from '../../PredefinedConfig/Selection/SelectedRowInf
 import { GridCell } from '../../PredefinedConfig/Selection/GridCell';
 import { ColumnSort } from '../../PredefinedConfig/Common/ColumnSort';
 import { DataUpdateConfig } from '../../PredefinedConfig/Common/DataUpdateConfig';
-import { DataChangedInfo, AccessLevel, AdaptableModule } from '../../types';
 import { CellHighlightInfo } from '../../PredefinedConfig/Common/CellHighlightInfo';
 import { RowHighlightInfo } from '../../PredefinedConfig/Common/RowHighlightInfo';
 import { GridOptions, RowNode } from '@ag-grid-community/all-modules';
 import { GridCellRange } from '../../PredefinedConfig/Selection/GridCellRange';
+import { CellDataChangedInfo } from '../../PredefinedConfig/Common/CellDataChangedInfo';
+import { AdaptableModule } from '../../PredefinedConfig/Common/Types';
+import { RowsHighlightInfo } from '../../PredefinedConfig/Common/RowsHighlightInfo';
+import { AccessLevel } from '../../PredefinedConfig/Common/Entitlement';
 export declare class GridApiImpl extends ApiBase implements GridApi {
     getGridState(): GridState;
     setGridData(dataSource: any): void;
@@ -19,7 +22,7 @@ export declare class GridApiImpl extends ApiBase implements GridApi {
     loadGridData(dataSource: any): void;
     updateGridData(dataRows: any[], dataUpdateConfig?: DataUpdateConfig): Promise<RowNode[]>;
     addGridData(dataRows: any[], dataUpdateConfig?: DataUpdateConfig): Promise<RowNode[]>;
-    undoCellEdit(dataChangedInfo: DataChangedInfo): boolean;
+    undoCellEdit(cellDataChangedInfo: CellDataChangedInfo): boolean;
     deleteGridData(dataRows: any[], dataUpdateConfig?: DataUpdateConfig): Promise<RowNode[]>;
     setCellValue(columnId: string, newValue: any, primaryKeyValue: any): void;
     setCellsValue(gridCells: {
@@ -64,6 +67,7 @@ export declare class GridApiImpl extends ApiBase implements GridApi {
     getRowNodesForPrimaryKeys(primaryKeyValues: any[]): RowNode[];
     getRowNodeForPrimaryKey(primaryKeyValue: any): RowNode;
     getPrimaryKeyValueForRowNode(rowNode: RowNode): any;
+    getPrimaryKeyValuesForRowNodes(rowNodes: RowNode[]): any[];
     setRowGroupColumns(columnIds: string[]): void;
     clearRowGroupColumns(): void;
     expandAllRowGroups(): void;
@@ -78,7 +82,7 @@ export declare class GridApiImpl extends ApiBase implements GridApi {
     isQuickFilterAvailable(): boolean;
     redrawGrid(): void;
     fireSearchChangedEvent(searchChangedTrigger: 'DataSource' | 'CurrentQuery' | 'Filter' | 'DataChange' | 'Sort'): void;
-    fireCellChangedEvent(dataChangedInfo: DataChangedInfo): void;
+    fireCellChangedEvent(cellDataChangedInfo: CellDataChangedInfo): void;
     fireGridDataChangedEvent(dataRows: any[], rowNodes: RowNode[], rowTrigger: 'Add' | 'Edit' | 'Delete'): void;
     jumpToRow(primaryKeyValue: any): void;
     jumpToColumn(columnId: string): void;
@@ -87,14 +91,18 @@ export declare class GridApiImpl extends ApiBase implements GridApi {
     unHighlightCell(primaryKeyValue: CellHighlightInfo['primaryKeyValue'], columnId: CellHighlightInfo['columnId']): void;
     unHighlightAllCells(): void;
     highlightRow(rowHighlightInfo: RowHighlightInfo): void;
+    highlightRows(rowHighlightInfos: RowsHighlightInfo): void;
     unHighlightRow(primaryKeyValue: RowHighlightInfo['primaryKeyValue']): void;
+    unHighlightRows(primaryKeyValues: RowsHighlightInfo['primaryKeyValues']): void;
     unHighlightAllRows(): void;
     refreshCells(rowNodes: RowNode[], columnIds: string[]): void;
     refreshRowByPrimaryKey(primaryKey: any): void;
     refreshRowNode(rowNode: RowNode): void;
+    refreshRowNodes(rowNodes: RowNode[]): void;
     areCellsEditable(gridCells: GridCell[]): boolean;
     getRowCount(): number;
     getVisibleRowCount(): number;
+    getRowsInViewport(): RowNode[];
     getColumnCount(): number;
     getVisibleColumnCount(): number;
     getEntitlementAccessLevelForModule(adaptableModule: AdaptableModule): AccessLevel;

package/src/Api/Implementation/GridApiImpl.js

@@ -32,10 +32,10 @@ class GridApiImpl extends ApiBase_1.ApiBase {
         this.fireGridDataChangedEvent(dataRows, rowNodes, 'Add');
         return rowNodes;
     }
-    undoCellEdit(dataChangedInfo) {
+    undoCellEdit(cellDataChangedInfo) {
         // for the reason of this hacky solution see the comments in DataService
-        this.adaptable.api.internalApi.getDataService().logUndoChange(dataChangedInfo);
-        this.setCellValue(dataChangedInfo.column.columnId, dataChangedInfo.oldValue, dataChangedInfo.primaryKeyValue);
+        this.adaptable.api.internalApi.getDataService().logUndoChange(cellDataChangedInfo);
+        this.setCellValue(cellDataChangedInfo.column.columnId, cellDataChangedInfo.oldValue, cellDataChangedInfo.primaryKeyValue);
         return true;
     }
     async deleteGridData(dataRows, dataUpdateConfig) {
@@ -220,6 +220,9 @@ class GridApiImpl extends ApiBase_1.ApiBase {
     getPrimaryKeyValueForRowNode(rowNode) {
         return this.adaptable.getPrimaryKeyValueFromRowNode(rowNode);
     }
+    getPrimaryKeyValuesForRowNodes(rowNodes) {
+        return rowNodes.map((rowNode) => this.getPrimaryKeyValueForRowNode(rowNode));
+    }
     setRowGroupColumns(columnIds) {
         this.adaptable.setRowGroupColumns(columnIds);
     }
@@ -273,21 +276,22 @@ class GridApiImpl extends ApiBase_1.ApiBase {
             this.adaptable.api.eventApi.emit('SearchChanged', searchChangedInfo);
         }
     }
-    fireCellChangedEvent(dataChangedInfo) {
+    fireCellChangedEvent(cellDataChangedInfo) {
         if (this.adaptable.isInitialised) {
             const cellChangedInfo = {
                 adaptableApi: this.adaptable.api,
-                cellChange: dataChangedInfo,
+                cellChange: cellDataChangedInfo,
             };
             this.adaptable.api.eventApi.emit('CellChanged', cellChangedInfo);
         }
     }
-    fireGridDataChangedEvent(dataRows, rowNodes, rowTrigger) {
+    fireGridDataChangedEvent(dataRows, rowNodes = [], rowTrigger) {
         if (this.adaptable.isInitialised) {
             const gridDataChangedInfo = {
+                changedAt: Date.now(),
                 adaptableApi: this.adaptable.api,
-                rowTrigger: rowTrigger,
-                dataRows: dataRows,
+                rowTrigger,
+                dataRows,
                 rowNodes,
             };
             this.adaptable.api.eventApi.emit('GridDataChanged', gridDataChangedInfo);
@@ -326,9 +330,20 @@ class GridApiImpl extends ApiBase_1.ApiBase {
             }, rowHighlightInfo.timeout);
         }
     }
+    highlightRows(rowHighlightInfos) {
+        this.dispatchAction(SystemRedux_1.SystemHighlightRowsAdd(rowHighlightInfos));
+        if (rowHighlightInfos.timeout) {
+            setTimeout(() => {
+                this.unHighlightRows(rowHighlightInfos.primaryKeyValues);
+            }, rowHighlightInfos.timeout);
+        }
+    }
     unHighlightRow(primaryKeyValue) {
         this.dispatchAction(SystemRedux_1.SystemHighlightRowDelete(primaryKeyValue));
     }
+    unHighlightRows(primaryKeyValues) {
+        this.dispatchAction(SystemRedux_1.SystemHighlightRowsDelete(primaryKeyValues));
+    }
     unHighlightAllRows() {
         this.dispatchAction(SystemRedux_1.SystemHighlightRowDeleteAll());
     }
@@ -342,6 +357,9 @@ class GridApiImpl extends ApiBase_1.ApiBase {
     refreshRowNode(rowNode) {
         this.adaptable.redrawRow(rowNode);
     }
+    refreshRowNodes(rowNodes) {
+        this.adaptable.redrawRows(rowNodes);
+    }
     areCellsEditable(gridCells) {
         for (let gridCell of gridCells) {
             if (!gridCell.column) {
@@ -364,6 +382,9 @@ class GridApiImpl extends ApiBase_1.ApiBase {
     getVisibleRowCount() {
         return this.adaptable.getVisibleRowCount();
     }
+    getRowsInViewport() {
+        return this.adaptable.getRowsInViewport();
+    }
     getColumnCount() {
         return this.adaptable.getColumnCount();
     }