@adaptabletools/adaptable 11.1.1-canary.0 → 11.1.1-canary.1

package/src/Utilities/Services/DataService.js

@@ -20,11 +20,11 @@ class DataService {
         this.undoChangeLog = new Map();
         this.undoChangeTimers = new Map();
     }
-    CreateDataChangedEvent(dataChangedInfo) {
-        if (dataChangedInfo.newValue != dataChangedInfo.oldValue) {
-            this.emitter.emitSync('DataChanged', dataChangedInfo);
-            this.adaptable.api.gridApi.fireCellChangedEvent(dataChangedInfo);
-            this.logDataChange(dataChangedInfo);
+    CreateDataChangedEvent(cellDataChangedInfo) {
+        if (cellDataChangedInfo.newValue != cellDataChangedInfo.oldValue) {
+            this.emitter.emitSync('CellDataChanged', cellDataChangedInfo);
+            this.adaptable.api.gridApi.fireCellChangedEvent(cellDataChangedInfo);
+            this.logDataChange(cellDataChangedInfo);
         }
     }
     // we need this temporary "shared memory" because the value change and the AG Grid cellChanged event are asynchronous
@@ -69,16 +69,18 @@ class DataService {
             newValue,
         });
     }
-    logDataChange(dataChangedInfo) {
-        const dataChangeLogEntry = this.extractDataChangeLogEntry(dataChangedInfo);
+    logDataChange(cellDataChangedInfo) {
+        const dataChangeLogEntry = this.extractDataChangeLogEntry(cellDataChangedInfo);
         this.dataChangeLogSubject$.next(dataChangeLogEntry);
     }
-    extractDataChangeLogEntry(dataChangedInfo) {
+    extractDataChangeLogEntry(cellDataChangedInfo) {
         // create rowData snapshot
-        const rowData = dataChangedInfo.rowData ? Helper_1.default.cloneObject(dataChangedInfo.rowData) : null;
+        const rowData = cellDataChangedInfo.rowData
+            ? Helper_1.default.cloneObject(cellDataChangedInfo.rowData)
+            : null;
         // strip down rowNode properties as it is pretty "heavy" on the memory
         const rowNode = rowData ? { data: rowData } : null;
-        return Object.assign(Object.assign({}, dataChangedInfo), { rowNode,
+        return Object.assign(Object.assign({}, cellDataChangedInfo), { rowNode,
             rowData });
     }
 }

package/src/Utilities/Services/Interface/IAlertService.d.ts

@@ -1,10 +1,10 @@
 import { AlertDefinition } from '../../../PredefinedConfig/AlertState';
-import { DataChangedInfo } from '../../../PredefinedConfig/Common/DataChangedInfo';
+import { CellDataChangedInfo } from '../../../PredefinedConfig/Common/CellDataChangedInfo';
 import { IAdaptableService } from './IAdaptableService';
 export declare type ReactiveAlertInfo = {
     alertDefinition: AlertDefinition;
     type: 'alert';
-    dataChangeLogEntry: DataChangedInfo;
+    dataChangeLogEntry: CellDataChangedInfo;
 };
 export interface IAlertService extends IAdaptableService {
     createReactiveAlert(alertDefinition: AlertDefinition): void;

package/src/Utilities/Services/Interface/IDataService.d.ts

@@ -1,10 +1,10 @@
-import { DataChangedInfo } from '../../../PredefinedConfig/Common/DataChangedInfo';
+import { CellDataChangedInfo } from '../../../PredefinedConfig/Common/CellDataChangedInfo';
 import { Observable } from 'rxjs';
 import { IAdaptableService } from './IAdaptableService';
 export interface IDataService extends IAdaptableService {
-    CreateDataChangedEvent(dataChangedInfo: DataChangedInfo): void;
-    on(eventName: 'DataChanged', callback: (dataChangedInfo: DataChangedInfo) => void): () => void;
-    readonly dataChangeLog$: Observable<DataChangedInfo>;
-    logUndoChange(undoChange: DataChangedInfo): void;
-    extractUndoChange(undoChange: DataChangedInfo): DataChangedInfo | undefined;
+    CreateDataChangedEvent(cellDataChangedInfo: CellDataChangedInfo): void;
+    on(eventName: 'CellDataChanged', callback: (cellDataChangedInfo: CellDataChangedInfo) => void): () => void;
+    readonly dataChangeLog$: Observable<CellDataChangedInfo>;
+    logUndoChange(undoChange: CellDataChangedInfo): void;
+    extractUndoChange(undoChange: CellDataChangedInfo): CellDataChangedInfo | undefined;
 }

package/src/Utilities/Services/Interface/IQueryLanguageService.d.ts

@@ -1,15 +1,15 @@
 import { Observable } from 'rxjs';
 import { IAdaptableService } from './IAdaptableService';
 import { RowNode } from '@ag-grid-community/all-modules';
-import { DataChangedInfo } from '../../../PredefinedConfig/Common/DataChangedInfo';
+import { CellDataChangedInfo } from '../../../PredefinedConfig/Common/CellDataChangedInfo';
 import { AdaptableModule } from '../../../PredefinedConfig/Common/Types';
 import { AggregationParameter } from '../../ExpressionFunctions/aggregatedScalarExpressionFunctions';
 import { ModuleExpressionFunctions } from '../../../AdaptableOptions/AdaptableQLOptions';
 export interface IQueryLanguageService extends IAdaptableService {
     evaluateBooleanExpression(expression: string, module: AdaptableModule, rowNode: RowNode): boolean;
     evaluateScalarExpression(expression: string, module: AdaptableModule, rowNode: RowNode): any;
-    evaluateObservableExpression(expression: string, module: AdaptableModule): Observable<DataChangedInfo>;
-    evaluateAggregatedBooleanExpression(expression: string, module: AdaptableModule): Observable<DataChangedInfo>;
+    evaluateObservableExpression(expression: string, module: AdaptableModule): Observable<CellDataChangedInfo>;
+    evaluateAggregatedBooleanExpression(expression: string, module: AdaptableModule): Observable<CellDataChangedInfo>;
     evaluateAggregatedScalarExpression(expression: string, module: AdaptableModule): AggregationParameter;
     validateBoolean(expression: string, module: AdaptableModule, config?: {
         force?: boolean;

package/src/Utilities/Services/Interface/IValidationService.d.ts

@@ -1,10 +1,10 @@
-import { DataChangedInfo } from '../../../PredefinedConfig/Common/DataChangedInfo';
+import { CellDataChangedInfo } from '../../../PredefinedConfig/Common/CellDataChangedInfo';
 import { AlertDefinition } from '../../../PredefinedConfig/AlertState';
 import { IAdaptableService } from './IAdaptableService';
 export interface IValidationService extends IAdaptableService {
-    getValidationRulesForDataChange(dataChangedInfo: DataChangedInfo): AlertDefinition[];
-    performValidation(dataChangedInfo: DataChangedInfo): boolean;
-    performServerValidation(dataChangedInfo: DataChangedInfo, config: {
+    getValidationRulesForDataChange(cellDataChangedInfo: CellDataChangedInfo): AlertDefinition[];
+    performValidation(cellDataChangedInfo: CellDataChangedInfo): boolean;
+    performServerValidation(cellDataChangedInfo: CellDataChangedInfo, config: {
         onServerValidationCompleted: () => void;
     }): () => boolean;
     createValidationDescription(alertDefinition: AlertDefinition): string;

package/src/Utilities/Services/QueryLanguageService.d.ts

@@ -1,7 +1,7 @@
 import { IQueryLanguageService } from './Interface/IQueryLanguageService';
 import { IAdaptable } from '../../AdaptableInterfaces/IAdaptable';
 import { Observable } from 'rxjs';
-import { DataChangedInfo } from '../../PredefinedConfig/Common/DataChangedInfo';
+import { CellDataChangedInfo } from '../../PredefinedConfig/Common/CellDataChangedInfo';
 import { RowNode } from '@ag-grid-community/all-modules';
 import { AdaptableModule } from '../../PredefinedConfig/Common/Types';
 import { ModuleExpressionFunctions } from '../../AdaptableOptions/AdaptableQLOptions';
@@ -17,8 +17,8 @@ export declare class QueryLanguageService implements IQueryLanguageService {
     evaluateBooleanExpression(expression: string, module: AdaptableModule, rowNode: any): any;
     evaluateScalarExpression(expression: string, module: AdaptableModule, rowNode: RowNode): any;
     evaluateAggregatedScalarExpression(expression: string, module: AdaptableModule): AggregationParameter;
-    evaluateObservableExpression(reactiveExpression: string, module: AdaptableModule): Observable<DataChangedInfo>;
-    evaluateAggregatedBooleanExpression(aggregationExpression: string, module: AdaptableModule): Observable<DataChangedInfo>;
+    evaluateObservableExpression(reactiveExpression: string, module: AdaptableModule): Observable<CellDataChangedInfo>;
+    evaluateAggregatedBooleanExpression(aggregationExpression: string, module: AdaptableModule): Observable<CellDataChangedInfo>;
     validateBoolean(expressionInput: string, module: AdaptableModule, config?: {
         force?: boolean;
     }): {

package/src/Utilities/Services/ValidationService.d.ts

@@ -1,14 +1,14 @@
 import { IAdaptable } from '../../AdaptableInterfaces/IAdaptable';
-import { DataChangedInfo } from '../../PredefinedConfig/Common/DataChangedInfo';
+import { CellDataChangedInfo } from '../../PredefinedConfig/Common/CellDataChangedInfo';
 import { IValidationService } from './Interface/IValidationService';
 import { AlertDefinition } from '../../PredefinedConfig/AlertState';
 export declare class ValidationService implements IValidationService {
     private adaptable;
     constructor(adaptable: IAdaptable);
-    getValidationRulesForDataChange(dataChangedInfo: DataChangedInfo): AlertDefinition[];
-    performValidation(dataChangedInfo: DataChangedInfo): boolean;
+    getValidationRulesForDataChange(cellDataChangedInfo: CellDataChangedInfo): AlertDefinition[];
+    performValidation(cellDataChangedInfo: CellDataChangedInfo): boolean;
     private IsAlertDefinitionTriggered;
-    performServerValidation(dataChangedInfo: DataChangedInfo, config: {
+    performServerValidation(cellDataChangedInfo: CellDataChangedInfo, config: {
         onServerValidationCompleted: () => void;
     }): () => boolean;
     createValidationDescription(alertDefinition: AlertDefinition): string;

package/src/Utilities/Services/ValidationService.js

@@ -11,28 +11,28 @@ class ValidationService {
         this.adaptable = adaptable;
     }
     // Not sure where to put this: was in the Module but might be better here until I can work out a way of having an event with a callback...
-    getValidationRulesForDataChange(dataChangedInfo) {
+    getValidationRulesForDataChange(cellDataChangedInfo) {
         // if the new value is the same as the old value then we can get out as we dont see it as an edit?
-        if (dataChangedInfo.oldValue == dataChangedInfo.newValue) {
+        if (cellDataChangedInfo.oldValue == cellDataChangedInfo.newValue) {
             return [];
         }
         let editingRules = this.adaptable.api.alertApi
             .getAlertDefinitionsWithPreventEdit()
-            .filter((v) => this.adaptable.api.scopeApi.isColumnInScope(dataChangedInfo.column, v.Scope));
+            .filter((v) => this.adaptable.api.scopeApi.isColumnInScope(cellDataChangedInfo.column, v.Scope));
         let failedValidations = [];
         if (ArrayExtensions_1.ArrayExtensions.IsNotEmpty(editingRules)) {
             editingRules.forEach((alertDefinition) => {
                 if (alertDefinition.Rule.BooleanExpression) {
-                    let isSatisfiedExpression = dataChangedInfo.rowNode != null &&
+                    let isSatisfiedExpression = cellDataChangedInfo.rowNode != null &&
                         this.adaptable.api.internalApi
                             .getQueryLanguageService()
-                            .evaluateBooleanExpression(alertDefinition.Rule.BooleanExpression, ModuleConstants_1.AlertModuleId, dataChangedInfo.rowNode);
+                            .evaluateBooleanExpression(alertDefinition.Rule.BooleanExpression, ModuleConstants_1.AlertModuleId, cellDataChangedInfo.rowNode);
                     if (isSatisfiedExpression) {
                         failedValidations.push(alertDefinition);
                     }
                 }
                 else {
-                    if (this.IsAlertDefinitionTriggered(alertDefinition, dataChangedInfo)) {
+                    if (this.IsAlertDefinitionTriggered(alertDefinition, cellDataChangedInfo)) {
                         failedValidations.push(alertDefinition);
                     }
                 }
@@ -40,15 +40,15 @@ class ValidationService {
         }
         return failedValidations;
     }
-    performValidation(dataChangedInfo) {
-        const failedRules = this.getValidationRulesForDataChange(dataChangedInfo);
+    performValidation(cellDataChangedInfo) {
+        const failedRules = this.getValidationRulesForDataChange(cellDataChangedInfo);
         if (failedRules.length > 0) {
             let alert = {
                 alertType: 'cellChanged',
                 header: 'Alert',
                 message: 'Perform Edit Alert Fired',
                 alertDefinition: failedRules[0],
-                dataChangedInfo: dataChangedInfo,
+                cellDataChangedInfo: cellDataChangedInfo,
             };
             this.adaptable.api.alertApi.publishAlertFiredEvent(alert);
             return false;
@@ -64,25 +64,25 @@ class ValidationService {
             column: dataChangedEvent.column,
         }, false);
     }
-    performServerValidation(dataChangedInfo, config) {
+    performServerValidation(cellDataChangedInfo, config) {
         return () => {
             this.adaptable.adaptableOptions.editOptions
-                .validateOnServer(dataChangedInfo)
+                .validateOnServer(cellDataChangedInfo)
                 .then((validationResult) => {
                 var _a, _b;
                 if (validationResult.NewValue === undefined) {
-                    validationResult.NewValue = dataChangedInfo.newValue;
+                    validationResult.NewValue = cellDataChangedInfo.newValue;
                 }
                 // If they have changed the return value then we should update the grid, log the function change
                 // otherwise the value will persist
-                if (validationResult.NewValue !== dataChangedInfo.newValue) {
-                    dataChangedInfo.newValue = validationResult.NewValue;
-                    // this.adaptable.setValue(dataChangedInfo, false);
-                    const row = (_a = dataChangedInfo.rowNode) === null || _a === void 0 ? void 0 : _a.data;
+                if (validationResult.NewValue !== cellDataChangedInfo.newValue) {
+                    cellDataChangedInfo.newValue = validationResult.NewValue;
+                    // this.adaptable.setValue(cellDataChangedInfo, false);
+                    const row = (_a = cellDataChangedInfo.rowNode) === null || _a === void 0 ? void 0 : _a.data;
                     if (!row) {
                         return;
                     }
-                    row[(_b = this.adaptable.api.columnApi.getAgGridColumnFieldForAdaptableColumn(dataChangedInfo.column.columnId)) !== null && _b !== void 0 ? _b : dataChangedInfo.column.columnId] = validationResult.NewValue;
+                    row[(_b = this.adaptable.api.columnApi.getAgGridColumnFieldForAdaptableColumn(cellDataChangedInfo.column.columnId)) !== null && _b !== void 0 ? _b : cellDataChangedInfo.column.columnId] = validationResult.NewValue;
                     this.adaptable.api.gridApi.updateGridData([row]);
                     if (StringExtensions_1.default.IsNotNullOrEmpty(validationResult.ValidationMessage) &&
                         this.adaptable.adaptableOptions.editOptions.displayServerValidationMessages) {

package/src/View/DataChangeHistory/DataChangeHistoryGrid.d.ts

@@ -1,9 +1,9 @@
 /// <reference types="react" />
-import { DataChangedInfo } from '../../PredefinedConfig/Common/DataChangedInfo';
+import { CellDataChangedInfo } from '../../PredefinedConfig/Common/CellDataChangedInfo';
 export interface DataChangeHistoryGridProps {
     adaptableContainerId: string;
     agGridContainerId: string;
-    changeHistoryLog: Record<string, DataChangedInfo>;
+    changeHistoryLog: Record<string, CellDataChangedInfo>;
     onUndoChange: (changeKey: string) => void;
 }
 export declare const DataChangeHistoryGrid: (props: DataChangeHistoryGridProps) => JSX.Element;

package/src/View/DataChangeHistory/DataChangeHistoryPopup.d.ts

@@ -1,11 +1,11 @@
 import { ModuleViewPopupProps } from '../Components/SharedProps/ModuleViewPopupProps';
 import * as React from 'react';
-import { DataChangedInfo } from '../../PredefinedConfig/Common/DataChangedInfo';
+import { CellDataChangedInfo } from '../../PredefinedConfig/Common/CellDataChangedInfo';
 import { SystemDataChangeHistoryDisableAction, SystemDataChangeHistoryEnableAction, SystemDataChangeHistoryResumeAction, SystemDataChangeHistorySuspendAction } from '../../Redux/ActionsReducers/SystemRedux';
 import { DataChangeHistoryMode } from '../../PredefinedConfig/SystemState';
 import { AdaptableApi } from '../../Api/AdaptableApi';
 interface DataChangeHistoryPopupProps extends ModuleViewPopupProps<DataChangeHistoryPopupComponent> {
-    changeHistoryLog: Record<string, DataChangedInfo>;
+    changeHistoryLog: Record<string, CellDataChangedInfo>;
     changeHistoryMode: DataChangeHistoryMode;
     activationTime: Date;
     suspensionTime: Date;

package/src/agGrid/Adaptable.d.ts

@@ -7,7 +7,7 @@ import { AdaptableApi } from '../Api/AdaptableApi';
 import { AdaptableColumn } from '../PredefinedConfig/Common/AdaptableColumn';
 import { AdaptableStyle } from '../PredefinedConfig/Common/AdaptableStyle';
 import { ColumnSort } from '../PredefinedConfig/Common/ColumnSort';
-import { DataChangedInfo } from '../PredefinedConfig/Common/DataChangedInfo';
+import { CellDataChangedInfo } from '../PredefinedConfig/Common/CellDataChangedInfo';
 import { DataUpdateConfig } from '../PredefinedConfig/Common/DataUpdateConfig';
 import { AdaptableMenuItem } from '../PredefinedConfig/Common/Menu';
 import { ReportData } from '../PredefinedConfig/ExportState';
@@ -149,7 +149,7 @@ export declare class Adaptable implements IAdaptable {
     private updateLayoutFromGrid;
     setSelectedCells(): SelectedCellInfo | undefined;
     setSelectedRows(): SelectedRowInfo | undefined;
-    setValue(dataChangedInfo: DataChangedInfo): void;
+    setValue(cellDataChangedInfo: CellDataChangedInfo): void;
     cancelEdit(): void;
     isCellEditable(rowNode: RowNode, column: Column): boolean;
     getDistinctValuesForColumn(column: AdaptableColumn, visibleRowsOnly: boolean, skipRowNode?: RowNode, permittedValues?: any[]): GridCell[];

package/src/agGrid/Adaptable.js

@@ -1483,25 +1483,27 @@ class Adaptable {
         this.agGridHelper.fireSelectionChangedEvent();
         return selectedRowInfo;
     }
-    setValue(dataChangedInfo) {
+    setValue(cellDataChangedInfo) {
         // note: because we use RowNode.setDataValue() this will cause Validation to fire
         // see https://www.ag-grid.com/javascript-data-grid/change-detection/#triggering-value-change-detection
         let newValue;
-        let dataType = dataChangedInfo.column.dataType;
+        let dataType = cellDataChangedInfo.column.dataType;
         newValue =
-            dataType == Enums_1.DataType.Number ? Number(dataChangedInfo.newValue) : dataChangedInfo.newValue;
+            dataType == Enums_1.DataType.Number
+                ? Number(cellDataChangedInfo.newValue)
+                : cellDataChangedInfo.newValue;
         if (dataType == undefined) {
             return; // no point continuing as probably a wrong  column
         }
-        if (dataChangedInfo.rowNode) {
-            dataChangedInfo.rowNode.setDataValue(dataChangedInfo.column.columnId, newValue);
+        if (cellDataChangedInfo.rowNode) {
+            cellDataChangedInfo.rowNode.setDataValue(cellDataChangedInfo.column.columnId, newValue);
         }
         else {
             if (this.useRowNodeLookUp) {
-                const rowNode = this.gridOptions.api.getRowNode(dataChangedInfo.primaryKeyValue);
+                const rowNode = this.gridOptions.api.getRowNode(cellDataChangedInfo.primaryKeyValue);
                 if (rowNode != null) {
-                    rowNode.setDataValue(dataChangedInfo.column.columnId, newValue);
-                    dataChangedInfo.rowNode = rowNode;
+                    rowNode.setDataValue(cellDataChangedInfo.column.columnId, newValue);
+                    cellDataChangedInfo.rowNode = rowNode;
                 }
             }
             else {
@@ -1509,9 +1511,9 @@ class Adaptable {
                 // prefer not to use this method but if we do then at least we can prevent further lookups once we find
                 this.gridOptions.api.getModel().forEachNode((rowNode) => {
                     if (!isUpdated) {
-                        if (dataChangedInfo.primaryKeyValue == this.getPrimaryKeyValueFromRowNode(rowNode)) {
-                            rowNode.setDataValue(dataChangedInfo.column.columnId, newValue);
-                            dataChangedInfo.rowNode = rowNode;
+                        if (cellDataChangedInfo.primaryKeyValue == this.getPrimaryKeyValueFromRowNode(rowNode)) {
+                            rowNode.setDataValue(cellDataChangedInfo.column.columnId, newValue);
+                            cellDataChangedInfo.rowNode = rowNode;
                             isUpdated = true;
                         }
                     }
@@ -3091,7 +3093,7 @@ class Adaptable {
                     }
                     return true;
                 }
-                const dataChangedInfo = this.api.internalApi.buildDataChangedInfo({
+                const cellDataChangedInfo = this.api.internalApi.buildDataChangedInfo({
                     oldValue: params.oldValue,
                     newValue: params.newValue,
                     column: this.api.columnApi.getColumnFromId(params.column.getColId()),
@@ -3099,15 +3101,15 @@ class Adaptable {
                     rowNode: params.node,
                     trigger: 'edit',
                 });
-                if (dataChangedInfo.oldValue === dataChangedInfo.newValue) {
+                if (cellDataChangedInfo.oldValue === cellDataChangedInfo.newValue) {
                     return true;
                 }
-                if (!this.ValidationService.performValidation(dataChangedInfo)) {
+                if (!this.ValidationService.performValidation(cellDataChangedInfo)) {
                     return false;
                 }
                 const onServerValidationCompleted = () => { };
                 if ((_a = this.adaptableOptions.editOptions) === null || _a === void 0 ? void 0 : _a.validateOnServer) {
-                    this.ValidationService.performServerValidation(dataChangedInfo, {
+                    this.ValidationService.performServerValidation(cellDataChangedInfo, {
                         onServerValidationCompleted,
                     })();
                 }
@@ -3176,13 +3178,13 @@ class Adaptable {
             return;
         }
         // rowNode = this.getRowNodeForPrimaryKey(primaryKeyValue);
-        let dataChangedInfos = [];
+        let cellDataChangedInfos = [];
         Object.keys(oldData).forEach((key) => {
             if (this.api.columnApi.doesColumnExist(key)) {
                 const oldValue = oldData[key];
                 const newValue = newData[key];
                 if (oldValue != newValue) {
-                    const dataChangedInfo = this.api.internalApi.buildDataChangedInfo({
+                    const cellDataChangedInfo = this.api.internalApi.buildDataChangedInfo({
                         oldValue: oldValue,
                         newValue: newValue,
                         column: this.api.columnApi.getColumnFromId(key),
@@ -3190,14 +3192,14 @@ class Adaptable {
                         rowNode: rowNode,
                         trigger: 'tick',
                     });
-                    if (this.isUndoChange(dataChangedInfo)) {
-                        dataChangedInfo.trigger = 'undo';
+                    if (this.isUndoChange(cellDataChangedInfo)) {
+                        cellDataChangedInfo.trigger = 'undo';
                     }
-                    dataChangedInfos.push(dataChangedInfo);
+                    cellDataChangedInfos.push(cellDataChangedInfo);
                 }
             }
         });
-        this.performPostEditChecks(dataChangedInfos);
+        this.performPostEditChecks(cellDataChangedInfos);
     }
     onCellDataChanged({ rowNode, oldValue, newValue, colId, }) {
         if (oldValue == newValue) {
@@ -3208,7 +3210,7 @@ class Adaptable {
             return;
         }
         if (this.isGroupRowNode(rowNode)) {
-            const dataChangedInfo = this.api.internalApi.buildDataChangedInfo({
+            const cellDataChangedInfo = this.api.internalApi.buildDataChangedInfo({
                 oldValue: oldValue,
                 newValue: newValue,
                 column: abColumn,
@@ -3220,14 +3222,14 @@ class Adaptable {
                 rowNode: rowNode,
                 trigger: 'aggChange',
             });
-            this.DataService.CreateDataChangedEvent(dataChangedInfo);
+            this.DataService.CreateDataChangedEvent(cellDataChangedInfo);
             return;
         }
         const primaryKeyValue = this.getPrimaryKeyValueFromRowNode(rowNode);
         if (!primaryKeyValue) {
             return;
         }
-        const dataChangedInfo = this.api.internalApi.buildDataChangedInfo({
+        const cellDataChangedInfo = this.api.internalApi.buildDataChangedInfo({
             oldValue: oldValue,
             newValue: newValue,
             column: abColumn,
@@ -3235,10 +3237,10 @@ class Adaptable {
             rowNode: rowNode,
             trigger: 'edit',
         });
-        if (this.isUndoChange(dataChangedInfo)) {
-            dataChangedInfo.trigger = 'undo';
+        if (this.isUndoChange(cellDataChangedInfo)) {
+            cellDataChangedInfo.trigger = 'undo';
         }
-        this.performPostEditChecks([dataChangedInfo]);
+        this.performPostEditChecks([cellDataChangedInfo]);
     }
     isUndoChange(dataChange) {
         // check if this is not a reverted change
@@ -3248,20 +3250,20 @@ class Adaptable {
     /**
      * There are a few things that we need to do AFTER we edit a cell and it makes sense to put them in one place
      */
-    performPostEditChecks(dataChangedInfos) {
-        const firstInfo = dataChangedInfos[0];
+    performPostEditChecks(cellDataChangedInfos) {
+        const firstInfo = cellDataChangedInfos[0];
         if (!firstInfo || !firstInfo.rowNode) {
             return;
         }
-        dataChangedInfos.forEach((dataChangedInfo) => {
-            if (dataChangedInfo.trigger === 'undo') {
-                LoggingHelper_1.LogAdaptableInfo(`Undo data change: PK(${dataChangedInfo.primaryKeyValue}) Col(${dataChangedInfo.column}) RevertedValue(${dataChangedInfo.oldValue}) OriginalValue(${dataChangedInfo.newValue})`);
+        cellDataChangedInfos.forEach((cellDataChangedInfo) => {
+            if (cellDataChangedInfo.trigger === 'undo') {
+                LoggingHelper_1.LogAdaptableInfo(`Undo data change: PK(${cellDataChangedInfo.primaryKeyValue}) Col(${cellDataChangedInfo.column}) RevertedValue(${cellDataChangedInfo.oldValue}) OriginalValue(${cellDataChangedInfo.newValue})`);
             }
-            if (dataChangedInfo.trigger === 'edit' || dataChangedInfo.trigger === 'undo') {
-                this.checkChangedCellCurrentlySelected(dataChangedInfo);
-                this.api.freeTextColumnApi.checkFreeTextColumnForDataChange(dataChangedInfo);
+            if (cellDataChangedInfo.trigger === 'edit' || cellDataChangedInfo.trigger === 'undo') {
+                this.checkChangedCellCurrentlySelected(cellDataChangedInfo);
+                this.api.freeTextColumnApi.checkFreeTextColumnForDataChange(cellDataChangedInfo);
             }
-            this.DataService.CreateDataChangedEvent(dataChangedInfo);
+            this.DataService.CreateDataChangedEvent(cellDataChangedInfo);
         });
         // if node is visible then check if need to refresh other columns / whole row if the updating column is:
         // 1. referenced in Conditional Styles that have Expressions (refreshing whole row if Scope is All)
@@ -3271,12 +3273,12 @@ class Adaptable {
                 wholeRow: false,
                 columnIds: new Set(),
             };
-            this.getExpressionStylesChanges(dataChangedScope, dataChangedInfos);
+            this.getExpressionStylesChanges(dataChangedScope, cellDataChangedInfos);
             if (dataChangedScope.wholeRow) {
                 this.redrawRow(firstInfo.rowNode);
             }
             else {
-                this.getFormatColumnComparisonChanges(dataChangedScope, dataChangedInfos);
+                this.getFormatColumnComparisonChanges(dataChangedScope, cellDataChangedInfos);
                 if (dataChangedScope.columnIds.size > 0) {
                     this.refreshCells([firstInfo.rowNode], Array.from(dataChangedScope.columnIds.values()), true);
                 }
@@ -3284,17 +3286,17 @@ class Adaptable {
         }
         firstInfo.trigger == 'tick' ? this.filterOnTickingDataChange() : this.filterOnEditDataChange();
     }
-    getExpressionStylesChanges(dataChangedScope, dataChangedInfos) {
+    getExpressionStylesChanges(dataChangedScope, cellDataChangedInfos) {
         const stylesWithExpression = this.api.conditionalStyleApi.getConditionalStylesWithExpression();
         if (ArrayExtensions_1.ArrayExtensions.IsNullOrEmpty(stylesWithExpression)) {
             return;
         }
-        dataChangedInfos.forEach((dataChangedInfo) => {
+        cellDataChangedInfos.forEach((cellDataChangedInfo) => {
             if (!dataChangedScope.wholeRow) {
                 stylesWithExpression.forEach((conditionalStyle) => {
                     if (!dataChangedScope.wholeRow) {
                         const columnIds = this.api.queryLanguageApi.getColumnsFromExpression(conditionalStyle.Rule.BooleanExpression);
-                        if (columnIds.includes(dataChangedInfo.column.columnId)) {
+                        if (columnIds.includes(cellDataChangedInfo.column.columnId)) {
                             if (this.api.scopeApi.scopeIsAll(conditionalStyle.Scope)) {
                                 dataChangedScope.wholeRow = true;
                                 return;
@@ -3313,14 +3315,14 @@ class Adaptable {
             }
         });
     }
-    getFormatColumnComparisonChanges(dataChangedScope, dataChangedInfos) {
+    getFormatColumnComparisonChanges(dataChangedScope, cellDataChangedInfos) {
         this.api.formatColumnApi.getAllFormatColumn().forEach((fc) => {
             let columnComparision = this.api.formatColumnApi.getColumnComparisonForFormatColumn(fc);
             if (columnComparision) {
                 let affectedColumnIds = this.api.formatColumnApi.getColumnIdsFromColumnComparison(columnComparision);
                 if (ArrayExtensions_1.ArrayExtensions.IsNotNullOrEmpty(affectedColumnIds)) {
-                    dataChangedInfos.forEach((dataChangedInfo) => {
-                        if (affectedColumnIds.includes(dataChangedInfo.column.columnId)) {
+                    cellDataChangedInfos.forEach((cellDataChangedInfo) => {
+                        if (affectedColumnIds.includes(cellDataChangedInfo.column.columnId)) {
                             this.api.scopeApi
                                 .getColumnsForScope(fc.Scope)
                                 .map((c) => c.columnId)
@@ -3333,18 +3335,18 @@ class Adaptable {
             }
         });
     }
-    checkChangedCellCurrentlySelected(dataChangedInfo) {
+    checkChangedCellCurrentlySelected(cellDataChangedInfo) {
         let selectedCellInfo = this.api.gridApi.getSelectedCellInfo();
         if (selectedCellInfo && ArrayExtensions_1.ArrayExtensions.IsNotNullOrEmpty(selectedCellInfo.gridCells)) {
-            let matchingCell = selectedCellInfo.gridCells.find((gc) => gc.primaryKeyValue == dataChangedInfo.primaryKeyValue &&
-                gc.column == dataChangedInfo.column);
+            let matchingCell = selectedCellInfo.gridCells.find((gc) => gc.primaryKeyValue == cellDataChangedInfo.primaryKeyValue &&
+                gc.column == cellDataChangedInfo.column);
             if (matchingCell) {
                 this.setSelectedCells();
             }
         }
         let selectedRowInfo = this.api.gridApi.getSelectedRowInfo();
         if (selectedRowInfo && ArrayExtensions_1.ArrayExtensions.IsNotNullOrEmpty(selectedRowInfo.gridRows)) {
-            let matchingRow = selectedRowInfo.gridRows.find((gr) => gr.primaryKeyValue == dataChangedInfo.primaryKeyValue);
+            let matchingRow = selectedRowInfo.gridRows.find((gr) => gr.primaryKeyValue == cellDataChangedInfo.primaryKeyValue);
             if (matchingRow) {
                 this.setSelectedRows();
             }

package/src/metamodel/adaptable.metamodel.d.ts

@@ -1000,6 +1000,40 @@ export declare const ADAPTABLE_METAMODEL: {
             isOptional: boolean;
         })[];
     };
+    CellDataChangedInfo: {
+        name: string;
+        kind: string;
+        description: string;
+        properties: ({
+            name: string;
+            kind: string;
+            description: string;
+            uiLabel: string;
+            reference?: undefined;
+            isOptional?: undefined;
+        } | {
+            name: string;
+            kind: string;
+            description: string;
+            uiLabel: string;
+            reference: string;
+            isOptional?: undefined;
+        } | {
+            name: string;
+            kind: string;
+            description: string;
+            uiLabel: string;
+            isOptional: boolean;
+            reference?: undefined;
+        } | {
+            name: string;
+            kind: string;
+            description: string;
+            uiLabel: string;
+            isOptional: boolean;
+            reference: string;
+        })[];
+    };
     CellHighlightInfo: {
         name: string;
         kind: string;
@@ -1595,40 +1629,6 @@ export declare const ADAPTABLE_METAMODEL: {
             uiLabel: string;
         }[];
     };
-    DataChangedInfo: {
-        name: string;
-        kind: string;
-        description: string;
-        properties: ({
-            name: string;
-            kind: string;
-            description: string;
-            uiLabel: string;
-            reference?: undefined;
-            isOptional?: undefined;
-        } | {
-            name: string;
-            kind: string;
-            description: string;
-            uiLabel: string;
-            reference: string;
-            isOptional?: undefined;
-        } | {
-            name: string;
-            kind: string;
-            description: string;
-            uiLabel: string;
-            isOptional: boolean;
-            reference?: undefined;
-        } | {
-            name: string;
-            kind: string;
-            description: string;
-            uiLabel: string;
-            isOptional: boolean;
-            reference: string;
-        })[];
-    };
     DataChangeHistoryApi: {
         name: string;
         kind: string;