@adaptabletools/adaptable 23.0.22 → 23.1.0-canary.1

package/src/agGrid/AdaptableAgGrid.d.ts

@@ -2,10 +2,10 @@ import { AdaptableOptions } from '../AdaptableOptions/AdaptableOptions';
 import { ChartRef, Column, GridApi, GridOptions, IRowNode, Module, RowModelType, StatusPanelDef } from 'ag-grid-enterprise';
 import { AdaptableLogger } from './AdaptableLogger';
 import { AdaptableApi, DestroyConfig } from '../Api/AdaptableApi';
-import { AdaptableVariant, IAdaptable, NormalizeAdaptableStateOptions } from '../AdaptableInterfaces/IAdaptable';
+import { AdaptableVariant, GridRefreshScope, IAdaptable, NormalizeAdaptableStateOptions } from '../AdaptableInterfaces/IAdaptable';
 import { EmitterCallback } from '../Utilities/Emitter';
 import { AdaptablePlugin } from '../AdaptableOptions/AdaptablePlugin';
-import { AgGridAdapter } from './AgGridAdapter';
+import { AgGridAdapter, RowNodeEvent } from './AgGridAdapter';
 import { IDataService } from '../Utilities/Services/Interface/IDataService';
 import { AdaptableState } from '../AdaptableState/AdaptableState';
 import { IAdaptableStore } from '../Redux/Store/Interface/IAdaptableStore';
@@ -54,7 +54,6 @@ interface AdaptableInitInternalConfig<TData = any> {
 }
 export declare class AdaptableAgGrid implements IAdaptable {
     logger: AdaptableLogger;
-    private _id;
     lifecycleState: AdaptableLifecycleState;
     variant: AdaptableVariant;
     private emitter;
@@ -94,7 +93,7 @@ export declare class AdaptableAgGrid implements IAdaptable {
     ThemeService: IThemeService;
     private LicenseService;
     private ChartingService;
-    private rowListeners;
+    private isListeningToAgGridRowNodeEvents;
     private debouncedSetSelectedRows;
     private debouncedSetSelectedCells;
     private agGridListenerKeydown;
@@ -131,9 +130,6 @@ export declare class AdaptableAgGrid implements IAdaptable {
     constructor(config?: {
         getAgGridColumnApiModuleReference?: () => Module;
     });
-    static forEachAdaptable(fn: (adaptable: AdaptableAgGrid) => void): void;
-    private static collectInstance;
-    private static dismissInstance;
     get isAgGridInitialising(): boolean;
     get isReady(): boolean;
     get isAvailable(): boolean;
@@ -187,6 +183,22 @@ export declare class AdaptableAgGrid implements IAdaptable {
      * Either initializes the AG Grid instance or delegates it to the framework wrappers (React/Anglar)
      */
     private initializeAgGrid;
+    /**
+     * Derives the host element of the grid (the element the framework wrapper / `createGrid()` renders
+     * the grid into) when `ContainerOptions.agGridContainer` is not provided.
+     *
+     * AG Grid 36+ wraps the grid in three grid-owned `div.ag-styled-root` elements which mirror the
+     * theme classes (`ag-theme-params-N ...`, or the host's `ag-theme-<name>` in legacy mode);
+     * `AgGridAdapter.getAgGridRootElement()` is the innermost one. These wrappers must be skipped:
+     * they are re-classed by AG Grid on every theme change, so anything AdapTable adds/removes on them
+     * (legacy theme switching) would be lost.
+     *
+     * Resolution order:
+     * 1. the closest non-`.ag-styled-root` ancestor of the grid root (the host element)
+     * 2. legacy theme mode only: if the host element has no `ag-theme-*` class, the closest ancestor
+     *    which has one (AG Grid itself accepts the theme class anywhere up the tree)
+     */
+    private deriveAgGridContainerElement;
     useRowNodeLookUp(): boolean;
     private buildInitContainerContext;
     getAgGridContainerElement(): HTMLElement | null;
@@ -198,6 +210,13 @@ export declare class AdaptableAgGrid implements IAdaptable {
     private initAdaptableStore;
     private mapAdaptableStateToAgGridState;
     private addGridEventListeners;
+    /**
+     * see #local_event_service_monkey_patch (AgGridAdapter.ts)
+     *
+     * Entry point for the AG Grid RowNode `dataChanged` / `cellChanged` events, which AG Grid does not expose publicly.
+     * These drive Adaptable's data change detection (CellChanged events, Alerts, Flashing Cells, etc.)
+     */
+    onAgGridRowNodeEvent(event: RowNodeEvent): void;
     private shouldAutoSizeLayout;
     private autoSizeLayoutIfNeeded;
     forPlugins(callback: (plugin: AdaptablePlugin) => any): void;
@@ -228,10 +247,52 @@ export declare class AdaptableAgGrid implements IAdaptable {
     getDisplayValueFromRawValue(rowNode: IRowNode, columnId: string, rawValue: any): string | undefined;
     private getCleanValue;
     getNormalisedValueFromRawValue(rawValue: any, column: AdaptableColumn): string | number | boolean | Date | unknown;
-    private __updateColumnModelAndRefreshGrid_already_called;
+    /**
+     * The refresh scope already applied by a column-model pass in the current microtask window
+     * (`null` when no pass ran yet), see `updateColumnModelAndRefreshGrid`.
+     */
+    private __columnModelRefreshDoneInThisTick;
     private __forceUpdateColumnModel;
-    updateColumnModelAndRefreshGrid(): void;
-    _updateColumnModelAndRefreshGridNow(): void;
+    /**
+     * #narrow_column_model_refresh
+     *
+     * Runs the column-model pass at most once per microtask window: the first call runs it synchronously
+     * with the requested refresh scope; a later call in the same window does NOT set up the columns again
+     * (the #stable_col_def_callbacks read live state anyway) but still gets any refresh it asks for that
+     * the first call did not perform - eg a cells-only pass followed by a request for a row redraw.
+     */
+    updateColumnModelAndRefreshGrid(refreshScope?: GridRefreshScope): void;
+    /**
+     * #column_model_refresh_perf
+     *
+     * The whole pass and each of its phases are published as DevTools performance tracks
+     * (`Runtime` track, see `DevToolsTracks`) when profiling is enabled (`localStorage.adaptableProfileTracks = 'true'`).
+     * The `Update column model & refresh grid` entry carries the number of columns set up, the number of
+     * colDefs AG Grid actually saw as changed (see `AgGridAdapter.DANGER_getColDefsVersion`) and the refresh
+     * scope applied, so a `performance.getEntriesByName()` consumer (eg the `perf/column-model-refresh`
+     * Playwright spec) can tell a callback-only pass from one that committed real colDef changes.
+     *
+     * @param refreshScope see #narrow_column_model_refresh; defaults to a full refresh (rows + header)
+     */
+    _updateColumnModelAndRefreshGridNow(refreshScope?: GridRefreshScope): void;
+    /**
+     * see #narrow_column_model_refresh
+     * Applies the given refresh scope; each operation is a DevTools `Runtime` track entry (see #column_model_refresh_perf).
+     */
+    private refreshGridAfterColumnModelUpdate;
+    /**
+     * see #narrow_column_model_refresh
+     * The cell-level counterpart of `redrawBody()`: re-runs the colDef callbacks on every rendered cell
+     * without destroying the rows, so cell focus, selection and an in-progress edit survive.
+     * `cellStyle` results are normalised (see `normalizeStyleForAgGrid`), so a style that no longer applies
+     * is cleared even though AG Grid only ever ADDS inline styles on refresh.
+     */
+    refreshRenderedCells(): void;
+    /**
+     * Re-applies the current sort, eg. after a Custom Sort was added/edited/removed at runtime.
+     * The column comparators are already up to date (see #stable_col_def_callbacks), AG Grid just has to sort again.
+     */
+    refreshSortIfColumnsSorted(): void;
     redrawBody(): void;
     refreshHeader(): void;
     redrawRows(rowNodes?: IRowNode[]): void;

package/src/agGrid/AdaptableAgGrid.js

@@ -1,7 +1,8 @@
 import { debounce } from '../Utilities/Helpers/TimingHelper';
-import { createGrid, LocalEventService, } from 'ag-grid-enterprise';
+import { createGrid, } from 'ag-grid-enterprise';
 import { AdaptableLogger } from './AdaptableLogger';
 import { PrimaryKeyDocsLink } from '../Utilities/Constants/DocumentationLinkConstants';
+import { describeGridRefreshScope, FULL_GRID_REFRESH_SCOPE, getMissingGridRefreshScope, mergeGridRefreshScopes, } from './gridRefreshScope';
 import StringExtensions from '../Utilities/Extensions/StringExtensions';
 import { applyQuickSearchFindCssVars } from '../Utilities/Helpers/QuickSearchHelper';
 import Emitter from '../Utilities/Emitter';
@@ -110,48 +111,9 @@ import { AgGridFilterAdapterFactory } from './AgGridFilterAdapter';
 import { AdaptableFilterHandler } from './AdaptableFilterHandler';
 import { AgGridFloatingFilterAdapterFactory } from './AgGridFloatingFilterAdapter';
 import { listenForDevTools } from '../setupDevTools';
-const LocalEventService_Prototype = LocalEventService.prototype;
-const LocalEventService_dispatchEvent = LocalEventService_Prototype.dispatchEvent;
-LocalEventService_Prototype.dispatchEvent = function (event) {
-    const agGridApi = event.api;
-    if (agGridApi?.isDestroyed()) {
-        return;
-    }
-    LocalEventService_dispatchEvent.apply(this, arguments);
-    if (event.type === 'cellChanged' || event.type === 'dataChanged') {
-        const eventRowNode = event.node;
-        if (!eventRowNode) {
-            AdaptableLogger.consoleErrorBase(`No RowNode found in passed event, this should never happen!`, event);
-            return;
-        }
-        const extractGridApiFromRowNode = (rowNode) => {
-            const rowNodeApi = rowNode?.beans?.gridApi;
-            if (!rowNodeApi) {
-                AdaptableLogger.consoleErrorBase(`No GridAPI found in passed RowNode, this should never happen!`, rowNode);
-            }
-            return rowNodeApi;
-        };
-        if (eventRowNode) {
-            AdaptableAgGrid.forEachAdaptable((adaptable) => {
-                if (extractGridApiFromRowNode(eventRowNode) !== adaptable.agGridAdapter?.getAgGridApi(true)) {
-                    return;
-                }
-                if (adaptable.isDestroyed) {
-                    return;
-                }
-                const fn = adaptable.rowListeners ? adaptable.rowListeners[event.type] : null;
-                if (fn) {
-                    fn(event);
-                }
-            });
-        }
-    }
-};
-const adaptableInstances = {};
 const publishTimestamp = Number(ADAPTABLE_PUBLISH_TIMESTAMP);
 export class AdaptableAgGrid {
     logger;
-    _id;
     lifecycleState;
     variant;
     emitter;
@@ -188,7 +150,7 @@ export class AdaptableAgGrid {
     ThemeService;
     LicenseService;
     ChartingService;
-    rowListeners;
+    isListeningToAgGridRowNodeEvents = false;
     debouncedSetSelectedRows;
     debouncedSetSelectedCells;
     agGridListenerKeydown;
@@ -226,18 +188,6 @@ export class AdaptableAgGrid {
         this.agGridModulesAdapter = new AgGridModulesAdapter(this);
         this.DataService = new DataService(this);
     }
-    static forEachAdaptable(fn) {
-        Object.keys(adaptableInstances).forEach((key) => {
-            fn(adaptableInstances[key]);
-        });
-    }
-    static collectInstance(adaptable, adaptableId) {
-        adaptable._id = adaptableId;
-        adaptableInstances[adaptable._id] = adaptable;
-    }
-    static dismissInstance(adaptable) {
-        delete adaptableInstances[adaptable._id];
-    }
     get isAgGridInitialising() {
         return this.lifecycleState === 'initAgGrid';
     }
@@ -330,7 +280,6 @@ export class AdaptableAgGrid {
         const adaptableId = this._rawAdaptableOptions.adaptableId;
         const initMarker = getMarker(adaptableId).track.Init.label.Init.start();
         const perfInitAdaptableAgGrid = this.logger.beginPerf(`Adaptable._initAdaptableAgGrid()`);
-        AdaptableAgGrid.collectInstance(this, this._rawAdaptableOptions.adaptableId);
         this.variant = config.variant;
         this.initWithLazyData =
             config.gridOptions.rowData == undefined || config.gridOptions.rowData.length === 0;
@@ -669,6 +618,7 @@ export class AdaptableAgGrid {
             agGridApi.onFilterChanged();
             filteringApplied = true;
         }
+        agGridApi.refreshCells();
         this._emit('AdapTableFiltersApplied');
         return filteringApplied;
     }
@@ -1055,6 +1005,14 @@ export class AdaptableAgGrid {
                 return result;
             };
         });
+        this.agGridOptionsService.setGridOptionsProperty(gridOptions, 'getColumnMenuItems', (original_getColumnMenuItems) => {
+            return (params) => {
+                if (params.source === 'columnMenu') {
+                    return this.agGridMenuAdapter.buildColumnMenu(params, original_getColumnMenuItems);
+                }
+                return this.agGridMenuAdapter.buildColumnsToolPanelMenu(params);
+            };
+        });
         this.agGridOptionsService.setGridOptionsProperty(gridOptions, 'getMainMenuItems', (original_getMainMenuItems) => {
             return (params) => {
                 return this.agGridMenuAdapter.buildColumnMenu(params, original_getMainMenuItems);
@@ -1300,8 +1258,7 @@ export class AdaptableAgGrid {
                 this.logger.info('Initializing with lazy data (no initial rowData).');
             }
             if (!this.getAgGridContainerElement()) {
-                const gridRoot = this.agGridAdapter.getAgGridRootElement();
-                const gridContainer = gridRoot?.closest('[class*="ag-theme"]');
+                const gridContainer = this.deriveAgGridContainerElement(agGridApi.getGridOption('theme') === 'legacy');
                 if (!gridContainer) {
                     this.logger.consoleError('Failed to derive AG Grid container from the framework wrapper. Please provide a valid container element via ContainerOptions.agGridContainer.');
                 }
@@ -1321,6 +1278,27 @@ export class AdaptableAgGrid {
         const agGridApi = createGrid(agGridContainer, gridOptions, gridParams);
         return agGridApi;
     }
+    deriveAgGridContainerElement(isLegacyTheme) {
+        const gridRoot = this.agGridAdapter.getAgGridRootElement();
+        if (!gridRoot) {
+            return undefined;
+        }
+        let hostElement = gridRoot;
+        while (hostElement && hostElement.classList?.contains('ag-styled-root')) {
+            hostElement = hostElement.parentElement;
+        }
+        if (!hostElement) {
+            return undefined;
+        }
+        const hasAgThemeClass = (element) => Array.from(element.classList ?? []).some((cls) => cls.indexOf('ag-theme-') === 0);
+        if (isLegacyTheme && !hasAgThemeClass(hostElement)) {
+            const themedAncestor = hostElement.parentElement?.closest('[class*="ag-theme-"]');
+            if (themedAncestor && hasAgThemeClass(themedAncestor)) {
+                return themedAncestor;
+            }
+        }
+        return hostElement;
+    }
     useRowNodeLookUp() {
         return this.agGridAdapter.getAgGridApi().getGridOption('getRowId') != undefined;
     }
@@ -1452,7 +1430,10 @@ export class AdaptableAgGrid {
             if (this.api.formatColumnApi.getActiveFormatColumns().some((fc) => {
                 return fc.ColumnGroupScope != null;
             })) {
-                this.updateColumnModelAndRefreshGrid();
+                this.updateColumnModelAndRefreshGrid({
+                    cells: true,
+                    header: this.api.formatColumnApi.internalApi.hasFormatColumnsTargetingHeader(),
+                });
             }
         }));
         this.agGridAdapter.getAgGridApi().addEventListener('columnPivotChanged', (this.listenerPivotChanged = (params) => {
@@ -1519,25 +1500,23 @@ export class AdaptableAgGrid {
             };
             this.agGridAdapter.getAgGridApi().addGlobalListener(this.listenerGlobalChartingChanges);
         }
-        this.rowListeners = {
-            dataChanged: (event) => {
-                this.onRowDataChanged({
-                    rowNode: event.node,
-                    oldData: event.oldData,
-                    newData: event.newData,
-                });
-            },
-            cellChanged: (event) => {
-                if (event.column) {
-                    this.onCellDataChanged({
-                        rowNode: event.node,
-                        oldValue: event.oldValue,
-                        newValue: event.newValue,
-                        colId: event.column.colId,
-                    });
-                }
-            },
-        };
+        this.isListeningToAgGridRowNodeEvents = true;
+    }
+    onAgGridRowNodeEvent(event) {
+        if (!this.isListeningToAgGridRowNodeEvents) {
+            return;
+        }
+        if (event.type === 'dataChanged') {
+            const { node, oldData, newData } = event;
+            this.onRowDataChanged({ rowNode: node, oldData, newData });
+            return;
+        }
+        if (event.type === 'cellChanged') {
+            const { node, column, oldValue, newValue } = event;
+            if (column) {
+                this.onCellDataChanged({ rowNode: node, oldValue, newValue, colId: column.getColId() });
+            }
+        }
     }
     shouldAutoSizeLayout() {
         const { layoutApi } = this.api;
@@ -1908,29 +1887,87 @@ export class AdaptableAgGrid {
         }
         return rawValue;
     }
-    __updateColumnModelAndRefreshGrid_already_called = false;
+    __columnModelRefreshDoneInThisTick = null;
     __forceUpdateColumnModel = false;
-    updateColumnModelAndRefreshGrid() {
-        if (this.__updateColumnModelAndRefreshGrid_already_called && !this.__forceUpdateColumnModel) {
+    updateColumnModelAndRefreshGrid(refreshScope = FULL_GRID_REFRESH_SCOPE) {
+        const alreadyDone = this.__columnModelRefreshDoneInThisTick;
+        if (alreadyDone && !this.__forceUpdateColumnModel) {
+            const missingScope = getMissingGridRefreshScope(alreadyDone, refreshScope);
+            if (missingScope) {
+                this.refreshGridAfterColumnModelUpdate(missingScope);
+                this.__columnModelRefreshDoneInThisTick = mergeGridRefreshScopes(alreadyDone, missingScope);
+            }
             return;
         }
         this.__forceUpdateColumnModel = false;
         try {
-            this._updateColumnModelAndRefreshGridNow();
-            this.__updateColumnModelAndRefreshGrid_already_called = true;
+            this._updateColumnModelAndRefreshGridNow(refreshScope);
+            this.__columnModelRefreshDoneInThisTick = alreadyDone
+                ? mergeGridRefreshScopes(alreadyDone, refreshScope)
+                : { ...refreshScope };
         }
         finally {
             queueMicrotask(() => {
-                this.__updateColumnModelAndRefreshGrid_already_called = false;
+                this.__columnModelRefreshDoneInThisTick = null;
             });
         }
     }
-    _updateColumnModelAndRefreshGridNow() {
-        this.logger.info('Updating column model and refreshing grid.');
+    _updateColumnModelAndRefreshGridNow(refreshScope = FULL_GRID_REFRESH_SCOPE) {
+        const startTime = performance.now();
+        const adaptableId = this.adaptableOptions.adaptableId;
+        const runtimeTrack = () => getMarker(adaptableId).track.Runtime.label;
+        const colDefsVersionBefore = this.agGridAdapter.DANGER_getColDefsVersion();
+        const passMarker = runtimeTrack().UpdateColumnModel.start();
+        const deriveMarker = runtimeTrack().DeriveColumnState.start();
         this.deriveAdaptableColumnStateFromAgGrid();
+        deriveMarker.end();
+        const setupColumnsMarker = runtimeTrack().SetupColumns.start();
         this.agGridColumnAdapter.setupColumns();
-        this.redrawBody();
-        this.refreshHeader();
+        setupColumnsMarker.end();
+        this.refreshGridAfterColumnModelUpdate(refreshScope);
+        const colDefsVersionAfter = this.agGridAdapter.DANGER_getColDefsVersion();
+        const colDefsChanged = colDefsVersionBefore != null && colDefsVersionAfter != null
+            ? colDefsVersionAfter - colDefsVersionBefore
+            : -1;
+        const columnCount = this.api.columnApi.getColumns().length;
+        const refreshScopeLabel = describeGridRefreshScope(refreshScope);
+        passMarker.end({
+            details: [
+                { name: 'columns', value: columnCount },
+                { name: 'colDefsChanged', value: colDefsChanged },
+                { name: 'refresh', value: refreshScopeLabel },
+            ],
+        });
+        this.logger.info(`Updated column model and refreshed grid in ${Math.round(performance.now() - startTime)}ms (${columnCount} columns, ${colDefsChanged} colDefs changed, refresh: ${refreshScopeLabel}).`);
+    }
+    refreshGridAfterColumnModelUpdate(refreshScope) {
+        const runtimeTrack = getMarker(this.adaptableOptions.adaptableId).track.Runtime.label;
+        if (refreshScope.rows) {
+            const redrawBodyMarker = runtimeTrack.RedrawBody.start();
+            this.redrawBody();
+            redrawBodyMarker.end();
+        }
+        else if (refreshScope.cells) {
+            const refreshCellsMarker = runtimeTrack.RefreshCells.start();
+            this.refreshRenderedCells();
+            refreshCellsMarker.end();
+        }
+        if (refreshScope.header) {
+            const refreshHeaderMarker = runtimeTrack.RefreshHeader.start();
+            this.refreshHeader();
+            refreshHeaderMarker.end();
+        }
+    }
+    refreshRenderedCells() {
+        this.agGridAdapter.getAgGridApi().refreshCells({ force: true, suppressFlash: true });
+        this.refreshAgGridFindIfNeeded();
+        this._emit('GridRefreshed');
+    }
+    refreshSortIfColumnsSorted() {
+        const columnSorts = this.api.layoutApi.getCurrentLayout()?.ColumnSorts;
+        if (columnSorts?.length) {
+            this.layoutManager.refreshSort();
+        }
     }
     redrawBody() {
         this.redrawRows();
@@ -3415,6 +3452,7 @@ export class AdaptableAgGrid {
                     'doesExternalFilterPass',
                     'excelStyles',
                     'getContextMenuItems',
+                    'getColumnMenuItems',
                     'getMainMenuItems',
                     'getRowClass',
                     'getRowId',
@@ -3458,13 +3496,12 @@ export class AdaptableAgGrid {
         this.agGridThemeAdapter = null;
         this.agGridModulesAdapter?.destroy();
         this.agGridModulesAdapter = null;
-        this.rowListeners = null;
+        this.isListeningToAgGridRowNodeEvents = false;
         this.emitter.destroy();
         this.emitter = null;
         this.adaptableOptions = null;
         this.columnMinMaxValuesCache = null;
         this.lifecycleState = 'preDestroyed';
-        AdaptableAgGrid.dismissInstance(this);
         if (config?.unmount) {
             const abContainerElement = this.getAdaptableContainerElement();
             if (abContainerElement != null) {

package/src/agGrid/AgGridAdapter.d.ts

@@ -1,9 +1,34 @@
-import { ColDef, ColGroupDef, Column, GridApi, GridOptions, IRowNode, ManagedGridOptionKey, ManagedGridOptions, Module } from 'ag-grid-enterprise';
+import { AgEvent, ColDef, ColGroupDef, Column, GridApi, GridOptions, IRowNode, ManagedGridOptionKey, ManagedGridOptions, Module } from 'ag-grid-enterprise';
 import type { AgChartInstance, AgSparklineOptions } from 'ag-charts-types';
 import { AdaptableAgGrid } from './AdaptableAgGrid';
 import { AdaptableColumn, AdaptableColumnGroup } from '../AdaptableState/Common/AdaptableColumn';
 import { SelectedCellInfo } from '../AdaptableState/Selection/SelectedCellInfo';
 import { SelectedRowInfo } from '../AdaptableState/Selection/SelectedRowInfo';
+/**
+ * #local_event_service_monkey_patch
+ *
+ * AG Grid does not expose the RowNode `cellChanged` and `dataChanged` events (they are dispatched only on the
+ * RowNode's own, lazily created, `LocalEventService`), so we override `LocalEventService.prototype.dispatchEvent`
+ * and hook our own data change detection into it.
+ *
+ * Since AG Grid v36, `LocalEventService` lives in the `ag-stack` package (not in `ag-grid-community`).
+ * Unlike a duplicated `ag-grid-community`, a duplicated `ag-stack` copy in a consumer bundle
+ * (different install location, CJS vs ESM, version skew) is SILENT - AG Grid keeps working,
+ * but a prototype patched via `import { LocalEventService } from 'ag-stack'` would never be hit
+ * by the grid, because the grid instantiates the class from ITS copy of the module.
+ *
+ * Because of this we don't patch the statically imported class; instead we patch the prototype
+ * of the `LocalEventService` instance actually used by the running grid (`beans.eventSvc.globalSvc`)
+ * - one patch per distinct prototype, regardless of how many copies of `ag-stack` are loaded.
+ *
+ * The patched prototype is shared by ALL grids (and all their RowNodes), so the patch identifies the
+ * originating grid via `rowNode.beans` and routes the event to that grid's AgGridAdapter
+ * (see DANGER_AG_GRID_ADAPTERS_MAP & AgGridAdapter.handleRowNodeEvent).
+ */
+export type RowNodeEventType = 'dataChanged' | 'cellChanged';
+export interface RowNodeEvent extends AgEvent<RowNodeEventType> {
+    node: IRowNode;
+}
 export type AgGridThemeMode = 'legacy' | 'themingApi';
 export declare class AgGridAdapter {
     private _adaptableInstance;
@@ -26,6 +51,11 @@ export declare class AgGridAdapter {
     private getActivePivotColumnFilters;
     private get agGridOptionsService();
     setAgGridId(agGridId: string): void;
+    /**
+     * see #local_event_service_monkey_patch
+     * Called (for the grid managed by this adapter) whenever AG Grid dispatches a RowNode `cellChanged` / `dataChanged` event
+     */
+    handleRowNodeEvent(event: RowNodeEvent): void;
     setAgGridApi(gridApi: GridApi): void;
     getAgGridApi(skipLogging?: boolean): GridApi | undefined;
     monkeyPatchingGridOptionsUpdates(): void;
@@ -34,6 +64,8 @@ export declare class AgGridAdapter {
     private DANGER_getPrivateAgGridBeans;
     DANGER_getCreateSparkline(): ((options: AgSparklineOptions) => AgChartInstance<AgSparklineOptions>) | undefined;
     DANGER_getLiveGridOptions(): GridOptions<any>;
+    DANGER_getColDefsVersion(): number | undefined;
+    DANGER_invalidateSortCache(): void;
     getAgGridRootElement(): HTMLElement;
     /**
      * When AG Grid is rendered the first time, the AG GridApi is not yet set in the Adaptable context (as it's set only AFTER the grid is fully initialised)

package/src/agGrid/AgGridAdapter.js

@@ -1,4 +1,5 @@
 import { ColumnApiModule, } from 'ag-grid-enterprise';
+import { AdaptableLogger } from './AdaptableLogger';
 import { ACTION_COLUMN_TYPE, CALCULATED_COLUMN_TYPE, FDC3_COLUMN_TYPE, FREE_TEXT_COLUMN_TYPE, } from '../AdaptableState/Common/AdaptableColumn';
 import { ACCESS_LEVEL_HIDDEN, ADAPTABLE_FDC3_ACTION_COLUMN_FRIENDLY_NAME, } from '../Utilities/Constants/GeneralConstants';
 import { createUuid } from '../AdaptableState/Uuid';
@@ -10,7 +11,84 @@ import { isPivotColumnTotal } from '../layout-manager/src/isPivotColumnTotal';
 import { isPivotAggTotalColumn } from '../layout-manager/src/isPivotAggTotalColumn';
 import { ONLY_AGG_FN_NAME, WEIGHTED_AVERAGE_AGG_FN_NAME, } from '../AdaptableState/Common/AggregationColumns';
 const DANGER_AG_GRID_BEANS_MAP = {};
+const DANGER_AG_GRID_ADAPTERS_MAP = {};
 const getColumnApiModule = () => ColumnApiModule;
+const PATCHED_LOCAL_EVENT_SERVICE_PROTOTYPES = new WeakSet();
+const patchLocalEventServiceDispatchEvent = (beans) => {
+    const localEventServiceInstance = beans?.eventSvc?.globalSvc;
+    const LocalEventService_Prototype = localEventServiceInstance
+        ? Object.getPrototypeOf(localEventServiceInstance)
+        : null;
+    if (!LocalEventService_Prototype ||
+        typeof LocalEventService_Prototype.dispatchEvent !== 'function') {
+        AdaptableLogger.consoleErrorBase(`CRITICAL: could not get hold of AG Grid LocalEventService, data change detection will NOT work!`, beans);
+        return;
+    }
+    if (PATCHED_LOCAL_EVENT_SERVICE_PROTOTYPES.has(LocalEventService_Prototype)) {
+        return;
+    }
+    PATCHED_LOCAL_EVENT_SERVICE_PROTOTYPES.add(LocalEventService_Prototype);
+    const LocalEventService_dispatchEvent = LocalEventService_Prototype.dispatchEvent;
+    LocalEventService_Prototype.dispatchEvent = function (event) {
+        LocalEventService_dispatchEvent.apply(this, arguments);
+        if (event.type !== 'cellChanged' && event.type !== 'dataChanged') {
+            return;
+        }
+        const rowNodeEvent = event;
+        const rowNode = rowNodeEvent.node;
+        if (!rowNode) {
+            AdaptableLogger.consoleErrorBase(`No RowNode found in passed event, this should never happen!`, event);
+            return;
+        }
+        const gridId = rowNode.beans?.context?.getId();
+        if (!gridId) {
+            AdaptableLogger.consoleErrorBase(`No gridId found in passed RowNode, this should never happen!`, rowNode);
+            return;
+        }
+        DANGER_AG_GRID_ADAPTERS_MAP[gridId]?.handleRowNodeEvent(rowNodeEvent);
+    };
+};
+const patchVisibleColsPartition = (beans) => {
+    const visibleCols = beans?.visibleCols;
+    if (!visibleCols || typeof visibleCols.partitionVisibleCols !== 'function') {
+        console.error(`CRITICAL: could not get hold of AG Grid VisibleColsService.partitionVisibleCols, the selection column may NOT be displayed when it is the last column!`);
+        return;
+    }
+    const original_partitionVisibleCols = visibleCols.partitionVisibleCols;
+    visibleCols.partitionVisibleCols = function () {
+        const result = original_partitionVisibleCols.apply(this, arguments);
+        const leftCols = result?.leftCols ?? [];
+        const rightCols = result?.rightCols ?? [];
+        const centerCols = result?.centerCols ?? [];
+        if (leftCols.length + rightCols.length + centerCols.length === 0) {
+            return result;
+        }
+        const colModel = beans.colModel;
+        const selectionCol = colModel?.colsList?.find((col) => col?.colKind === 'selection');
+        if (!selectionCol || !selectionCol.visible) {
+            return result;
+        }
+        if (leftCols.includes(selectionCol) ||
+            rightCols.includes(selectionCol) ||
+            centerCols.includes(selectionCol)) {
+            return result;
+        }
+        const showAutoGroupAndValuesOnly = colModel.pivotMode && !colModel.showingPivotResult;
+        if (showAutoGroupAndValuesOnly && !(beans.selectionColSvc?.isEnabled?.() ?? false)) {
+            return result;
+        }
+        if (selectionCol.pinned === 'right') {
+            rightCols.push(selectionCol);
+        }
+        else if (selectionCol.pinned) {
+            leftCols.push(selectionCol);
+        }
+        else {
+            centerCols.push(selectionCol);
+        }
+        return result;
+    };
+};
 export class AgGridAdapter {
     _adaptableInstance;
     DANGER_USE_GETTER_gridApi;
@@ -38,11 +116,14 @@ export class AgGridAdapter {
                     console.error('CRITICAL: No gridId found in beans, this should never happen!');
                 }
                 DANGER_AG_GRID_BEANS_MAP[gridId] = beans;
+                patchLocalEventServiceDispatchEvent(beans);
+                patchVisibleColsPartition(beans);
             };
         }
     }
     destroy() {
         delete DANGER_AG_GRID_BEANS_MAP[this._agGridId];
+        delete DANGER_AG_GRID_ADAPTERS_MAP[this._agGridId];
         this.initialGridOptions = null;
         this.DANGER_gridApi_from_args = null;
         this.DANGER_USE_GETTER_gridApi = null;
@@ -86,6 +167,10 @@ export class AgGridAdapter {
     }
     setAgGridId(agGridId) {
         this._agGridId = agGridId;
+        DANGER_AG_GRID_ADAPTERS_MAP[agGridId] = this;
+    }
+    handleRowNodeEvent(event) {
+        this._adaptableInstance?.onAgGridRowNodeEvent(event);
     }
     setAgGridApi(gridApi) {
         this.DANGER_USE_GETTER_gridApi = gridApi;
@@ -223,6 +308,12 @@ export class AgGridAdapter {
     DANGER_getLiveGridOptions() {
         return this.DANGER_getPrivateAgGridBeans()?.gridOptions;
     }
+    DANGER_getColDefsVersion() {
+        return this.DANGER_getPrivateAgGridBeans()?.colModel?.colDefsVersion;
+    }
+    DANGER_invalidateSortCache() {
+        this.DANGER_getPrivateAgGridBeans()?.sortSvc?.invalidate();
+    }
     getAgGridRootElement() {
         return this.DANGER_getPrivateAgGridBeans()?.eGridDiv;
     }