@adaptabletools/adaptable 19.2.4 → 20.0.0-canary.1

package/src/Utilities/ObjectFactory.js

@@ -1,8 +1,10 @@
-import { ExportDestination, MathOperation, ScheduleType } from '../PredefinedConfig/Common/Enums';
+import { MathOperation, ScheduleType } from '../PredefinedConfig/Common/Enums';
 import { createUuid } from '../PredefinedConfig/Uuid';
-import { ALERT_DEFAULT_MESSAGE_TYPE, ALERT_DEFAULT_SHOW_POPUP, EMPTY_STRING, PLUS_MINUS_DEFAULT_NUDGE_VALUE, } from './Constants/GeneralConstants';
+import { EMPTY_STRING } from './Constants/GeneralConstants';
+import { ALERT_DEFAULT_MESSAGE_TYPE, ALERT_DEFAULT_SHOW_POPUP, PLUS_MINUS_DEFAULT_NUDGE_VALUE, } from './Constants/ObjectDefaultConstants';
 import { Bounce, Flip, Slide, Zoom } from '../components/Toastify';
 import { BLACK, getHexForName, LIGHT_GRAY } from '../View/UIHelper';
+import { isPivotLayout } from '../Api/Implementation/LayoutHelpers';
 export function CreateEmptyCustomSort() {
     return { Uuid: createUuid(), ColumnId: EMPTY_STRING, SortedValues: [] };
 }
@@ -26,7 +28,10 @@ export function CreateEmptyCalculatedColumn(defaultSpecialColumnSettings) {
             ScalarExpression: EMPTY_STRING,
         },
         // need to create some defaults - which we will change later
-        CalculatedColumnSettings: Object.assign(Object.assign({}, defaultSpecialColumnSettings), { DataType: undefined }),
+        CalculatedColumnSettings: {
+            ...defaultSpecialColumnSettings,
+            DataType: undefined,
+        },
     };
 }
 export function CreateEmptyNamedQuery(expression) {
@@ -63,14 +68,14 @@ export function CreateCellChangedAlert(alertHeader, alertMessage, alertDefinitio
         cellDataChangedInfo: cellDataChangedInfo,
     };
 }
-export function CreateRowChangedAlert(alertHeader, alertMessage, alertDefinition, gridDataChange) {
+export function CreateRowChangedAlert(alertHeader, alertMessage, alertDefinition, rowDataChangedInfo) {
     return {
         alertType: 'rowChanged',
         Uuid: createUuid(),
         header: alertHeader,
         message: alertMessage,
         alertDefinition,
-        gridDataChangedInfo: gridDataChange,
+        rowDataChangedInfo: rowDataChangedInfo,
     };
 }
 export function CreateEmptyAlertDefinition() {
@@ -98,7 +103,7 @@ export function CreateEmptyFlashingCellDefinition() {
     };
 }
 export function CreateInternalAlertDefinitionForMessages(messageType, alertProperties) {
-    alertProperties = alertProperties !== null && alertProperties !== void 0 ? alertProperties : {
+    alertProperties = alertProperties ?? {
         DisplayNotification: ALERT_DEFAULT_SHOW_POPUP,
     };
     return {
@@ -156,7 +161,7 @@ export function CreateEmptyReportSchedule() {
         ScheduleType: ScheduleType.Report,
         Schedule: CreateEmptySchedule(),
         ReportName: EMPTY_STRING,
-        ExportDestination: ExportDestination.CSV,
+        ReportFormat: EMPTY_STRING,
     };
 }
 export function CreateEmptyIPushPullReport() {
@@ -200,13 +205,13 @@ export function CreateIPushPullSchedule(iPushPullReport) {
         Transmission: 'Snapshot',
     };
 }
-export function CreateReportSchedule(reportName) {
+export function CreateReportSchedule(reportName, reportFormat) {
     return {
         Uuid: createUuid(),
         ScheduleType: ScheduleType.Report,
         Schedule: CreateEmptySchedule(),
         ReportName: reportName,
-        ExportDestination: ExportDestination.CSV,
+        ReportFormat: reportFormat,
     };
 }
 export function CreateEmptySchedule() {
@@ -243,14 +248,41 @@ export function CreateEmptyFreeTextColumn(defaultSpecialColumnSettings) {
         DefaultValue: EMPTY_STRING,
         FreeTextStoredValues: [],
         TextEditor: 'Inline',
-        FreeTextColumnSettings: Object.assign(Object.assign({}, defaultSpecialColumnSettings), { DataType: 'String' }),
+        FreeTextColumnSettings: {
+            ...defaultSpecialColumnSettings,
+            DataType: 'text',
+        },
+    };
+}
+export function CreateEmptyPivotLayout(layout) {
+    const result = {
+        Name: layout.Name,
+        ColumnSorts: layout.ColumnSorts || [],
+        ColumnFilters: layout.ColumnFilters || [],
+        Uuid: createUuid(),
+        PivotColumns: layout.PivotColumns || [],
+        PivotAggregationColumns: layout.PivotAggregationColumns || [],
+        PivotGroupedColumns: layout.PivotGroupedColumns || [],
+        ColumnWidths: layout.ColumnWidths || {},
     };
+    return result;
 }
 export function CreateEmptyLayout(layout, adaptableColumns) {
-    return Object.assign(Object.assign({}, layout), { Uuid: createUuid(), Columns: layout.Columns || [], ColumnSorts: layout.ColumnSorts || [], ColumnFilters: layout.ColumnFilters || [], 
-        //  ColumnFlexMap: layout.ColumnFlexMap || {},
-        ColumnWidthMap: layout.ColumnWidthMap || {}, RowGroupedColumns: layout.RowGroupedColumns ||
-            (adaptableColumns ? adaptableColumns.filter((c) => c.isGrouped).map((c) => c.columnId) : []) });
+    if (isPivotLayout(layout)) {
+        return CreateEmptyPivotLayout(layout);
+    }
+    const tableLayout = layout;
+    const result = {
+        ...tableLayout,
+        Uuid: createUuid(),
+        TableColumns: tableLayout.TableColumns || [],
+        ColumnSorts: tableLayout.ColumnSorts || [],
+        ColumnFilters: tableLayout.ColumnFilters || [],
+        ColumnWidths: tableLayout.ColumnWidths || {},
+        RowGroupedColumns: tableLayout.RowGroupedColumns ||
+            (adaptableColumns ? adaptableColumns.filter((c) => c.isGrouped).map((c) => c.columnId) : []),
+    };
+    return result;
 }
 export function CreateEmptyStyle() {
     return {
@@ -289,10 +321,12 @@ export function CreateEmptyCellSummmary() {
 export function CreateColumnFilter(ColumnId, PredicateId, Inputs) {
     return {
         ColumnId,
-        Predicate: {
-            PredicateId: PredicateId,
-            Inputs,
-        },
+        Predicates: [
+            {
+                PredicateId: PredicateId,
+                Inputs,
+            },
+        ],
     };
 }
 export function CreateEmptyStyledColumn() {
@@ -311,25 +345,19 @@ export function CreateDefaultStyledColumnBadge() {
     };
 }
 export function CreateEmptyChartDefinition(chartDefinition) {
-    return Object.assign({ Uuid: createUuid() }, chartDefinition);
+    return {
+        Uuid: createUuid(),
+        ...chartDefinition,
+    };
 }
 export function CreateCustomDisplayFormatterContext(value, node, abColumn, api) {
     return {
         adaptableColumn: abColumn,
         cellValue: value,
         rowNode: node,
-        adaptableApi: api,
-        userName: api.optionsApi.getUserName(),
-        adaptableId: api.optionsApi.getAdaptableId(),
+        ...api.internalApi.buildBaseContext(),
     };
 }
-export const createBaseContext = (adaptableApi) => {
-    return {
-        adaptableApi: adaptableApi,
-        userName: adaptableApi.optionsApi.getUserName(),
-        adaptableId: adaptableApi.optionsApi.getAdaptableId(),
-    };
-};
 export function CreateEmptyTheme(name) {
     return {
         Uuid: createUuid(),
@@ -338,7 +366,10 @@ export function CreateEmptyTheme(name) {
     };
 }
 export function CreateEmptyCommentThread(cellAddress) {
-    return Object.assign(Object.assign({}, cellAddress), { Comments: [] });
+    return {
+        ...cellAddress,
+        Comments: [],
+    };
 }
 function getToastPosition(position) {
     switch (position) {
@@ -371,10 +402,9 @@ function getToastTransition(transition) {
     }
 }
 export function CreateToastOptions(notificationsOptions, { onClose, containerId }, overides) {
-    var _a;
     const adaptableToastPosition = notificationsOptions.position;
     const position = getToastPosition(adaptableToastPosition);
-    const duration = (_a = overides.duration) !== null && _a !== void 0 ? _a : notificationsOptions.duration;
+    const duration = overides.duration ?? notificationsOptions.duration;
     const showProgressBar = notificationsOptions.showProgressBar;
     const closeWhenClicked = notificationsOptions.closeWhenClicked;
     const pauseWhenHovering = notificationsOptions.pauseWhenHovering;
@@ -422,6 +452,7 @@ export const ObjectFactory = {
     CreateEmptyFormatColumn,
     CreateEmptyFreeTextColumn,
     CreateEmptyLayout,
+    CreateEmptyPivotLayout,
     CreateColumnFilter,
     CreateEmptyStyle,
     CreateEmptyCellSummmary,

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

@@ -1,7 +1,7 @@
 import { AggregatedScalarExpressionEvaluation } from '../ExpressionFunctions/aggregatedScalarExpressionFunctions';
 import { AdaptableApi } from '../../Api/AdaptableApi';
 import { AdaptableModule as ModuleConstants } from '../../PredefinedConfig/Common/Types';
-import { IRowNode } from '@ag-grid-community/core';
+import { IRowNode } from 'ag-grid-enterprise';
 import { XOR } from '../Extensions/TypeExtensions';
 export declare class AggregatedScalarLiveValue {
     private source;

package/src/Utilities/Services/AggregatedScalarLiveValue.js

@@ -49,19 +49,17 @@ export class AggregatedScalarLiveValue {
         return aggregationValue;
     }
     getAllAggregationValues() {
-        var _a;
-        if ((_a = this.expressionEvaluation.aggregationParams.groupBy) === null || _a === void 0 ? void 0 : _a.length) {
+        if (this.expressionEvaluation.aggregationParams.groupBy?.length) {
             const aggregations = this.aggregationResult.deepMap.topDownValues();
             return aggregations.map((aggregation) => aggregation.reducerResults[this.aggregationReducerName]);
         }
         return [this.getGlobalAggregatedValue()];
     }
     getAggregationValue(rowNode) {
-        var _a, _b;
-        if ((_a = this.expressionEvaluation.aggregationParams.groupBy) === null || _a === void 0 ? void 0 : _a.length) {
+        if (this.expressionEvaluation.aggregationParams.groupBy?.length) {
             const groupColumns = this.expressionEvaluation.aggregationParams.groupBy.map((groupByParam) => groupByParam.field);
             const groupKeys = groupColumns.map((groupColumnName) => this.getRowNodeValueForColumnId(rowNode, groupColumnName));
-            return (_b = this.aggregationResult.deepMap.get(groupKeys)) === null || _b === void 0 ? void 0 : _b.reducerResults[this.aggregationReducerName];
+            return this.aggregationResult.deepMap.get(groupKeys)?.reducerResults[this.aggregationReducerName];
         }
         return this.getGlobalAggregatedValue();
     }
@@ -74,7 +72,6 @@ export class AggregatedScalarLiveValue {
         return rawValue instanceof Date ? rawValue.getTime() : rawValue;
     }
     computeAggregatedValue(expressionEvaluation) {
-        var _a;
         const gridRowNodes = expressionEvaluation.getRowNodes
             ? expressionEvaluation.getRowNodes()
             : this.adaptableApi.gridApi.getAllRowNodes({
@@ -93,7 +90,7 @@ export class AggregatedScalarLiveValue {
         const mapGroupByToKey = (columnId) => {
             return (_unusableProperty, rowNode) => this.getRowNodeValueForColumnId(rowNode, columnId);
         };
-        (_a = expressionEvaluation.aggregationParams.groupBy) === null || _a === void 0 ? void 0 : _a.forEach((groupByDef) => {
+        expressionEvaluation.aggregationParams.groupBy?.forEach((groupByDef) => {
             groupByDef.toKey = mapGroupByToKey(groupByDef.field);
         });
         let aggregatedRowNodes = gridRowNodes;

package/src/Utilities/Services/AlertService.js

@@ -1,4 +1,4 @@
-import { isGridDataChangedInfo } from './Interface/IAlertService';
+import { isRowDataChangedInfo } from './Interface/IAlertService';
 import Emitter from '../Emitter';
 import { combineLatest, of } from 'rxjs';
 import { AlertModuleId } from '../Constants/ModuleConstants';
@@ -34,10 +34,10 @@ export class AlertService {
             of(alertDefinition),
             reactiveExpressionObservable,
         ]).subscribe(([alertDefinition, changeLogEntry]) => {
-            const reactiveAlertInfo = isGridDataChangedInfo(changeLogEntry)
+            const reactiveAlertInfo = isRowDataChangedInfo(changeLogEntry)
                 ? {
                     alertDefinition,
-                    type: 'gridDataChangedAlert',
+                    type: 'rowDataChangedAlert',
                     gridChangeLogEntry: changeLogEntry,
                 }
                 : {
@@ -55,7 +55,7 @@ export class AlertService {
     deleteReactiveAlert(alertDefinition) {
         if (this.reactiveAlertsMap.has(alertDefinition.Uuid)) {
             const obsoleteReactiveAlert = this.reactiveAlertsMap.get(alertDefinition.Uuid);
-            obsoleteReactiveAlert === null || obsoleteReactiveAlert === void 0 ? void 0 : obsoleteReactiveAlert.subscription.unsubscribe();
+            obsoleteReactiveAlert?.subscription.unsubscribe();
             this.reactiveAlertsMap.delete(alertDefinition.Uuid);
         }
     }

package/src/Utilities/Services/{CellPopupService.d.ts → AnnotationsService.d.ts}

@@ -2,17 +2,21 @@ import { IAdaptable } from '../../AdaptableInterfaces/IAdaptable';
 import { AdaptableApi, CellAddress } from '../../types';
 import { IAdaptableService } from './Interface/IAdaptableService';
 /**
- * This service controls the interaction between notes and comments
+ * This service controls the interaction between Notes & Comments
+ * If there are active Notes or Comments it listens to Cell Selection and Mouse Enter events
  */
-export declare class CellPopupService implements IAdaptableService {
+export declare class AnnotationsService implements IAdaptableService {
     private api;
     adaptable: IAdaptable;
+    private isListeningToEvents;
     constructor(api: AdaptableApi);
     destroy(): void;
     private getAdaptableState;
     private dispatchAction;
     static isSameAddress(a: CellAddress, b: CellAddress): boolean;
-    private handleAdaptableReady;
+    checkListenToEvents(): void;
+    shouldListenToEvents(): boolean;
+    setUpEventListeners(): void;
     private getCellPositionFromEvent;
     private handleMouseEnter;
     private handleCellSelected;

package/src/Utilities/Services/{CellPopupService.js → AnnotationsService.js}

@@ -1,12 +1,15 @@
-import * as SystemRedux from '../../Redux/ActionsReducers/SystemRedux';
+import * as InternalRedux from '../../Redux/ActionsReducers/InternalRedux';
+import ArrayExtensions from '../Extensions/ArrayExtensions';
 /**
- * This service controls the interaction between notes and comments
+ * This service controls the interaction between Notes & Comments
+ * If there are active Notes or Comments it listens to Cell Selection and Mouse Enter events
  */
-export class CellPopupService {
+export class AnnotationsService {
     constructor(api) {
         this.api = api;
+        this.isListeningToEvents = false;
         this.adaptable = api.internalApi.getAdaptableInstance();
-        this.adaptable.api.eventApi.on('AdaptableReady', () => this.handleAdaptableReady());
+        this.adaptable.api.eventApi.on('AdaptableReady', () => this.checkListenToEvents());
     }
     destroy() { }
     getAdaptableState() {
@@ -19,7 +22,7 @@ export class CellPopupService {
         if (!a || !b) {
             return false;
         }
-        if ((a === null || a === void 0 ? void 0 : a.ColumnId) === (b === null || b === void 0 ? void 0 : b.ColumnId) && (a === null || a === void 0 ? void 0 : a.PrimaryKeyValue) === (b === null || b === void 0 ? void 0 : b.PrimaryKeyValue)) {
+        if (a?.ColumnId === b?.ColumnId && a?.PrimaryKeyValue === b?.PrimaryKeyValue) {
             return true;
         }
         // Primary keys retreived from the grid dom are always strings, so we must also consider them strings
@@ -29,25 +32,36 @@ export class CellPopupService {
         }
         return false;
     }
-    handleAdaptableReady() {
+    checkListenToEvents() {
+        if (!this.isListeningToEvents && this.shouldListenToEvents()) {
+            this.setUpEventListeners();
+            this.isListeningToEvents = true;
+        }
+    }
+    shouldListenToEvents() {
+        // Listen to events if we either have Notes in state or if Comments have been set up
+        return (ArrayExtensions.IsNotNullOrEmpty(this.api.noteApi.getAllNotes()) ||
+            this.api.internalApi.getModuleService().isModuleAvailable('Comment'));
+    }
+    setUpEventListeners() {
         this.adaptable._on('MouseEnter', (event) => this.handleMouseEnter(event));
         this.api.eventApi.on('CellSelectionChanged', (params) => {
-            var _a;
             const cells = params.selectedCellInfo.gridCells;
-            if ((cells === null || cells === void 0 ? void 0 : cells.length) === 1 && ((_a = cells[0].column) === null || _a === void 0 ? void 0 : _a.columnId) && cells[0].primaryKeyValue) {
+            if (ArrayExtensions.hasOneItem(cells)) {
                 const selectedCell = cells[0];
-                const cellSelected = {
-                    PrimaryKeyValue: selectedCell.primaryKeyValue,
-                    ColumnId: selectedCell.column.columnId,
-                };
-                this.handleCellSelected(cellSelected);
+                if (selectedCell.column?.columnId && selectedCell.primaryKeyValue) {
+                    const selectedCellAddress = {
+                        PrimaryKeyValue: selectedCell.primaryKeyValue,
+                        ColumnId: selectedCell.column.columnId,
+                    };
+                    this.handleCellSelected(selectedCellAddress);
+                }
             }
         });
     }
     getCellPositionFromEvent(event) {
-        var _a, _b;
         const target = event.target;
-        if (!((_b = (_a = target === null || target === void 0 ? void 0 : target.classList) === null || _a === void 0 ? void 0 : _a.contains) === null || _b === void 0 ? void 0 : _b.call(_a, 'ag-cell'))) {
+        if (!target?.classList?.contains?.('ag-cell')) {
             return null;
         }
         try {
@@ -69,32 +83,32 @@ export class CellPopupService {
         }
         const cellPosition = this.getCellPositionFromEvent(event);
         const openCellAddress = this.getOpenCellAddress();
-        // Hovering over someting that is not a cell and there is no open note
+        // Hovering over something that is not a cell and there is no open note
         if (!cellPosition && openCellAddress) {
             // need to close if the new cell does not have a note
             this.hidePopup();
             return;
         }
-        const cellNote = this.api.noteApi.getNoteForCell(cellPosition);
-        const cellComments = this.api.commentApi.getCommentThread(cellPosition);
-        const hasNotesOrComments = cellNote || cellComments;
-        // call only if it is different
-        if (CellPopupService.isSameAddress(openCellAddress, cellPosition)) {
+        // call only if cell address is different
+        if (AnnotationsService.isSameAddress(openCellAddress, cellPosition)) {
             return;
         }
-        if (hasNotesOrComments) {
-            this.showPopup(cellPosition, false);
+        const cellNote = this.api.noteApi.getNoteForCell(cellPosition);
+        const cellComments = this.api.commentApi.getCommentThreadForCell(cellPosition);
+        if (!cellNote && !cellComments) {
+            return;
         }
+        this.showPopup(cellPosition, false);
     }
     handleCellSelected(cellAddress) {
         // if already opened - do nothing
         const openCellAddress = this.getOpenCellAddress();
-        if (CellPopupService.isSameAddress(openCellAddress, cellAddress)) {
+        if (AnnotationsService.isSameAddress(openCellAddress, cellAddress)) {
             return;
         }
         // if open but this has no note, close
         const cellNote = this.api.noteApi.getNoteForCell(cellAddress);
-        const cellComments = this.api.commentApi.getCommentThread(cellAddress);
+        const cellComments = this.api.commentApi.getCommentThreadForCell(cellAddress);
         const hasNotesOrComments = cellNote || cellComments;
         if (openCellAddress && !hasNotesOrComments) {
             // hide only if in edit mode
@@ -113,21 +127,21 @@ export class CellPopupService {
         }
     }
     getOpenCellAddress() {
-        return SystemRedux.SystemCommentsAndNotesSelector(this.getAdaptableState().System);
+        return InternalRedux.CommentsAndNotesSelector(this.getAdaptableState().Internal);
     }
     getEditMode() {
-        return SystemRedux.SystemCommentsAndNotesEditModeSelector(this.getAdaptableState().System);
+        return InternalRedux.CommentsAndNotesEditModeSelector(this.getAdaptableState().Internal);
     }
     hidePopup() {
-        this.dispatchAction(SystemRedux.SystemCellPopupHide());
+        this.dispatchAction(InternalRedux.CellPopupHide());
     }
     showPopup(cellAddress, editMode) {
-        this.dispatchAction(SystemRedux.SystemCellPopupShow(cellAddress, editMode));
+        this.dispatchAction(InternalRedux.CellPopupShow(cellAddress, editMode));
     }
     editFocusedEntity(entity) {
-        this.dispatchAction(SystemRedux.SystemCellPopupEditFocusedEntity(entity));
+        this.dispatchAction(InternalRedux.CellPopupEditFocusedEntity(entity));
     }
     getNotePopupEditMode() {
-        return SystemRedux.SystemCommentsAndNotesEditModeSelector(this.getAdaptableState().System);
+        return InternalRedux.CommentsAndNotesEditModeSelector(this.getAdaptableState().Internal);
     }
 }

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

@@ -1,11 +1,15 @@
 import { ICalculatedColumnExpressionService } from './Interface/ICalculatedColumnExpressionService';
-import { IRowNode } from '@ag-grid-community/core';
+import { IRowNode } from 'ag-grid-enterprise';
 import { AdaptableCalculatedColumnQuery, CalculatedColumn, CalculatedColumnSettings } from '../../PredefinedConfig/CalculatedColumnState';
+import { CellDataChangedInfo } from '../../PredefinedConfig/Common/CellDataChangedInfo';
+import { RowDataChangedInfo } from '../../PredefinedConfig/Common/RowDataChangedInfo';
 import { AdaptableApi } from '../../../types';
 export declare class CalculatedColumnExpressionService implements ICalculatedColumnExpressionService {
     private adaptableApi;
     private aggregatedScalarLiveValuesMap;
     constructor(adaptableApi: AdaptableApi);
+    listentoCellDataChange(cellDataChangedInfo: CellDataChangedInfo): void;
+    listentoRowDataChange(rowDataChangedInfo: RowDataChangedInfo): void;
     destroy(): void;
     getCalculatedColumnDataType(calculatedColumnQuery: AdaptableCalculatedColumnQuery): CalculatedColumnSettings['DataType'];
     isCalculatedColumnQueryValid(calculatedColumnQuery: AdaptableCalculatedColumnQuery): boolean;

package/src/Utilities/Services/CalculatedColumnExpressionService.js

@@ -5,37 +5,31 @@ export class CalculatedColumnExpressionService {
         this.adaptableApi = adaptableApi;
         this.aggregatedScalarLiveValuesMap = new Map();
         this.adaptableApi = adaptableApi;
-        this.adaptableApi.internalApi
-            .getDataService()
-            .on('CellDataChanged', (cellDataChangedInfo) => {
-            if (cellDataChangedInfo.trigger === 'aggChange') {
-                // do NOT handle changes on group rows
-                return;
-            }
-            const refreshedCalculatedColumns = [];
-            this.aggregatedScalarLiveValuesMap.forEach((aggregatedScalarLiveValue, calculatedColumnId) => {
-                const calculatedColumn = this.adaptableApi.calculatedColumnApi.getCalculatedColumnById(calculatedColumnId);
-                const columnDependencies = this.adaptableApi.calculatedColumnApi.internalApi.getReferencedColumnIdsForCalculatedColumn(calculatedColumn);
-                if (columnDependencies.includes(cellDataChangedInfo.column.columnId)) {
-                    aggregatedScalarLiveValue.refresh();
-                    refreshedCalculatedColumns.push(calculatedColumn.ColumnId);
-                }
-            });
-            if (refreshedCalculatedColumns.length) {
-                this.adaptableApi.gridApi.refreshCells(null, refreshedCalculatedColumns);
-            }
-        });
-        this.adaptableApi.eventApi.on('GridDataChanged', () => {
-            const refreshedCalculatedColumns = [];
-            this.aggregatedScalarLiveValuesMap.forEach((aggregatedScalarLiveValue, calculatedColumnId) => {
-                const calculatedColumn = this.adaptableApi.calculatedColumnApi.getCalculatedColumnById(calculatedColumnId);
+    }
+    listentoCellDataChange(cellDataChangedInfo) {
+        const refreshedCalculatedColumns = [];
+        this.aggregatedScalarLiveValuesMap.forEach((aggregatedScalarLiveValue, calculatedColumnId) => {
+            const calculatedColumn = this.adaptableApi.calculatedColumnApi.getCalculatedColumnById(calculatedColumnId);
+            const columnDependencies = this.adaptableApi.calculatedColumnApi.internalApi.getReferencedColumnIdsForCalculatedColumn(calculatedColumn);
+            if (columnDependencies.includes(cellDataChangedInfo.column.columnId)) {
                 aggregatedScalarLiveValue.refresh();
                 refreshedCalculatedColumns.push(calculatedColumn.ColumnId);
-            });
-            if (refreshedCalculatedColumns.length) {
-                this.adaptableApi.gridApi.refreshCells(null, refreshedCalculatedColumns);
             }
         });
+        if (refreshedCalculatedColumns.length) {
+            this.adaptableApi.gridApi.refreshColumns(refreshedCalculatedColumns);
+        }
+    }
+    listentoRowDataChange(rowDataChangedInfo) {
+        const refreshedCalculatedColumns = [];
+        this.aggregatedScalarLiveValuesMap.forEach((aggregatedScalarLiveValue, calculatedColumnId) => {
+            const calculatedColumn = this.adaptableApi.calculatedColumnApi.getCalculatedColumnById(calculatedColumnId);
+            aggregatedScalarLiveValue.refresh();
+            refreshedCalculatedColumns.push(calculatedColumn.ColumnId);
+        });
+        if (refreshedCalculatedColumns.length) {
+            this.adaptableApi.gridApi.refreshColumns(refreshedCalculatedColumns);
+        }
     }
     destroy() {
         this.aggregatedScalarLiveValuesMap.clear();
@@ -47,31 +41,31 @@ export class CalculatedColumnExpressionService {
                 // currently AggregatedScalarExpression support only numerical values
                 // TODO AFL try to derive the type from the aggregatedColumn?
                 // we definitely don't want to aggregate everything only to get the data type
-                return 'Number';
+                return 'number';
             }
             let firstRowNode = this.adaptableApi.gridApi.getFirstRowNode();
             let firstRowValue = this.adaptableApi.internalApi
                 .getQueryLanguageService()
                 .evaluateScalarExpression(calculatedColumnQuery.ScalarExpression, CalculatedColumnModuleId, firstRowNode);
             if (firstRowValue instanceof Date) {
-                return 'Date';
+                return 'date';
             }
             if (typeof firstRowValue === 'boolean') {
-                return 'Boolean';
+                return 'boolean';
             }
             if (typeof firstRowValue === 'string') {
-                return 'String';
+                return 'text';
             }
             if (typeof firstRowValue === 'number') {
-                return 'Number';
+                return 'number';
             }
             if (Array.isArray(firstRowValue)) {
-                return 'NumberArray';
+                return 'numberArray';
             }
         }
         catch (e) {
             this.adaptableApi.logError(`Invalid CalculatedColumn expression ${this.adaptableApi.expressionApi.getAdaptableQueryExpression(calculatedColumnQuery)} :: ${e}`);
-            return 'Number';
+            return 'number';
         }
     }
     isCalculatedColumnQueryValid(calculatedColumnQuery) {
@@ -97,40 +91,39 @@ export class CalculatedColumnExpressionService {
         return false;
     }
     evaluateCalculatedColumnQuery(calculatedColumn, rowNode) {
-        var _a, _b, _c, _d, _e;
         try {
             if (this.adaptableApi.gridApi.isGroupRowNode(rowNode)) {
                 return undefined;
             }
             // no validation here, this function has to be as performant as possible
-            if ((_a = calculatedColumn === null || calculatedColumn === void 0 ? void 0 : calculatedColumn.Query) === null || _a === void 0 ? void 0 : _a.ScalarExpression) {
+            if (calculatedColumn?.Query?.ScalarExpression) {
                 return this.adaptableApi.internalApi
                     .getQueryLanguageService()
                     .evaluateScalarExpression(calculatedColumn.Query.ScalarExpression, CalculatedColumnModuleId, rowNode);
             }
-            if ((_b = calculatedColumn === null || calculatedColumn === void 0 ? void 0 : calculatedColumn.Query) === null || _b === void 0 ? void 0 : _b.AggregatedScalarExpression) {
+            if (calculatedColumn?.Query?.AggregatedScalarExpression) {
                 const aggregatedScalarLiveValue = this.aggregatedScalarLiveValuesMap.get(calculatedColumn.Uuid);
-                return aggregatedScalarLiveValue === null || aggregatedScalarLiveValue === void 0 ? void 0 : aggregatedScalarLiveValue.getAggregatedValueForRow(rowNode);
+                return aggregatedScalarLiveValue?.getAggregatedValueForRow(rowNode);
             }
         }
         catch (error) {
-            this.adaptableApi.logError(`Invalid CalculatedColumn expression ${(_d = (_c = calculatedColumn === null || calculatedColumn === void 0 ? void 0 : calculatedColumn.Query) === null || _c === void 0 ? void 0 : _c.ScalarExpression) !== null && _d !== void 0 ? _d : (_e = calculatedColumn === null || calculatedColumn === void 0 ? void 0 : calculatedColumn.Query) === null || _e === void 0 ? void 0 : _e.AggregatedScalarExpression} :: ${error}`);
+            this.adaptableApi.logError(`Invalid CalculatedColumn expression ${calculatedColumn?.Query?.ScalarExpression ??
+                calculatedColumn?.Query?.AggregatedScalarExpression} :: ${error}`);
             return null;
         }
     }
     createAggregatedScalarLiveValue(calculatedColumn) {
-        var _a, _b, _c;
         // if there is already an aggregated scalar, delete it (possible when editing)
         this.destroyAggregatedScalarLiveValue(calculatedColumn);
-        if ((_a = calculatedColumn.Query) === null || _a === void 0 ? void 0 : _a.AggregatedScalarExpression) {
+        if (calculatedColumn.Query?.AggregatedScalarExpression) {
             try {
                 const aggregatedScalarLiveValue = new AggregatedScalarLiveValue({
-                    aggregatedScalarExpression: (_b = calculatedColumn.Query) === null || _b === void 0 ? void 0 : _b.AggregatedScalarExpression,
+                    aggregatedScalarExpression: calculatedColumn.Query?.AggregatedScalarExpression,
                 }, CalculatedColumnModuleId, this.adaptableApi);
                 this.aggregatedScalarLiveValuesMap.set(calculatedColumn.Uuid, aggregatedScalarLiveValue);
             }
             catch (e) {
-                this.adaptableApi.logError(`Creating CalculatedColumn ('${(_c = calculatedColumn.Query) === null || _c === void 0 ? void 0 : _c.AggregatedScalarExpression}') failed!`, e.message);
+                this.adaptableApi.logError(`Creating CalculatedColumn ('${calculatedColumn.Query?.AggregatedScalarExpression}') failed!`, e.message);
             }
         }
     }

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

@@ -1,4 +1,4 @@
-import { AgEventType, ChartModel } from '@ag-grid-community/core';
+import { AgEventType, ChartModel } from 'ag-grid-enterprise';
 import { AdaptableApi } from '../../types';
 import { IChartingService } from './Interface/IChartingService';
 export declare class ChartingService implements IChartingService {