@adaptabletools/adaptable 23.1.0 → 24.0.0-canary.0

package/src/agGrid/AdaptableAgGrid.js

@@ -9,6 +9,7 @@ import Emitter from '../Utilities/Emitter';
 import { applyDefaultAdaptableOptions } from '../AdaptableOptions/DefaultAdaptableOptions';
 import { resolveContainerElement } from '../Utilities/resolveContainerElement';
 import { AgGridAdapter } from './AgGridAdapter';
+import { createAdaptableNotesDataSource } from '../Utilities/Helpers/NotesHelper';
 import * as GeneralConstants from '../Utilities/Constants/GeneralConstants';
 import { AG_GRID_GRAND_TOTAL_ROW_ID, AG_GRID_GROUPED_COLUMN, AG_GRID_SELECTION_COLUMN, AUTOGENERATED_PK_COLUMN, ERROR_LAYOUT, GROUP_PATH_SEPARATOR, HALF_SECOND, QUARTER_SECOND, } from '../Utilities/Constants/GeneralConstants';
 import { generateSelectionColumn } from '../Api/Implementation/ColumnApiImpl';
@@ -16,7 +17,7 @@ import { DataService } from '../Utilities/Services/DataService';
 import { AdaptableStore } from '../Redux/Store/AdaptableStore';
 import { AdaptableApiImpl } from '../Api/Implementation/AdaptableApiImpl';
 import { Fdc3Service } from '../Utilities/Services/Fdc3Service';
-import { AnnotationsService } from '../Utilities/Services/AnnotationsService';
+import { CommentsService } from '../Utilities/Services/CommentsService';
 import { ChartingService } from '../Utilities/Services/ChartingService';
 import { ThemeService } from '../Utilities/Services/ThemeService';
 import { ValidationService } from '../Utilities/Services/ValidationService';
@@ -24,7 +25,8 @@ import { ModuleService } from '../Utilities/Services/ModuleService';
 import { CalculatedColumnExpressionService } from '../Utilities/Services/CalculatedColumnExpressionService';
 import { expandCellDataChangedInfosWithCalculatedColumns } from '../Utilities/Services/CalculatedColumnExpressionService';
 import { QueryLanguageService } from '../Utilities/Services/QueryLanguageService';
-import { AlertService } from '../Utilities/Services/AlertService';
+import { LiveRefreshService } from '../Utilities/Services/LiveRefreshService';
+import { AlertLiveBindingService } from '../Utilities/Services/AlertLiveBindingService';
 import { TeamSharingService } from '../Utilities/Services/TeamSharingService';
 import { LicenseService } from '../Utilities/Services/LicenseService';
 import { ALL_TOOL_PANELS } from '../AdaptableState/Common/Types';
@@ -67,8 +69,8 @@ import { NamedQueryModule } from '../Strategy/NamedQueryModule';
 import { CommentModule } from '../Strategy/CommentModule';
 import { Helper } from '../Utilities/Helpers/Helper';
 import { createUuid } from '../components/utils/uuid';
-import UIHelper from '../View/UIHelper';
-import { getAdaptableToolPanelAgGridComponent } from '../View/Components/ToolPanel/AdaptableToolPanel';
+import UIHelper from '../Utilities/Helpers/UIHelper';
+import { getAdaptableToolPanelAgGridComponent } from '../View/ToolPanel/AdaptableToolPanel';
 import { ADAPTABLE_STATUS_PANEL } from '../AdaptableState/StatusBarState';
 import { AdaptableStatusBar } from '../View/StatusBar/AdaptableStatusBar';
 import ArrayExtensions from '../Utilities/Extensions/ArrayExtensions';
@@ -87,18 +89,19 @@ import { stripDeprecatedStateKeys } from '../migration/DeprecatedStateKeys';
 import { ensureLoadingScreenPortalElement } from '../components/Modal';
 import { AdaptableLoadingScreen } from '../View/Components/Popups/AdaptableLoadingScreen';
 import { createElement } from 'react';
-import { createAgStatusPanelComponent } from '../Utilities/createAgStatusPanelComponent';
+import { createAgStatusPanelComponent } from './AgGridStatusPanelCreator';
 import { only } from '../AdaptableState/Aggregations/only';
 import { weightedAverage } from '../AdaptableState/Aggregations/weightedAverage';
 import { ROW_SUMMARY_ROW_ID } from '../AdaptableState/Common/RowSummary';
 import { FlashingCellService } from '../Utilities/Services/FlashingCellService';
 import { AgGridExportAdapter } from './AgGridExportAdapter';
-import { checkForDuplicateColumns, resetLayoutHelperErrorOnceMessages, getLayoutRowGroupValuesExceptionGroupKeys, isPivotLayout, layoutModelToLayoutState, layoutStateToLayoutModel, normalizeLayout, } from '../Api/Implementation/LayoutHelpers';
+import { checkForDuplicateColumns, resetLayoutHelperErrorOnceMessages, getLayoutRowGroupValuesExceptionGroupKeys, isPivotLayout, layoutModelToLayoutState, layoutStateToLayoutModel, normalizeLayout, } from '../Utilities/Helpers/Layouts/LayoutHelper';
+import { applyAutoCreatedLayout, buildLayoutFromColDefs, resolveAutoCreateLayoutConfig, } from '../Utilities/Helpers/Layouts/AutoCreateLayoutHelper';
 import { LayoutManager } from '../layout-manager/src';
 import { rowGroupDisplayTypeToGridOption } from '../layout-manager/src/rowGroupDisplayType';
 import { isPivotLayoutModel } from '../layout-manager/src/isPivotLayoutModel';
 import { ACTION_COLUMN_TYPE, CALCULATED_COLUMN_TYPE, FDC3_COLUMN_TYPE, FREE_TEXT_COLUMN_TYPE, HIDDEN_COLUMN_TYPE, hiddenColDefConfig, PIVOT_AGGREGATION_TOTAL_COLUMN_TYPE, PIVOT_ANY_TOTAL_COLUMN_TYPE, PIVOT_COLUMN_TOTAL_COLUMN_TYPE, PIVOT_GRAND_TOTAL_COLUMN_TYPE, } from '../AdaptableState/Common/AdaptableColumn';
-import { agGridDataTypeDefinitions } from './agGridDataTypeDefinitions';
+import { mergeDataTypeDefinitions } from './AgGridCellDataTypeHelper';
 import { AgGridThemeAdapter } from './AgGridThemeAdapter';
 import { mapOldTypeToDataType } from '../migration/VersionUpgrade20';
 import { tagProvidedByAdaptable } from '../Utilities/adaptableOverrideCheck';
@@ -106,9 +109,9 @@ import { AgGridModulesAdapter } from './AgGridModulesAdapter';
 import { getMarker } from '../devTools';
 import { DeepMap } from '@infinite-table/infinite-react';
 import { DateFormatter } from '../Utilities/Helpers/DisplayFormatHelper';
-import { clearPredicateDefMapMemo } from '../Api/Implementation/PredicateApiImpl';
 import { AgGridFilterAdapterFactory } from './AgGridFilterAdapter';
 import { AdaptableFilterHandler } from './AdaptableFilterHandler';
+import { getColumnFilterInListValues } from '../aql/columnFilterQl';
 import { AgGridFloatingFilterAdapterFactory } from './AgGridFloatingFilterAdapter';
 import { listenForDevTools } from '../setupDevTools';
 const publishTimestamp = Number(ADAPTABLE_PUBLISH_TIMESTAMP);
@@ -141,16 +144,18 @@ export class AdaptableAgGrid {
     ModuleService;
     ValidationService;
     QueryLanguageService;
-    AlertService;
+    LiveRefreshService;
+    AlertLiveBindingService;
     TeamSharingService;
     RowFormService;
     Fdc3Service;
-    AnnotationsService;
+    CommentsService;
     FlashingCellService;
     ThemeService;
     LicenseService;
     ChartingService;
     isListeningToAgGridRowNodeEvents = false;
+    offScreenRowUpdateTrackers = [];
     debouncedSetSelectedRows;
     debouncedSetSelectedCells;
     agGridListenerKeydown;
@@ -164,6 +169,10 @@ export class AdaptableAgGrid {
     listenerCellSelectionChanged;
     listenerSortChanged;
     listenerColumnGroupOpened;
+    listenerCellDoubleClicked;
+    listenerCellClicked;
+    listenerCellValueChanged;
+    unsubscribeFormulaTraceLayoutChanged = null;
     layoutManager;
     rowSelectionCheckboxesOverride = null;
     columnMinMaxValuesCache = {};
@@ -317,18 +326,7 @@ export class AdaptableAgGrid {
         await this.adaptableStore.loadStore({
             adaptable: this,
             adaptableStateKey: this.adaptableOptions.adaptableStateKey,
-            postLoadHook: (state) => {
-                if (this.adaptableOptions.stateOptions.autoMigrateState) {
-                    this.api.logError;
-                    const config = {
-                        fromVersion: 16,
-                        logger: this.logger,
-                    };
-                    state = AdaptableUpgradeHelper.migrateAdaptableState(state, config);
-                }
-                state = this.normalizeAdaptableState(state, config.gridOptions);
-                return state;
-            },
+            postLoadHook: this.buildPostLoadHook(config.gridOptions),
         });
         perfLoadStore.end();
         loadStoreMarker.end();
@@ -346,6 +344,7 @@ export class AdaptableAgGrid {
                 this.logger.consoleError(`Column "${colDef.colId}" uses cellDataType="dateString" which is no longer supported. It has been replaced with cellDataType="date". Please update your column definition.`);
                 colDef.cellDataType = 'date';
             }
+            this.disableUnsupportedAdaptableFilter(colDef, String(colDef.colId ?? colDef.field ?? ''));
         });
         gridOptions.columnDefs = columnDefs;
         this.setInitialGridOptions(gridOptions, config.variant);
@@ -473,6 +472,23 @@ export class AdaptableAgGrid {
             unmount: false,
         });
     }
+    migrateLoadedAdaptableState(state) {
+        if (!this.adaptableOptions.stateOptions.autoMigrateState) {
+            return state;
+        }
+        const upgradeConfig = {
+            fromVersion: 16,
+            logger: this.logger,
+            layoutTagOptions: this.adaptableOptions.layoutOptions?.layoutTagOptions,
+        };
+        return AdaptableUpgradeHelper.migrateAdaptableState(state, upgradeConfig);
+    }
+    buildPostLoadHook(gridOptions) {
+        return (state) => {
+            state = this.migrateLoadedAdaptableState(state);
+            return this.normalizeAdaptableState(state, gridOptions);
+        };
+    }
     normalizeAdaptableState(state, agGridOptions) {
         state = stripDeprecatedStateKeys(state, this.logger);
         state = this.normaliseLayoutState(state, agGridOptions);
@@ -480,16 +496,42 @@ export class AdaptableAgGrid {
         return state;
     }
     normaliseLayoutState(state, gridOptions) {
-        const layoutState = state.Layout;
-        if (!layoutState || !layoutState.Layouts?.length) {
+        const autoCreateConfig = resolveAutoCreateLayoutConfig(this.adaptableOptions.layoutOptions?.autoCreateLayout);
+        const existingLayouts = state.Layout?.Layouts;
+        const hasLayouts = !!existingLayouts?.length;
+        const hasNamedLayout = !!existingLayouts?.some((layout) => layout.Name === autoCreateConfig?.name);
+        const shouldAutoCreate = !!autoCreateConfig && (!hasLayouts || (autoCreateConfig.createEveryLoad && hasNamedLayout));
+        if (shouldAutoCreate) {
+            const derived = buildLayoutFromColDefs(autoCreateConfig.name, {
+                columnDefs: gridOptions.columnDefs,
+                defaultColDef: gridOptions.defaultColDef,
+                pivotMode: gridOptions.pivotMode,
+                rowModelType: gridOptions.rowModelType,
+            });
+            const createdLayout = this.api?.layoutApi?.internalApi
+                ? this.api.layoutApi.internalApi.buildAutoCreatedLayout(derived)
+                : derived;
+            const nextLayouts = applyAutoCreatedLayout(existingLayouts, createdLayout);
+            state.Layout = {
+                ...(state.Layout ?? {}),
+                CurrentLayout: state.Layout?.CurrentLayout || autoCreateConfig.name,
+                Layouts: nextLayouts,
+            };
+        }
+        else if (!hasLayouts) {
             this.logger.consoleError('No Layouts defined in InitialState.Layout.Layouts[]. At least one Layout is required.');
         }
-        if (!layoutState.CurrentLayout ||
-            !layoutState.Layouts.find((l) => l.Name === layoutState.CurrentLayout)) {
-            layoutState.CurrentLayout = layoutState.Layouts?.[0]?.Name;
+        else if (autoCreateConfig && !autoCreateConfig.createEveryLoad) {
+            this.logger.info('layoutOptions.autoCreateLayout is set but Layouts already exist; the option is ignored.');
+        }
+        const layoutState = state.Layout;
+        if (layoutState?.Layouts?.length &&
+            (!layoutState.CurrentLayout ||
+                !layoutState.Layouts.find((l) => l.Name === layoutState.CurrentLayout))) {
+            layoutState.CurrentLayout = layoutState.Layouts[0].Name;
         }
         if (gridOptions.rowModelType === 'viewport') {
-            if (state.Layout.Layouts) {
+            if (state.Layout?.Layouts) {
                 state.Layout.Layouts = state.Layout.Layouts.filter((layout) => {
                     if (isPivotLayout(layout)) {
                         return false;
@@ -504,36 +546,11 @@ export class AdaptableAgGrid {
                 });
             }
         }
-        if (state.Layout.Layouts) {
+        if (state.Layout?.Layouts) {
             const normalizeOptions = {
                 isTree: !!gridOptions.treeData,
             };
             state.Layout.Layouts = state.Layout.Layouts.map((layout) => normalizeLayout(layout, normalizeOptions));
-            state.Layout.Layouts = state.Layout.Layouts.map((layout) => {
-                if (Array.isArray(layout.ColumnFilters)) {
-                    layout.ColumnFilters = layout.ColumnFilters.map((columnFilter) => {
-                        if (columnFilter.ColumnId === AG_GRID_GROUPED_COLUMN) {
-                            if (Array.isArray(columnFilter.Predicates)) {
-                                columnFilter.Predicates = columnFilter.Predicates.map((predicate) => {
-                                    if (predicate.PredicateId === 'In' || predicate.PredicateId === 'NotIn') {
-                                        if (Array.isArray(predicate.Inputs)) {
-                                            predicate.Inputs = predicate.Inputs.map((input) => {
-                                                if (!Array.isArray(input)) {
-                                                    return [input];
-                                                }
-                                                return input;
-                                            });
-                                        }
-                                    }
-                                    return predicate;
-                                });
-                            }
-                        }
-                        return columnFilter;
-                    });
-                }
-                return layout;
-            });
         }
         return state;
     }
@@ -755,6 +772,7 @@ export class AdaptableAgGrid {
                 return original_defaultColDef;
             }
             const defaultColDef = { ...original_defaultColDef };
+            this.disableUnsupportedAdaptableFilter(defaultColDef, 'defaultColDef');
             defaultColDef.headerValueGetter = tagProvidedByAdaptable((params) => {
                 const columnHeaderName = this.api.columnApi.internalApi.getColumnHeaderName(params);
                 const formattedHeaderName = this.api.formatColumnApi.internalApi.formatColumnHeaderName(columnHeaderName, params);
@@ -953,11 +971,37 @@ export class AdaptableAgGrid {
             }
             return original_suppressSetFilterByDefault;
         });
+        let gridFilterPassPlan;
+        const resolveGridFilterPassPlan = () => {
+            const expression = this.api.filterApi.gridFilterApi.getCurrentGridFilterExpression();
+            if (gridFilterPassPlan && gridFilterPassPlan.expression === expression) {
+                return gridFilterPassPlan;
+            }
+            let passes;
+            if (StringExtensions.IsNotNullOrEmpty(expression)) {
+                const evaluateGridFilterOnClient = this.api.expressionApi.internalApi.evaluateExpressionInAdaptableQL('GridFilter', undefined, expression);
+                if (evaluateGridFilterOnClient) {
+                    const isCurrentGridFilterValid = this.api.expressionApi.isValidScalarExpression(expression, GridFilterModuleId, `Invalid Grid Filter '${expression}'`);
+                    if (!isCurrentGridFilterValid) {
+                        passes = () => false;
+                    }
+                    else {
+                        const evaluate = this.api.internalApi
+                            .getQueryLanguageService()
+                            .prepareBooleanRowEvaluator(expression, GridFilterModuleId);
+                        passes = (node) => Boolean(evaluate(node));
+                    }
+                }
+            }
+            gridFilterPassPlan = { expression, passes };
+            return gridFilterPassPlan;
+        };
         this.agGridOptionsService.setGridOptionsProperty(gridOptions, 'isExternalFilterPresent', (original_isExternalFilterPresent) => {
             return (params) => {
                 if (!this.isAvailable) {
                     return false;
                 }
+                gridFilterPassPlan = undefined;
                 const isGridFilterActive = StringExtensions.IsNotNullOrEmpty(this.api.filterApi.gridFilterApi.getCurrentGridFilterExpression());
                 return (isGridFilterActive ||
                     (original_isExternalFilterPresent ? original_isExternalFilterPresent(params) : false));
@@ -982,21 +1026,9 @@ export class AdaptableAgGrid {
                 if (!isRowFilterable) {
                     return true;
                 }
-                const currentGridFilterExpression = this.api.filterApi.gridFilterApi.getCurrentGridFilterExpression();
-                if (StringExtensions.IsNotNullOrEmpty(currentGridFilterExpression)) {
-                    const evaluateGridFilterOnClient = this.api.expressionApi.internalApi.evaluateExpressionInAdaptableQL('GridFilter', undefined, currentGridFilterExpression);
-                    if (evaluateGridFilterOnClient) {
-                        const isCurrentGridFilterValid = this.api.expressionApi.isValidBooleanExpression(currentGridFilterExpression, GridFilterModuleId, `Invalid Grid Filter '${currentGridFilterExpression}'`);
-                        if (!isCurrentGridFilterValid) {
-                            return false;
-                        }
-                        const gridFilterEvaluationResult = this.api.internalApi
-                            .getQueryLanguageService()
-                            .evaluateBooleanExpression(currentGridFilterExpression, GridFilterModuleId, node);
-                        if (!gridFilterEvaluationResult) {
-                            return false;
-                        }
-                    }
+                const gridFilterPasses = resolveGridFilterPassPlan().passes;
+                if (gridFilterPasses && !gridFilterPasses(node)) {
+                    return false;
                 }
                 const result = original_doesExternalFilterPass
                     ? original_doesExternalFilterPass(node)
@@ -1212,16 +1244,24 @@ export class AdaptableAgGrid {
             }
             return patchedColumnTypes;
         });
-        this.agGridOptionsService.setGridOptionsProperty(gridOptions, 'dataTypeDefinitions', () => {
-            const revertedDateTypeDefinitions = agGridDataTypeDefinitions;
-            return revertedDateTypeDefinitions;
-        });
+        this.agGridOptionsService.setGridOptionsProperty(gridOptions, 'dataTypeDefinitions', (userDefinitions) => mergeDataTypeDefinitions(userDefinitions));
         this.agGridOptionsService.setGridOptionsProperty(gridOptions, 'findOptions', (original_findOptions) => {
             return {
                 ...original_findOptions,
                 caseSensitive: !!this.adaptableOptions.quickSearchOptions.isQuickSearchCaseSensitive,
             };
         });
+        this.agGridOptionsService.setGridOptionsProperty(gridOptions, 'notesDataSource', (original_notesDataSource) => {
+            if (original_notesDataSource) {
+                return original_notesDataSource;
+            }
+            const canUseAgGridNotes = StringExtensions.IsNotNullOrEmpty(this.adaptableOptions.primaryKey) &&
+                !this.hasAutogeneratedPrimaryKey;
+            if (!canUseAgGridNotes) {
+                return original_notesDataSource;
+            }
+            return createAdaptableNotesDataSource(this.api);
+        });
         this.agGridOptionsService.setGridOptionsProperty(gridOptions, 'suppressOverlays', (original_suppressOverlays) => {
             let suppressOverlays = original_suppressOverlays || [];
             if (!suppressOverlays.includes('exporting')) {
@@ -1407,7 +1447,12 @@ export class AdaptableAgGrid {
     addGridEventListeners() {
         const gridContainerElement = this.getAgGridContainerElement();
         if (gridContainerElement) {
-            gridContainerElement.addEventListener('keydown', (this.agGridListenerKeydown = (event) => this._emit('KeyDown', event)), true);
+            gridContainerElement.addEventListener('keydown', (this.agGridListenerKeydown = (event) => {
+                if (event.key === 'Escape') {
+                    this.api.calculatedColumnApi.internalApi.hideFormulaTrace();
+                }
+                this._emit('KeyDown', event);
+            }), true);
             gridContainerElement.addEventListener('mouseenter', (this.agGridListenerMouseEnter = (event) => {
                 this._emit('MouseEnter', event);
             }), true);
@@ -1476,6 +1521,49 @@ export class AdaptableAgGrid {
             this.debouncedSetSelectedCells();
             this.api.eventApi.internalApi.fireGridSortedEvent();
         }));
+        this.agGridAdapter.getAgGridApi().addEventListener('cellDoubleClicked', (this.listenerCellDoubleClicked = (event) => {
+            const enableDoubleClick = this.api.optionsApi.getCalculatedColumnOptions()?.formulaTrace?.enableDoubleClick !==
+                false;
+            if (!enableDoubleClick) {
+                return;
+            }
+            const columnId = event?.column?.getColId?.();
+            const rowNode = event?.node;
+            if (!columnId || !rowNode || this.isGroupRowNode(rowNode)) {
+                return;
+            }
+            const calculatedColumn = this.api.calculatedColumnApi.getCalculatedColumnForColumnId(columnId);
+            if (!calculatedColumn) {
+                return;
+            }
+            this.api.calculatedColumnApi.internalApi.showFormulaTrace(calculatedColumn, rowNode);
+        }));
+        this.agGridAdapter.getAgGridApi().addEventListener('cellClicked', (this.listenerCellClicked = (event) => {
+            const formulaTraceInfo = this.api.calculatedColumnApi.internalApi.getFormulaTraceInfo();
+            if (!formulaTraceInfo) {
+                return;
+            }
+            if (this.api.calculatedColumnApi.internalApi.getCompactCalculatedColumnEditorInfo()) {
+                return;
+            }
+            const columnId = event?.column?.getColId?.();
+            const rowNode = event?.node;
+            if (!columnId || !rowNode) {
+                return;
+            }
+            const primaryKeyValue = this.getPrimaryKeyValueFromRowNode(rowNode);
+            const isSameCalculatedCell = columnId === formulaTraceInfo.calculatedColumnId &&
+                primaryKeyValue === formulaTraceInfo.primaryKeyValue;
+            if (!isSameCalculatedCell) {
+                this.api.calculatedColumnApi.internalApi.hideFormulaTrace();
+            }
+        }));
+        this.unsubscribeFormulaTraceLayoutChanged = this.api.eventApi.on('LayoutChanged', () => {
+            if (this.api.calculatedColumnApi.internalApi.getCompactCalculatedColumnEditorInfo()) {
+                return;
+            }
+            this.api.calculatedColumnApi.internalApi.hideFormulaTrace();
+        });
         const eventsThatTriggerChartingChanges = [
             'chartCreated',
             'chartRangeSelectionChanged',
@@ -1499,6 +1587,9 @@ export class AdaptableAgGrid {
             };
             this.agGridAdapter.getAgGridApi().addGlobalListener(this.listenerGlobalChartingChanges);
         }
+        this.agGridAdapter.getAgGridApi().addEventListener('cellValueChanged', (this.listenerCellValueChanged = (event) => {
+            this.onAgGridCellValueChanged(event);
+        }));
         this.isListeningToAgGridRowNodeEvents = true;
     }
     onAgGridRowNodeEvent(event) {
@@ -1507,6 +1598,7 @@ export class AdaptableAgGrid {
         }
         if (event.type === 'dataChanged') {
             const { node, oldData, newData } = event;
+            this.noteRowNodeDataChanged(node?.id);
             this.onRowDataChanged({ rowNode: node, oldData, newData });
             return;
         }
@@ -1517,6 +1609,40 @@ export class AdaptableAgGrid {
             }
         }
     }
+    onAgGridCellValueChanged(event) {
+        if (!this.isListeningToAgGridRowNodeEvents) {
+            return;
+        }
+        if (this.offScreenRowUpdateTrackers.length > 0) {
+            return;
+        }
+        const node = event.node;
+        const column = event.column;
+        if (!node || !column) {
+            return;
+        }
+        if (node.__localEventService) {
+            return;
+        }
+        if (node.rowPinned != null &&
+            node.pinnedSibling) {
+            return;
+        }
+        this.onCellDataChanged({
+            rowNode: node,
+            oldValue: event.oldValue,
+            newValue: event.newValue,
+            colId: column.getColId(),
+        });
+    }
+    noteRowNodeDataChanged(rowId) {
+        if (rowId == null || this.offScreenRowUpdateTrackers.length === 0) {
+            return;
+        }
+        for (const tracker of this.offScreenRowUpdateTrackers) {
+            tracker.seenIds.add(rowId);
+        }
+    }
     shouldAutoSizeLayout() {
         const { layoutApi } = this.api;
         const currentLayout = layoutApi.getCurrentLayout();
@@ -1567,10 +1693,11 @@ export class AdaptableAgGrid {
         this.ModuleService = new ModuleService(this.api);
         this.CalculatedColumnExpressionService = new CalculatedColumnExpressionService(this.api);
         this.QueryLanguageService = new QueryLanguageService(this.api);
-        this.AlertService = new AlertService(this.api);
+        this.LiveRefreshService = new LiveRefreshService(this.api);
+        this.AlertLiveBindingService = new AlertLiveBindingService(this.api);
         this.TeamSharingService = new TeamSharingService(this.api);
         this.Fdc3Service = new Fdc3Service(this.api);
-        this.AnnotationsService = new AnnotationsService(this.api);
+        this.CommentsService = new CommentsService(this.api);
         this.FlashingCellService = new FlashingCellService(this.api);
         this.RowFormService = new RowFormService(this.api);
     }
@@ -2146,16 +2273,83 @@ export class AdaptableAgGrid {
     applyAgGridTransaction(transaction) {
         const isServerSideRowModel = this.getAgGridRowModelType() === 'serverSide';
         const agGridApi = this.agGridAdapter.getAgGridApi();
-        return isServerSideRowModel
-            ? agGridApi.applyServerSideTransaction(transaction)
-            : agGridApi.applyTransaction(transaction);
+        if (isServerSideRowModel) {
+            return agGridApi.applyServerSideTransaction(transaction);
+        }
+        const tracking = this.beginOffScreenRowUpdateTracking(transaction.update);
+        try {
+            const result = agGridApi.applyTransaction(transaction);
+            this.emitOffScreenRowUpdates(tracking, result?.update);
+            return result;
+        }
+        finally {
+            this.endOffScreenRowUpdateTracking(tracking);
+        }
     }
     applyAgGridTransactionAsync(transaction, callback) {
         const isServerSideRowModel = this.getAgGridRowModelType() === 'serverSide';
         const agGridApi = this.agGridAdapter.getAgGridApi();
-        return isServerSideRowModel
-            ? agGridApi.applyServerSideTransactionAsync(transaction, callback)
-            : agGridApi.applyTransactionAsync(transaction, callback);
+        if (isServerSideRowModel) {
+            return agGridApi.applyServerSideTransactionAsync(transaction, callback);
+        }
+        const tracking = this.beginOffScreenRowUpdateTracking(transaction.update);
+        const wrappedCallback = (result) => {
+            try {
+                this.emitOffScreenRowUpdates(tracking, result?.update);
+            }
+            finally {
+                this.endOffScreenRowUpdateTracking(tracking);
+            }
+            callback(result);
+        };
+        return agGridApi.applyTransactionAsync(transaction, wrappedCallback);
+    }
+    beginOffScreenRowUpdateTracking(updateRows) {
+        if (!updateRows?.length || !this.isListeningToAgGridRowNodeEvents) {
+            return undefined;
+        }
+        const primaryKey = this.adaptableOptions.primaryKey;
+        const oldDataByPk = new Map();
+        for (const row of updateRows) {
+            if (row == null || row[primaryKey] == null) {
+                continue;
+            }
+            const node = this.getRowNodeForPrimaryKey(row[primaryKey]);
+            if (node?.data) {
+                oldDataByPk.set(row[primaryKey], { ...node.data });
+            }
+        }
+        const tracking = {
+            seenIds: new Set(),
+            oldDataByPk,
+        };
+        this.offScreenRowUpdateTrackers.push(tracking);
+        return tracking;
+    }
+    endOffScreenRowUpdateTracking(tracking) {
+        if (!tracking) {
+            return;
+        }
+        const index = this.offScreenRowUpdateTrackers.lastIndexOf(tracking);
+        if (index >= 0) {
+            this.offScreenRowUpdateTrackers.splice(index, 1);
+        }
+    }
+    emitOffScreenRowUpdates(tracking, updatedNodes) {
+        if (!tracking || !updatedNodes?.length) {
+            return;
+        }
+        for (const node of updatedNodes) {
+            if (!node || (node.id != null && tracking.seenIds.has(node.id))) {
+                continue;
+            }
+            const primaryKeyValue = this.getPrimaryKeyValueFromRowNode(node);
+            const oldData = tracking.oldDataByPk.get(primaryKeyValue);
+            if (oldData == null) {
+                continue;
+            }
+            this.onRowDataChanged({ rowNode: node, oldData, newData: node.data });
+        }
     }
     updateRows(dataRows, dataUpdateConfig) {
         if (this.hasAutogeneratedPrimaryKey) {
@@ -2412,9 +2606,7 @@ export class AdaptableAgGrid {
         const columnFilterApi = this.api.filterApi.columnFilterApi;
         const columnFilter = columnFilterApi.getColumnFilterForColumn(column.columnId);
         const filterHandler = columnFilterApi.internalApi.getAdaptableFilterHandler(column.columnId);
-        const inputs = (columnFilter?.Predicates ?? [])
-            .filter((predicate) => predicate.PredicateId === 'In' || predicate.PredicateId === 'NotIn')
-            .flatMap((predicate) => (Array.isArray(predicate.Inputs) ? predicate.Inputs : []));
+        const inputs = getColumnFilterInListValues(columnFilter);
         return inputs.map((value) => {
             const known = filterHandler?.getRememberedLazyInFilterValue(value);
             return known ?? { value, label: value == null ? '' : String(value) };
@@ -2667,7 +2859,7 @@ export class AdaptableAgGrid {
         const topLevelGridCells = [];
         const treeDeepMap = new DeepMap();
         const isPivotResultColumn = column.isGeneratedPivotResultColumn;
-        const includeTime = this.api.predicateApi.internalApi.shouldEvaluateInPredicateUsingTime(column.columnId);
+        const includeTime = this.api.expressionApi.shouldEvaluateDatesUsingTime(column.columnId);
         const colId = column.columnId;
         const rowNodeCallback = (rowNode) => {
             if (!rowNode) {
@@ -2869,7 +3061,7 @@ export class AdaptableAgGrid {
     getUniqueGridCells(column, gridCells) {
         let gridCellsToUse = gridCells;
         const cache = new Map();
-        const lowercase = this.api.predicateApi.useCaseSensitivity(column.columnId);
+        const lowercase = !this.api.expressionApi.useCaseSensitivity();
         const getter = (dataItem) => {
             let value = dataItem.rawValue;
             if (value instanceof Date) {
@@ -3034,7 +3226,14 @@ export class AdaptableAgGrid {
     }
     selectNodes(rowNodes, clearSelection) {
         if (ArrayExtensions.IsNotNullOrEmpty(rowNodes)) {
-            rowNodes.forEach((node) => this.selectNode(node, clearSelection));
+            let shouldClearSelection = clearSelection;
+            rowNodes.forEach((node) => {
+                if (!node) {
+                    return;
+                }
+                this.selectNode(node, shouldClearSelection);
+                shouldClearSelection = false;
+            });
         }
     }
     deSelectNodes(rowNodes, clearSelection) {
@@ -3409,7 +3608,6 @@ export class AdaptableAgGrid {
         this.layoutManager?.destroy();
         this.layoutManager = null;
         this.rowSelectionCheckboxesOverride = null;
-        clearPredicateDefMapMemo();
         const agGridApi = this.agGridAdapter?.getAgGridApi();
         if (agGridApi && !agGridApi.isDestroyed()) {
             agGridApi.removeEventListener('firstDataRendered', this.listenerFirstDataRendered);
@@ -3418,6 +3616,9 @@ export class AdaptableAgGrid {
             agGridApi.removeEventListener('cellSelectionChanged', this.listenerCellSelectionChanged);
             agGridApi.removeEventListener('columnGroupOpened', this.listenerColumnGroupOpened);
             agGridApi.removeEventListener('sortChanged', this.listenerSortChanged);
+            agGridApi.removeEventListener('cellDoubleClicked', this.listenerCellDoubleClicked);
+            agGridApi.removeEventListener('cellClicked', this.listenerCellClicked);
+            agGridApi.removeEventListener('cellValueChanged', this.listenerCellValueChanged);
             agGridApi.removeGlobalListener(this.listenerGlobalSetRowSelection);
             if (this.listenerGlobalChartingChanges) {
                 this.agGridAdapter.getAgGridApi().removeGlobalListener(this.listenerGlobalChartingChanges);
@@ -3429,6 +3630,13 @@ export class AdaptableAgGrid {
             this.listenerCellSelectionChanged = null;
             this.listenerGlobalSetRowSelection = null;
             this.listenerSortChanged = null;
+            this.listenerCellDoubleClicked = null;
+            this.listenerCellClicked = null;
+            this.listenerCellValueChanged = null;
+            if (this.unsubscribeFormulaTraceLayoutChanged) {
+                this.unsubscribeFormulaTraceLayoutChanged();
+                this.unsubscribeFormulaTraceLayoutChanged = null;
+            }
             const liveGridOptions = this.agGridAdapter.DANGER_getLiveGridOptions();
             if (liveGridOptions) {
                 this.agGridOptionsService.revertGridOptionsPropertiesToUserValue(liveGridOptions, [
@@ -3457,6 +3665,8 @@ export class AdaptableAgGrid {
                     liveGridOptions.components.AdaptableToolPanel = null;
                 }
             }
+            const columns = agGridApi.getAllGridColumns() ?? agGridApi.getColumns() ?? [];
+            this.agGridColumnAdapter?.revertColDefPropertiesToUserValues(columns);
         }
         if (config?.destroyAgGrid === true) {
             this.agGridAdapter.getAgGridApi()?.destroy();
@@ -3520,10 +3730,12 @@ export class AdaptableAgGrid {
         this.ModuleService = null;
         this.ValidationService?.destroy?.();
         this.ValidationService = null;
+        this.LiveRefreshService?.destroy?.();
+        this.LiveRefreshService = null;
+        this.AlertLiveBindingService?.destroy?.();
+        this.AlertLiveBindingService = null;
         this.QueryLanguageService?.destroy?.();
         this.QueryLanguageService = null;
-        this.AlertService?.destroy?.();
-        this.AlertService = null;
         this.TeamSharingService?.destroy?.();
         this.TeamSharingService = null;
         this.RowFormService?.destroy?.();
@@ -3536,8 +3748,8 @@ export class AdaptableAgGrid {
         this.ThemeService = null;
         this.ChartingService?.destroy?.();
         this.ChartingService = null;
-        this.AnnotationsService?.destroy?.();
-        this.AnnotationsService = null;
+        this.CommentsService?.destroy?.();
+        this.CommentsService = null;
         this.unmountLoadingScreen?.();
         this.unmountLoadingScreen = null;
     }
@@ -3683,7 +3895,7 @@ export class AdaptableAgGrid {
             return;
         }
         const primaryKeyValue = this.getPrimaryKeyValueFromRowNode(rowNode);
-        if (!primaryKeyValue) {
+        if (primaryKeyValue == null) {
             return;
         }
         let cellDataChangedInfos = [];
@@ -3730,7 +3942,7 @@ export class AdaptableAgGrid {
             return;
         }
         const primaryKeyValue = this.getPrimaryKeyValueFromRowNode(rowNode);
-        if (!primaryKeyValue) {
+        if (primaryKeyValue == null) {
             return;
         }
         const cellDataChangedInfo = this.api.internalApi.buildCellDataChangedInfo({
@@ -3764,8 +3976,7 @@ export class AdaptableAgGrid {
             this.DataService.CreateCellDataChangedEvent(cellDataChangedInfo);
             this.resetMinMaxCachedValueForColumn(cellDataChangedInfo.column);
         });
-        this.refreshCellsBasedOnCellDataChange(rowNode, cellDataChangedInfos);
-        this.refreshColumnsBasedOnCellDataChange(cellDataChangedInfos);
+        this.applyPostEditRefresh(rowNode, this.collectPostEditRefreshScope(rowNode, cellDataChangedInfos));
         const colIds = cellDataChangedInfos.map((c) => c.column.columnId);
         const { columnFilterApi, gridFilterApi } = this.api.filterApi;
         const isGridFilterActive = !!gridFilterApi.getCurrentGridFilterExpression();
@@ -3775,36 +3986,65 @@ export class AdaptableAgGrid {
             this.filterOnDataChange();
         }
     }
-    refreshCellsBasedOnCellDataChange(rowNode, cellDataChangedInfos) {
-        if (this.agGridAdapter.isVisibleNode(rowNode)) {
-            let dataChangedScope = {
-                wholeRow: false,
-                columnIds: new Set(),
-            };
-            this.checkFormatColumnExpressionStyleChanges(dataChangedScope, cellDataChangedInfos);
-            if (dataChangedScope.wholeRow) {
-                this.redrawRow(rowNode);
-                return;
-            }
-            this.checkFormatColumnPredicateStyleChanges(dataChangedScope, cellDataChangedInfos);
-            this.checkFreeTextColumnChanges(dataChangedScope, cellDataChangedInfos);
-            this.checkStyledColumnComparisonChanges(dataChangedScope, cellDataChangedInfos);
-            if (dataChangedScope.columnIds.size > 0) {
-                this.refreshCells(rowNode, Array.from(dataChangedScope.columnIds.values()), true);
+    collectPostEditRefreshScope(rowNode, cellDataChangedInfos) {
+        const scope = {
+            wholeRow: false,
+            columnIds: new Set(),
+            allRowsColumnIds: new Set(),
+        };
+        const isVisible = this.agGridAdapter.isVisibleNode(rowNode);
+        if (isVisible) {
+            this.checkFormatColumnExpressionStyleChanges(scope, cellDataChangedInfos);
+            if (!scope.wholeRow) {
+                this.checkFormatColumnPredicateStyleChanges(scope, cellDataChangedInfos);
+                this.checkFreeTextColumnChanges(scope, cellDataChangedInfos);
+                this.checkStyledColumnComparisonChanges(scope, cellDataChangedInfos);
+            }
+        }
+        const expressionService = this.api.internalApi.getCalculatedColumnExpressionService();
+        cellDataChangedInfos.forEach((info) => {
+            if (!info.preventEdit && info.trigger !== 'aggChange') {
+                const columnId = info.column?.columnId;
+                if (columnId !== undefined) {
+                    expressionService
+                        .getObservableCalculatedColumnsAffectedByColumn(columnId)
+                        .forEach((affected) => {
+                        if (affected.rowIndependent) {
+                            scope.allRowsColumnIds.add(affected.columnId);
+                        }
+                        else if (isVisible) {
+                            scope.columnIds.add(affected.columnId);
+                        }
+                    });
+                }
             }
-        }
-    }
-    refreshColumnsBasedOnCellDataChange(cellDataChangedInfos) {
-        const columnIdsToUpdate = [];
-        cellDataChangedInfos.forEach((cellDataChangeInfo) => {
-            const styledColumn = this.api.styledColumnApi.getActiveStyledColumnForColumn(cellDataChangeInfo.column);
+            const styledColumn = this.api.styledColumnApi.getActiveStyledColumnForColumn(info.column);
             if (styledColumn &&
                 this.api.styledColumnApi.internalApi.hasStyledColumnRelativeCellRange(styledColumn)) {
-                columnIdsToUpdate.push(styledColumn.ColumnId);
+                scope.allRowsColumnIds.add(styledColumn.ColumnId);
             }
         });
-        if (ArrayExtensions.IsNotNullOrEmpty(columnIdsToUpdate)) {
-            this.refreshColumns(columnIdsToUpdate, true);
+        scope.allRowsColumnIds.forEach((columnId) => {
+            scope.columnIds.delete(columnId);
+        });
+        return scope;
+    }
+    applyPostEditRefresh(rowNode, scope) {
+        const { wholeRow, columnIds, allRowsColumnIds } = scope;
+        if (allRowsColumnIds.size > 0 && wholeRow) {
+            this.agGridAdapter.getAgGridApi().refreshCells({ force: true, suppressFlash: true });
+            return;
+        }
+        if (allRowsColumnIds.size > 0) {
+            this.refreshColumns([...allRowsColumnIds, ...columnIds], true, true);
+            return;
+        }
+        if (wholeRow) {
+            this.redrawRow(rowNode);
+            return;
+        }
+        if (columnIds.size > 0 && this.agGridAdapter.isVisibleNode(rowNode)) {
+            this.refreshCells(rowNode, Array.from(columnIds), true, true);
         }
     }
     checkStyledColumnComparisonChanges(dataChangedScope, cellDataChangedInfos) {
@@ -3854,7 +4094,7 @@ export class AdaptableAgGrid {
             if (!dataChangedScope.wholeRow) {
                 formatColumnsWithExpression.forEach((formatColumn) => {
                     if (!dataChangedScope.wholeRow) {
-                        const columnIds = this.api.expressionApi.getColumnsFromExpression(formatColumn.Rule.BooleanExpression);
+                        const columnIds = this.api.expressionApi.getColumnsFromExpression(formatColumn.Rule);
                         if (columnIds.includes(cellDataChangedInfo.column.columnId)) {
                             if (this.api.columnScopeApi.scopeIsAll(formatColumn.Scope)) {
                                 dataChangedScope.wholeRow = true;
@@ -3968,6 +4208,23 @@ export class AdaptableAgGrid {
         this.__prevLayoutForRefresh = layout;
         return layout;
     }
+    isUnsupportedAdaptableFilter(filter) {
+        if (filter == null || typeof filter === 'boolean') {
+            return false;
+        }
+        return typeof filter.handler !== 'function';
+    }
+    disableUnsupportedAdaptableFilter(colDef, columnLabel) {
+        if (!this.api.optionsApi.getFilterOptions().useAdaptableFiltering) {
+            return;
+        }
+        if (!this.isUnsupportedAdaptableFilter(colDef.filter)) {
+            return;
+        }
+        this.logger.consoleError(`Column "${columnLabel}" has a custom filter in colDef.filter, but Adaptable filtering only accepts boolean (true/false) values for this property.`);
+        colDef.filter = false;
+        colDef.floatingFilter = false;
+    }
     validateColumnDefTypes(columnDefs) {
         columnDefs.forEach((colDef) => {
             if (colDef.children?.length) {