@adaptabletools/adaptable 11.1.0 → 11.1.1-canary.2

package/src/Utilities/Emitter.js

@@ -100,13 +100,16 @@ class Emittery {
             });
         });
     }
-    onIncludeFiredOnce(eventName) {
+    onIncludeFiredOnce(eventName, listener) {
         const triggeredEventsMap = triggeredMap.get(this);
         const eventInfo = triggeredEventsMap.get(eventName);
         if (eventInfo) {
-            return Promise.resolve(eventInfo.data);
+            listener(eventInfo.data);
+            return () => { };
+        }
+        else {
+            return this.on(eventName, listener);
         }
-        return this.once(eventName);
     }
     onIncludeFired(eventName, listener) {
         const triggeredEventsMap = triggeredMap.get(this);

package/src/Utilities/ExpressionFunctions/aggregatedBooleanExpressionFunctions.d.ts

@@ -1,5 +1,5 @@
 import { ExpressionFunction } from '../../parser/src/types';
-declare type AggregationFunctionName = 'WHERE' | 'COL' | AggregationFunction | ComparisonFunction;
+export declare type AggregationFunctionName = 'WHERE' | 'COL' | AggregationFunction | ComparisonFunction;
 declare type AggregationFunction = 'SUM';
 declare type ComparisonFunction = 'EQ' | 'NEQ' | 'LT' | 'GT' | 'LTE' | 'GTE';
 export declare const aggregatedBooleanExpressionFunctions: Record<AggregationFunctionName, ExpressionFunction>;

package/src/Utilities/ExpressionFunctions/expressionFunctionUtils.d.ts

@@ -1,7 +1,7 @@
 import { ExpressionContext } from '../../parser/src/types';
 import { AdaptableApi } from '../../Api/AdaptableApi';
 import { Observable } from 'rxjs';
-import { DataChangedInfo } from '../../PredefinedConfig/Common/DataChangedInfo';
+import { CellDataChangedInfo } from '../../PredefinedConfig/Common/CellDataChangedInfo';
 export interface BaseParameter<T = string, N = string> {
     type: T;
     name: N;
@@ -12,7 +12,7 @@ export interface ColumnParameter extends BaseParameter<'config', 'COL'> {
 export declare const getStringValues: (context: ExpressionContext, ...stringArguments: string[]) => string[];
 export declare const getStringValue: (context: ExpressionContext, stringArgument: string) => string;
 export declare const isTextSearchCaseInsensitive: (context: ExpressionContext) => boolean;
-export declare const getDataChangeLog$: (context: ExpressionContext, columnNameFilter: string) => Observable<DataChangedInfo>;
+export declare const getDataChangeLog$: (context: ExpressionContext, columnNameFilter: string) => Observable<CellDataChangedInfo>;
 export declare const handleWhereFunction: (args: any[], context: ExpressionContext) => any;
 export declare const extractColumnParameter: (consumingFunctionName: string, args: BaseParameter[]) => ColumnParameter;
 export declare const extractParameter: <T extends BaseParameter<string, string>>(consumingFunctionName: string, allowedType: T["type"], allowedOperands: T["name"][], args: BaseParameter[], isOptional?: boolean) => T;

package/src/Utilities/ExpressionFunctions/expressionFunctionUtils.js

@@ -18,7 +18,7 @@ exports.getStringValue = (context, stringArgument) => {
     return exports.isTextSearchCaseInsensitive(context) ? stringArgument.toLowerCase() : stringArgument;
 };
 exports.isTextSearchCaseInsensitive = (context) => !context.api.internalApi.isTextComparisonCaseSensitive();
-// returns an observable which filters the source$ emissions and emits only if the DataChangedInfo relates to the given column
+// returns an observable which filters the source$ emissions and emits only if the CellDataChangedInfo relates to the given column
 // optionally, if a filter function (where clause) is provided, it is also evaluated
 exports.getDataChangeLog$ = (context, columnNameFilter) => {
     let dataChangeLog$ = context.api.internalApi.getDataService().dataChangeLog$;

package/src/Utilities/ExpressionFunctions/observableExpressionFunctions.d.ts

@@ -1,5 +1,5 @@
 import { ExpressionFunction } from '../../parser/src/types';
-declare type ObservableFunctionName = 'WHERE' | 'COL' | 'TIMEFRAME' | ObservableFunction | ChangeFunction;
+export declare type ObservableFunctionName = 'WHERE' | 'COL' | 'TIMEFRAME' | ObservableFunction | ChangeFunction;
 declare type ObservableFunction = 'ROW_CHANGE' | 'GRID_CHANGE';
 declare type ChangeFunction = 'MAX' | 'MIN' | 'NONE' | 'COUNT';
 export declare const observableExpressionFunctions: Record<ObservableFunctionName, ExpressionFunction>;

package/src/Utilities/ObjectFactory.d.ts

@@ -13,7 +13,7 @@ import { ConditionalStyle } from '../PredefinedConfig/ConditionalStyleState';
 import { FormatColumn } from '../PredefinedConfig/FormatColumnState';
 import { FreeTextColumn } from '../PredefinedConfig/FreeTextColumnState';
 import { AdaptableStyle } from '../PredefinedConfig/Common/AdaptableStyle';
-import { DataChangedInfo } from '../PredefinedConfig/Common/DataChangedInfo';
+import { CellDataChangedInfo } from '../PredefinedConfig/Common/CellDataChangedInfo';
 import { Glue42Report, Glue42Schedule } from '../PredefinedConfig/Glue42State';
 import { IPushPullReport } from '../PredefinedConfig/SystemState';
 import { IPushPullSchedule } from '../PredefinedConfig/IPushPullState';
@@ -34,7 +34,7 @@ export declare function CreateEmptyCalculatedColumn(isFilterable: boolean): Calc
 export declare function CreateEmptyNamedQuery(expression?: string): NamedQuery;
 export declare function CreateEmptyPlusMinusNudge(): PlusMinusNudge;
 export declare function CreateGenericAlert(alertHeader: string, alertMessage: string, alertDefinition: AlertDefinition): AdaptableGenericAlert;
-export declare function CreateCellChangedAlert(alertHeader: string, alertMessage: string, alertDefinition: AlertDefinition, dataChangedInfo: DataChangedInfo): AdaptableCellChangedAlert;
+export declare function CreateCellChangedAlert(alertHeader: string, alertMessage: string, alertDefinition: AlertDefinition, cellDataChangedInfo: CellDataChangedInfo): AdaptableCellChangedAlert;
 export declare function CreateRowChangedAlert(alertHeader: string, alertMessage: string, alertDefinition: AlertDefinition, gridDataChange: GridDataChangedInfo): AdaptableRowChangedAlert;
 export declare function CreateEmptyAlertDefinition(): AlertDefinition;
 export declare function CreateEmptyFlashingCellDefinition(): FlashingCellDefinition;

package/src/Utilities/ObjectFactory.js

@@ -61,14 +61,14 @@ function CreateGenericAlert(alertHeader, alertMessage, alertDefinition) {
     };
 }
 exports.CreateGenericAlert = CreateGenericAlert;
-function CreateCellChangedAlert(alertHeader, alertMessage, alertDefinition, dataChangedInfo) {
+function CreateCellChangedAlert(alertHeader, alertMessage, alertDefinition, cellDataChangedInfo) {
     return {
         alertType: 'cellChanged',
         Uuid: Uuid_1.createUuid(),
         header: alertHeader,
         message: alertMessage,
         alertDefinition,
-        dataChangedInfo,
+        cellDataChangedInfo: cellDataChangedInfo,
     };
 }
 exports.CreateCellChangedAlert = CreateCellChangedAlert;

package/src/Utilities/Services/CalculatedColumnExpressionService.js

@@ -12,8 +12,8 @@ class CalculatedColumnExpressionService {
         this.adaptable = adaptable;
         this.adaptable.api.internalApi
             .getDataService()
-            .on('DataChanged', (dataChangedInfo) => {
-            if (dataChangedInfo.trigger === 'aggChange') {
+            .on('CellDataChanged', (cellDataChangedInfo) => {
+            if (cellDataChangedInfo.trigger === 'aggChange') {
                 // do NOT handle changes on group rows
                 return;
             }
@@ -21,7 +21,7 @@ class CalculatedColumnExpressionService {
             this.aggregatedScalarCalculatedColumnsMap.forEach((aggregatedScalarCalculatedColumn) => {
                 if (aggregatedScalarCalculatedColumn
                     .getColumnDependencies()
-                    .includes(dataChangedInfo.column.columnId)) {
+                    .includes(cellDataChangedInfo.column.columnId)) {
                     aggregatedScalarCalculatedColumn.refreshAggregatedColumnValue();
                     refreshedCalculatedColumns.push(aggregatedScalarCalculatedColumn.getCalculatedColumnId());
                 }

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

@@ -1,21 +1,21 @@
 import { IDataService } from './Interface/IDataService';
 import { IAdaptable } from '../../AdaptableInterfaces/IAdaptable';
-import { DataChangedInfo } from '../../PredefinedConfig/Common/DataChangedInfo';
+import { CellDataChangedInfo } from '../../PredefinedConfig/Common/CellDataChangedInfo';
 import { EmitterCallback } from '../../Utilities/Emitter';
 import { Observable } from 'rxjs';
 export declare class DataService implements IDataService {
     private adaptable;
     private emitter;
     private readonly dataChangeLogSubject$;
-    dataChangeLog$: Observable<DataChangedInfo>;
+    dataChangeLog$: Observable<CellDataChangedInfo>;
     private undoChangeLog;
     private undoChangeTimers;
     constructor(adaptable: IAdaptable);
     on: (eventName: string, callback: EmitterCallback) => (() => void);
     emit: (eventName: string, data?: any) => Promise<any>;
-    CreateDataChangedEvent(dataChangedInfo: DataChangedInfo): void;
-    logUndoChange(change: DataChangedInfo): void;
-    extractUndoChange(change: DataChangedInfo): DataChangedInfo | undefined;
+    CreateDataChangedEvent(cellDataChangedInfo: CellDataChangedInfo): void;
+    logUndoChange(change: CellDataChangedInfo): void;
+    extractUndoChange(change: CellDataChangedInfo): CellDataChangedInfo | undefined;
     destroy(): void;
     private getUndoChangeKey;
     private logDataChange;

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/ActionColumnRenderer.d.ts

@@ -1,9 +1,4 @@
-import { ICellRendererComp, ICellRendererParams, ITooltipComp, ITooltipParams } from '@ag-grid-community/all-modules';
-export declare class CustomTooltip implements ITooltipComp {
-    private eGui;
-    init(params: ITooltipParams): void;
-    getGui(): any;
-}
+import { ICellRendererComp, ICellRendererParams } from '@ag-grid-community/all-modules';
 export declare class ActionColumnRenderer implements ICellRendererComp {
     private eGui;
     private eventListener;

package/src/agGrid/ActionColumnRenderer.js

@@ -1,85 +1,76 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ActionColumnRenderer = exports.CustomTooltip = void 0;
+exports.ActionColumnRenderer = void 0;
 const tslib_1 = require("tslib");
 const SimpleButton_1 = tslib_1.__importDefault(require("../components/SimpleButton"));
 const react_dom_1 = require("react-dom");
 const React = tslib_1.__importStar(require("react"));
-class CustomTooltip {
-    init(params) {
-        this.eGui = document.createElement('div');
-        this.eGui.classList.add('custom-tooltip');
-        let { field, lastValidation, validationFailedMsg } = params.value;
-        this.eGui.innerHTML = `
-        <div class="validation-msg">
-          FIELD-${field.toUpperCase()} - invalid value:
-          "<span class="invalid-value"> ${lastValidation} </span>",
-          ${validationFailedMsg}
-        </div>
-    `;
-    }
-    getGui() {
-        return this.eGui;
-    }
-}
-exports.CustomTooltip = CustomTooltip;
+const uuid_1 = require("../components/utils/uuid");
 class ActionColumnRenderer {
     // gets called once before the renderer is used
     init(params) {
         var _a;
         const adaptable = params.api.__adaptable;
-        let actionCol = (_a = adaptable.api.userInterfaceApi
+        const actionCol = (_a = adaptable.api.userInterfaceApi
             .getAllActionColumn()) === null || _a === void 0 ? void 0 : _a.find((ac) => ac.columnId == params.colDef.colId);
-        if (actionCol) {
+        if (actionCol && actionCol.actionColumnButton) {
+            let actionButtons = Array.isArray(actionCol.actionColumnButton)
+                ? actionCol.actionColumnButton
+                : [actionCol.actionColumnButton];
+            if (!actionButtons.length) {
+                return;
+            }
+            // actionButtons don't have IDs, so we need to generate them to be used later as a react component key
+            actionButtons = actionButtons.map((actionButton) => (Object.assign(Object.assign({}, actionButton), { Uuid: uuid_1.createUuid() })));
             // create the cell
             this.eGui = document.createElement('div');
             this.eGui.className = 'ab-ActionColumn';
-            let pkValue = adaptable.getPrimaryKeyValueFromRowNode(params.node);
-            let button = actionCol.actionColumnButton;
-            let context = {
-                actionColumn: actionCol,
-                primaryKeyValue: pkValue,
-                rowNode: params.node,
-                adaptableApi: adaptable.api,
-            };
             // if its a group node then only show if set to do so
             if (adaptable.api.gridApi.isGroupRowNode(params.node) && !actionCol.includeGroupedRows) {
                 this.eGui.innerHTML = '';
                 return;
             }
-            if (button.hidden && button.hidden(button, context)) {
-                this.eGui.innerHTML = '';
-                return;
-            }
-            const disabled = button.disabled && button.disabled(button, context);
-            const renderButton = (adaptableApi, context) => {
-                var _a, _b;
-                const defaultIconProps = {
-                    style: {
-                        height: 15,
-                        width: 15,
-                    },
-                };
-                const iconProps = button.icon && Object.assign({}, defaultIconProps, button.icon);
-                let buttonStyle = adaptableApi.internalApi.getStyleForButton(button, context);
-                let buttonLabel = adaptableApi.internalApi.getLabelForButton(button, context);
-                let buttonTooltip = adaptableApi.internalApi.getTooltipForButton(button, context);
-                const handleClick = () => {
-                    button.onClick(button, context);
-                    // Timeout to let any updates to be done before re-rendering the component
-                    setTimeout(() => {
-                        // when called again it triggers a re-render
-                        // https:reactjs.org/docs/react-dom.html#render
-                        doRender();
-                    }, 16);
-                };
-                return (React.createElement(SimpleButton_1.default, { key: button.Uuid, variant: (_a = buttonStyle === null || buttonStyle === void 0 ? void 0 : buttonStyle.variant) !== null && _a !== void 0 ? _a : 'text', disabled: disabled, tooltip: buttonTooltip, tone: (_b = buttonStyle === null || buttonStyle === void 0 ? void 0 : buttonStyle.tone) !== null && _b !== void 0 ? _b : 'none', onClick: handleClick, className: buttonStyle === null || buttonStyle === void 0 ? void 0 : buttonStyle.className, accessLevel: 'Full' },
-                    button.icon ? React.createElement("img", Object.assign({}, iconProps)) : null,
-                    buttonLabel));
+            const pkValue = adaptable.getPrimaryKeyValueFromRowNode(params.node);
+            const buttonContext = {
+                actionColumn: actionCol,
+                primaryKeyValue: pkValue,
+                rowNode: params.node,
+                adaptableApi: adaptable.api,
+            };
+            const renderActionButtons = (buttons, adaptableApi, context) => {
+                return (React.createElement(React.Fragment, null, buttons.map((button) => {
+                    var _a, _b;
+                    if (button.hidden && button.hidden(button, context)) {
+                        return;
+                    }
+                    const defaultIconProps = {
+                        style: {
+                            height: 15,
+                            width: 15,
+                        },
+                    };
+                    const iconProps = button.icon && Object.assign({}, defaultIconProps, button.icon);
+                    const buttonStyle = adaptableApi.internalApi.getStyleForButton(button, context);
+                    const buttonLabel = adaptableApi.internalApi.getLabelForButton(button, context);
+                    const buttonTooltip = adaptableApi.internalApi.getTooltipForButton(button, context);
+                    const handleClick = () => {
+                        button.onClick(button, context);
+                        // Timeout to let any updates to be done before re-rendering the component
+                        setTimeout(() => {
+                            // when called again it triggers a re-render
+                            // https:reactjs.org/docs/react-dom.html#render
+                            doRender();
+                        }, 16);
+                    };
+                    const disabled = button.disabled && button.disabled(button, context);
+                    return (React.createElement(SimpleButton_1.default, { key: button.Uuid, variant: (_a = buttonStyle === null || buttonStyle === void 0 ? void 0 : buttonStyle.variant) !== null && _a !== void 0 ? _a : 'text', disabled: disabled, tooltip: buttonTooltip, tone: (_b = buttonStyle === null || buttonStyle === void 0 ? void 0 : buttonStyle.tone) !== null && _b !== void 0 ? _b : 'none', onClick: handleClick, className: buttonStyle === null || buttonStyle === void 0 ? void 0 : buttonStyle.className, accessLevel: 'Full' },
+                        button.icon ? React.createElement("img", Object.assign({}, iconProps)) : null,
+                        buttonLabel));
+                })));
             };
             const eGui = this.eGui;
             function doRender() {
-                react_dom_1.render(renderButton(adaptable.api, context), eGui);
+                react_dom_1.render(renderActionButtons(actionButtons, adaptable.api, buttonContext), eGui);
             }
             this.render = doRender;
             doRender();

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';
@@ -74,6 +74,7 @@ export declare class Adaptable implements IAdaptable {
     private _id;
     private currentColumnDefs?;
     private rowListeners;
+    private isCheckedColumnDataType;
     _on: (eventName: string, callback: EmitterCallback) => (() => void);
     _onIncludeFired: (eventName: string, callback: EmitterCallback) => (() => void);
     _emit: (eventName: string, data?: any) => Promise<any>;
@@ -149,7 +150,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[];