@adaptabletools/adaptable 23.0.21 → 23.1.0-canary.0

package/src/agGrid/AdaptableAgGrid.d.ts

@@ -5,7 +5,7 @@ import { AdaptableApi, DestroyConfig } from '../Api/AdaptableApi';
 import { AdaptableVariant, 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;
@@ -232,6 +251,11 @@ export declare class AdaptableAgGrid implements IAdaptable {
     private __forceUpdateColumnModel;
     updateColumnModelAndRefreshGrid(): void;
     _updateColumnModelAndRefreshGridNow(): 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,5 +1,5 @@
 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 StringExtensions from '../Utilities/Extensions/StringExtensions';
@@ -110,48 +110,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 +149,7 @@ export class AdaptableAgGrid {
     ThemeService;
     LicenseService;
     ChartingService;
-    rowListeners;
+    isListeningToAgGridRowNodeEvents = false;
     debouncedSetSelectedRows;
     debouncedSetSelectedCells;
     agGridListenerKeydown;
@@ -226,18 +187,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 +279,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 +617,7 @@ export class AdaptableAgGrid {
             agGridApi.onFilterChanged();
             filteringApplied = true;
         }
+        agGridApi.refreshCells();
         this._emit('AdapTableFiltersApplied');
         return filteringApplied;
     }
@@ -1055,6 +1004,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 +1257,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 +1277,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;
     }
@@ -1519,25 +1496,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;
@@ -1926,11 +1901,18 @@ export class AdaptableAgGrid {
         }
     }
     _updateColumnModelAndRefreshGridNow() {
-        this.logger.info('Updating column model and refreshing grid.');
+        const startTime = performance.now();
         this.deriveAdaptableColumnStateFromAgGrid();
         this.agGridColumnAdapter.setupColumns();
         this.redrawBody();
         this.refreshHeader();
+        this.logger.info(`Updated column model and refreshed grid in ${Math.round(performance.now() - startTime)}ms.`);
+    }
+    refreshSortIfColumnsSorted() {
+        const columnSorts = this.api.layoutApi.getCurrentLayout()?.ColumnSorts;
+        if (columnSorts?.length) {
+            this.layoutManager.refreshSort();
+        }
     }
     redrawBody() {
         this.redrawRows();
@@ -3415,6 +3397,7 @@ export class AdaptableAgGrid {
                     'doesExternalFilterPass',
                     'excelStyles',
                     'getContextMenuItems',
+                    'getColumnMenuItems',
                     'getMainMenuItems',
                     'getRowClass',
                     'getRowId',
@@ -3458,13 +3441,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,7 @@ export declare class AgGridAdapter {
     private DANGER_getPrivateAgGridBeans;
     DANGER_getCreateSparkline(): ((options: AgSparklineOptions) => AgChartInstance<AgSparklineOptions>) | undefined;
     DANGER_getLiveGridOptions(): GridOptions<any>;
+    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,9 @@ export class AgGridAdapter {
     DANGER_getLiveGridOptions() {
         return this.DANGER_getPrivateAgGridBeans()?.gridOptions;
     }
+    DANGER_invalidateSortCache() {
+        this.DANGER_getPrivateAgGridBeans()?.sortSvc?.invalidate();
+    }
     getAgGridRootElement() {
         return this.DANGER_getPrivateAgGridBeans()?.eGridDiv;
     }

package/src/agGrid/AgGridColumnAdapter.d.ts

@@ -7,12 +7,53 @@ export declare function getEditorForColumnDataType(columnDataType: AdaptableColu
 export declare class AgGridColumnAdapter {
     private adaptableInstance;
     private colDefPropertyCache;
+    private workingColDefs;
+    private sortCacheInvalidationNeeded;
+    private stableCallbacks;
+    private stableCallbackImplementations;
+    private stableCallbackOwners;
+    private adaptableColumnFilterDef;
+    private adaptableFloatingFilterComponent;
     constructor(adaptableInstance: AdaptableAgGrid);
     private getVariant;
     destroy(): void;
     private get adaptableApi();
     private get adaptableOptions();
     private get agGridApi();
+    /**
+     * The colDef that `setupColumnXxx` methods should read from & write to:
+     * the working copy while the column is being set up (see #col_def_commit), the live colDef otherwise.
+     */
+    private getColDefForSetup;
+    /**
+     * see #col_def_commit
+     * Creates the working copy of the colDef, which is committed via `commitColDefChanges`
+     */
+    private beginColDefChanges;
+    /**
+     * see #col_def_commit
+     * Hands the working copy over to AG Grid, which re-initialises everything it caches from the colDef
+     * and refreshes the rendered cells of the column - but only if the colDef actually changed.
+     */
+    private commitColDefChanges;
+    /**
+     * see #stable_col_def_callbacks
+     * Returns the (stable) function AG Grid should see for this column & property,
+     * delegating to the given (latest) implementation.
+     */
+    private toStableCallback;
+    /**
+     * #pivot_result_col_def_copies_source
+     *
+     * AG Grid generates a pivot result colDef by copying the WHOLE colDef of its value (source) column
+     * (`PivotColDefService.createColDef` -> `Object.assign(colDef, valueColumn.colDef)`), and regenerates it
+     * whenever the source colDef is committed (see #col_def_commit). The copy therefore contains the
+     * callbacks Adaptable set up for the SOURCE column, which must not be mistaken for values provided by the user.
+     *
+     * When such a callback is found where a user value is expected, the user value of the source column
+     * is used instead - which is exactly what the pivot result column would have inherited from the user.
+     */
+    private resolveUserProvidedValue;
     setColDefProperty<T extends keyof ColDef>(col: Column, propertyName: T, propertyGetter: (userPropertyValue: ColDef[T]) => ColDef[T] | undefined): void;
     getUserColDefProperty<T extends keyof ColDef>(columnId: string, propertyName: T): ColDef[T] | undefined;
     shouldSkipColumn(colId: string): boolean;
@@ -22,6 +63,7 @@ export declare class AgGridColumnAdapter {
      * @param specificColumnIds - optional list of column Ids to setup. If not provided, all columns are setup
      */
     setupColumns(specificColumnIds?: string[]): void;
+    private setupColumn;
     private setupColumnValueGetter;
     private setupColumnCellClass;
     private setupColumnHeaderClass;
@@ -45,6 +87,8 @@ export declare class AgGridColumnAdapter {
     private setupColumnCellDataType;
     setupColumnHeader({ col }: ColumnSetupInfo): void;
     private setupColumnFilter;
+    private getAdaptableColumnFilterDef;
+    private getAdaptableFloatingFilterComponent;
     private setupColumnFloatingFilter;
     private setupColumnValueFormatter;
     private setupColumnEditable;