@adaptabletools/adaptable 12.1.7 → 12.2.0-canary.0

package/src/agGrid/Adaptable.js

@@ -62,6 +62,8 @@ const StatusBarState_1 = require("../PredefinedConfig/StatusBarState");
 const createAgStatusPanelComponent_1 = require("./createAgStatusPanelComponent");
 const AdaptableStatusBar_1 = require("../View/StatusBar/AdaptableStatusBar");
 const RowEditService_1 = require("../Utilities/Services/RowEditService");
+const weightedAverage_1 = require("./weightedAverage");
+const AggregationColumns_1 = require("../PredefinedConfig/Common/AggregationColumns");
 const tinycolor = require('tinycolor2');
 all_modules_1.ModuleRegistry.registerModules(all_modules_1.AllCommunityModules);
 const GROUP_PATH_SEPARATOR = '/';
@@ -365,6 +367,7 @@ class Adaptable {
         this.isInitialised = false;
         this.useRowNodeLookUp = false; // we will set later in instantiate if possible to be true
         this.forPlugins((plugin) => plugin.afterInitOptions(this, this.adaptableOptions));
+        this.registerAdaptableAggFuncs();
         // get the api ready
         this.api = new AdaptableApiImpl_1.AdaptableApiImpl(this);
         this.forPlugins((plugin) => plugin.afterInitApi(this, this.api));
@@ -375,10 +378,13 @@ class Adaptable {
         this.agGridMenuHelper = new agGridMenuHelper_1.agGridMenuHelper(this, this.gridOptions);
         // Build the default group sort comparator - will get custom sort values (but not functions) in real time
         // TODO: if  a custom 'aggFunc' property is defined (see setupColumnAggFunc()), it won't be evaluated
-        if (!this.getInitialGroupOrderComparator(this.gridOptions) &&
-            this.adaptableOptions.columnOptions.autoOrderGroupedColumns) {
-            this.gridOptions.initialGroupOrderComparator =
-                this.agGridHelper.runAdaptableGroupComparerFunction();
+        if (this.adaptableOptions.columnOptions.autoOrderGroupedColumns) {
+            this.setGridOptionsProperty('initialGroupOrderComparator', (userPropertyValue) => {
+                if (userPropertyValue) {
+                    return userPropertyValue;
+                }
+                return this.agGridHelper.runAdaptableGroupComparerFunction();
+            });
         }
         // we prefer the grid to be NOT instantiated so that we can do it
         // perhaps in future we will force instantiation only?
@@ -571,15 +577,6 @@ class Adaptable {
         }
         if ((_a = this.adaptableOptions.generalOptions) === null || _a === void 0 ? void 0 : _a.hideEmptyGroupRows) {
             LoggingHelper_1.ConsoleLogWarning(`DEPRECATED: 'GeneralOptions.hideEmptyGroupRows' is deprecated and will no longer be evaluated!`);
-            // disabled due to showstopper starting with AG Grid v26
-            // the internal implementation of AG Grids GroupCellRenderer has changed A LOT!
-            // this.gridOptions.components = this.gridOptions.components || {};
-            //
-            // this.gridOptions.autoGroupColumnDef = this.gridOptions.autoGroupColumnDef || {};
-            // if (!this.gridOptions.autoGroupColumnDef.cellRenderer) {
-            //   this.gridOptions.autoGroupColumnDef.cellRenderer = '__adaptableGroupCellRenderer';
-            //   this.gridOptions.components.__adaptableGroupCellRenderer = AdaptableGroupCellRenderer;
-            // }
         }
         const adaptableSideBarDef = this.createAdaptableSideBarDef();
         if (!!adaptableSideBarDef) {
@@ -587,12 +584,9 @@ class Adaptable {
             this.gridOptions.components.AdaptableToolPanel = AdaptableToolPanel_1.getAdaptableToolPanelAgGridComponent(this);
         }
         if (this.agGridHelper.isSideBarDefObject(adaptableSideBarDef)) {
-            if (this.gridOptions.api) {
-                this.gridOptions.api.setSideBar(adaptableSideBarDef);
-            }
-            else {
-                this.gridOptions.sideBar = adaptableSideBarDef;
-            }
+            this.setGridOptionsProperty('sideBar', () => {
+                return adaptableSideBarDef;
+            });
             this.hasAdaptableToolPanel = true;
         }
         this.createStatusBars();
@@ -720,24 +714,25 @@ class Adaptable {
         }
     }
     createStatusBars() {
-        var _a, _b;
-        const statusBarOptions = Object.assign({}, this.gridOptions.statusBar);
         const adaptableStatusPanelKeys = [];
-        const statusPanels = (_b = ((_a = statusBarOptions === null || statusBarOptions === void 0 ? void 0 : statusBarOptions.statusPanels) !== null && _a !== void 0 ? _a : [])) === null || _b === void 0 ? void 0 : _b.map((statusPanel) => {
-            if (statusPanel.statusPanel === StatusBarState_1.ADAPTABLE_STATUS_PANEL) {
-                adaptableStatusPanelKeys.push(statusPanel.key);
-                const context = {
-                    Key: statusPanel.key,
-                };
-                return Object.assign(Object.assign({}, statusPanel), { statusPanel: createAgStatusPanelComponent_1.createAgStatusPanelComponent(AdaptableStatusBar_1.AdaptableStatusBar, this, context) });
-            }
-            return statusPanel;
+        this.setGridOptionsProperty('statusBar', (originalStatusBar) => {
+            var _a, _b;
+            const statusPanels = (_b = ((_a = originalStatusBar === null || originalStatusBar === void 0 ? void 0 : originalStatusBar.statusPanels) !== null && _a !== void 0 ? _a : [])) === null || _b === void 0 ? void 0 : _b.map((statusPanel) => {
+                if (statusPanel.statusPanel === StatusBarState_1.ADAPTABLE_STATUS_PANEL) {
+                    adaptableStatusPanelKeys.push(statusPanel.key);
+                    const context = {
+                        Key: statusPanel.key,
+                    };
+                    return Object.assign(Object.assign({}, statusPanel), { statusPanel: createAgStatusPanelComponent_1.createAgStatusPanelComponent(AdaptableStatusBar_1.AdaptableStatusBar, this, context) });
+                }
+                return statusPanel;
+            });
+            return Object.assign(Object.assign({}, originalStatusBar), { statusPanels });
         });
-        statusBarOptions.statusPanels = statusPanels;
-        this.gridOptions.statusBar = statusBarOptions;
         const statusBarModule = this.ModuleService.getModuleById(ModuleConstants.StatusBarModuleId);
         this.api.eventApi.on('AdaptableReady', () => {
-            const adaptableStatusPanels = statusPanels.filter((statusPanel) => adaptableStatusPanelKeys.includes(statusPanel.key));
+            var _a, _b;
+            const adaptableStatusPanels = (_b = (_a = this.gridOptions.statusBar) === null || _a === void 0 ? void 0 : _a.statusPanels) === null || _b === void 0 ? void 0 : _b.filter((statusPanel) => adaptableStatusPanelKeys.includes(statusPanel.key));
             // need to add only the adaptable panels
             statusBarModule.syncStateWithOptions(adaptableStatusPanels);
         });
@@ -1310,9 +1305,11 @@ class Adaptable {
             }
             newColState.rowGroupIndex =
                 groupedColumnsIndexesMap[colId] != null ? groupedColumnsIndexesMap[colId] : null;
-            // if (newColState.rowGroupIndex == null) {
+            const previousRowGroup = newColState.rowGroup;
             newColState.rowGroup = newColState.rowGroupIndex != null;
-            // }
+            if (!previousRowGroup && newColState.rowGroup) {
+                this.triggerSetupColumnKeyCreator(colId);
+            }
             const normalizePinned = (pinnedValue) => {
                 if (typeof pinnedValue === 'string') {
                     return pinnedValue;
@@ -1331,15 +1328,25 @@ class Adaptable {
             newColState.aggFunc = null;
             if (aggregationFunctionsColumnsMap[colId] != null) {
                 const colDef = (_b = (_a = this.gridOptions) === null || _a === void 0 ? void 0 : _a.api) === null || _b === void 0 ? void 0 : _b.getColumnDef(colId);
-                newColState.aggFunc =
-                    aggregationFunctionsColumnsMap[colId] === true
-                        ? // if we have true, it means - take the default aggFunc from colDef
-                            // NOTE: colState gives us the current aggFunc, which can be null,
-                            // while the colDef gives us the initially configured aggFunc for that column
-                            (_e = (_d = (_c = colState.aggFunc) !== null && _c !== void 0 ? _c : colDef === null || colDef === void 0 ? void 0 : colDef.aggFunc) !== null && _d !== void 0 ? _d : 
-                            // @ts-ignore available only wth ag-Grid v27.3.x
-                            colDef === null || colDef === void 0 ? void 0 : colDef.defaultAggFunc) !== null && _e !== void 0 ? _e : 'sum'
-                        : aggregationFunctionsColumnsMap[colId];
+                let aggFunc = null;
+                const aggFuncFromLayout = aggregationFunctionsColumnsMap[colId];
+                const adaptableAggFunc = this.getActiveAdaptableAggFuncForCol(colId);
+                if (aggFuncFromLayout === true) {
+                    // if we have true, it means - take the default aggFunc from colDef
+                    // NOTE: colState gives us the current aggFunc, which can be null,
+                    // while the colDef gives us the initially configured aggFunc for that column
+                    aggFunc =
+                        (_e = (_d = (_c = colState.aggFunc) !== null && _c !== void 0 ? _c : colDef === null || colDef === void 0 ? void 0 : colDef.aggFunc) !== null && _d !== void 0 ? _d : 
+                        // @ts-ignore available only wth ag-Grid v27.3.x
+                        colDef === null || colDef === void 0 ? void 0 : colDef.defaultAggFunc) !== null && _e !== void 0 ? _e : 'sum';
+                }
+                else if (adaptableAggFunc && adaptableAggFunc.type === 'weightedAverage') {
+                    aggFunc = AggregationColumns_1.WEIGHTED_AVERAGE_AGG_FN_NAME;
+                }
+                else if (typeof aggFuncFromLayout === 'string') {
+                    aggFunc = aggFuncFromLayout;
+                }
+                newColState.aggFunc = aggFunc;
             }
             if (sortModelMap[colId]) {
                 newColState.sort = sortModelMap[colId].sort;
@@ -1524,7 +1531,8 @@ class Adaptable {
         layout.ColumnSorts = columnSorts;
         layout.RowGroupedColumns = groupedColumns;
         if (Object.keys(aggregatedColumns).length) {
-            layout.AggregationColumns = aggregatedColumns;
+            // ag-grid aggregations are not 1-1 with adaptable column-aggregations
+            layout.AggregationColumns = this.handleUpdateWeightedAvgFromGrid(aggregatedColumns);
         }
         layout.EnablePivot = this.gridOptions.columnApi.isPivotMode();
         layout.PivotColumns = pivotColumns;
@@ -2028,7 +2036,9 @@ class Adaptable {
     getAllRowNodes(config) {
         let rowNodes = [];
         this.gridOptions.api.forEachNode((rowNode, rowIndex) => {
-            if (!this.isGroupRowNode(rowNode) || (config === null || config === void 0 ? void 0 : config.includeGroupRows)) {
+            const includeGroupRows = (config === null || config === void 0 ? void 0 : config.includeGroupRows) || !this.isGroupRowNode(rowNode);
+            const filterFnFulfilled = !(config === null || config === void 0 ? void 0 : config.filterFn) || (config === null || config === void 0 ? void 0 : config.filterFn(rowNode));
+            if (includeGroupRows && filterFnFulfilled) {
                 rowNodes.push(rowNode);
             }
         });
@@ -2186,10 +2196,31 @@ class Adaptable {
             return newColDef;
         });
     }
-    setupColumnValueGetter({ col }) {
-        // need this here if we want plugins to intercept
+    setupColumnValueGetter({ col, abColumn }) {
         this.setColDefProperty(col, 'valueGetter', (userValue) => {
-            return userValue;
+            return (params) => {
+                const columnId = abColumn.columnId;
+                let evaluatedUserValue = userValue;
+                if (typeof userValue === 'function') {
+                    evaluatedUserValue = userValue(params);
+                }
+                const defaultValue = evaluatedUserValue
+                    ? evaluatedUserValue
+                    : (params === null || params === void 0 ? void 0 : params.data)
+                        ? params.data[columnId]
+                        : undefined;
+                const adaptableAggFunc = this.getActiveAdaptableAggFuncForCol(columnId);
+                if (adaptableAggFunc && adaptableAggFunc.type === 'weightedAverage' && !params.node.group) {
+                    const weightedColumnId = adaptableAggFunc.weightedColumnId;
+                    return {
+                        [columnId]: defaultValue,
+                        [weightedColumnId]: params.data[weightedColumnId],
+                        toString: () => (defaultValue ? `${defaultValue}` : ''),
+                        valueOf: () => defaultValue,
+                    };
+                }
+                return defaultValue;
+            };
         });
     }
     setupColumnAggFunc({ col }) {
@@ -2377,42 +2408,8 @@ class Adaptable {
         this.safeSetColDefs(resultColDefs);
         this.setLayout();
     }
-    cleanupFloatingFilters_WORKAROUND() {
-        // since AG Grid v26.2.0 floating filters have a memory leak due to an dangling reference to an obsolete agSetFilter instance
-        var _a, _b;
-        // 1a. The initial floating filter component is defaulted to the 'agSetColumnFloatingFilter'
-        // (see https://github.com/ag-grid/ag-grid/blob/v26.2.0/community-modules/core/src/ts/headerRendering/cells/floatingFilter/headerFilterCellCtrl.ts#L210) and a corresponding bean component is instantiated.
-        //   1b. A listener to the 'filterChanged' event is created, referencing the newly created bean instance: https://github.com/ag-grid/ag-grid/blob/v26.2.0/community-modules/core/src/ts/headerRendering/cells/floatingFilter/headerFilterCellCtrl.ts#L298
-        //   2a. The floating filter is set to a custom component (via https://www.ag-grid.com/javascript-data-grid/column-properties/#reference-filtering-floatingFilterComponent), triggering the creation of a new floating filter bean component
-        //   2b. Another listener to the 'filterChanged' event is created, referencing the newly created (in step 2a) bean instance https://github.com/ag-grid/ag-grid/blob/v26.2.0/community-modules/core/src/ts/headerRendering/cells/floatingFilter/headerFilterCellCtrl.ts#L298
-        //   BUT the listener created in step 1b is NOT destroyed, leading to a state where the 'filterChanged' event has listeners stemming from both the current floating filter bean but also from the initial(now obsolete) bean
-        //
-        // As a consequence, any 'filterChanged' event will be processed by both listeners (1b, 2b) and will more often than not lead to a runtime exception due to the dangling references from the obsolete listener
-        // AG Grid team tracks this issue in AG-6179
-        // until a fix arrives, a workaround is to hide all the visible columns (thus destroying all the HeaderFilterCellCtrl instances)
-        if (!((_b = (_a = this.adaptableOptions) === null || _a === void 0 ? void 0 : _a.filterOptions) === null || _b === void 0 ? void 0 : _b.useAdaptableQuickFilter)) {
-            // no need to do anything if we don't use adaptable quick filter
-            return;
-        }
-        if (this.gridOptions.columnApi.isPivotMode()) {
-            // floating filters are NOT available in pivot mode
-            return;
-        }
-        // floating filter instances (HeaderFilterCellCtrl) are created only for rendered columns (in viewport)
-        // so we have to handle only the displayed columns
-        const allDisplayedCols = this.gridOptions.columnApi.getAllDisplayedColumns();
-        const colsWithFloatingFilter = allDisplayedCols.filter((col) => {
-            const colDef = col.getColDef();
-            return (colDef.floatingFilter ||
-                colDef.floatingFilterComponent ||
-                this.api.columnApi.usesAdaptableQuickFilter(col.getColId()));
-        });
-        colsWithFloatingFilter.forEach((col) => this.gridOptions.columnApi.setColumnsVisible(colsWithFloatingFilter, false));
-        // !! it is important to NOT set the columns visible again as this is already taken care of in the next performed method (this.updateColDefsForSpecialColumns())
-    }
     getColDefsForCalculatedColumns() {
         const defaultCalculatedColumnSettings = ObjectFactory_1.CreateEmptyCalculatedColumn().CalculatedColumnSettings;
-        const isExternalEvaluation = !this.api.internalApi.runModuleInAdaptableQL('CalculatedColumn');
         return this.api.calculatedColumnApi.getAllCalculatedColumn().map((calculatedColumn) => {
             const calculatedColumnSettings = Object.assign(Object.assign({}, defaultCalculatedColumnSettings), calculatedColumn.CalculatedColumnSettings);
             if (!calculatedColumnSettings.DataType) {
@@ -2426,6 +2423,7 @@ class Adaptable {
             if (ArrayExtensions_1.ArrayExtensions.IsNotNullOrEmpty(calculatedColumnSettings.ColumnTypes)) {
                 columnTypes.push(...calculatedColumnSettings.ColumnTypes);
             }
+            const isExternalEvaluation = !this.api.internalApi.evaluateExpressionInAdaptableQL('CalculatedColumn', this.api.queryLanguageApi.getAdaptableQueryExpression(calculatedColumn.Query));
             const newColDef = {
                 headerName: calculatedColumn.FriendlyName
                     ? calculatedColumn.FriendlyName
@@ -2455,7 +2453,7 @@ class Adaptable {
             if (calculatedColumnSettings.ShowToolTip != null &&
                 calculatedColumnSettings.ShowToolTip == true) {
                 newColDef.tooltipValueGetter = () => {
-                    return this.api.queryLanguageApi.getAdaptableQueryExpression(calculatedColumn.Query);
+                    return this.api.internalApi.getAdaptableQueryExpressionText(calculatedColumn.Query);
                 };
             }
             if (calculatedColumnSettings.HeaderToolTip) {
@@ -2540,7 +2538,23 @@ class Adaptable {
             this.throttleFilterOnTickingDataChange = null;
             this.gridOptions.api.__adaptable = null;
             this.gridOptions.api.setColumnDefs = GridApi_setColumnDefs;
-            this.gridOptions.getRowStyle = null;
+            this.revertGridOptionsPropertiesToUserValue([
+                'getRowStyle',
+                'getRowClass',
+                'excelStyles',
+                'suppressAggFuncInHeader',
+                'initialGroupOrderComparator',
+                'getContextMenuItems',
+                'getMainMenuItems',
+                'isExternalFilterPresent',
+                'doesExternalFilterPass',
+                'statusBar',
+                'sideBar',
+                'aggFuncs',
+            ]);
+            if (this.gridOptions.components) {
+                this.gridOptions.components.AdaptableToolPanel = null;
+            }
             if (config && config.destroyApi === false) {
             }
             else {
@@ -2560,6 +2574,8 @@ class Adaptable {
         this.emitter.destroy();
         this.emitter = null;
         this._adaptableReady = false;
+        this.agGridHelper.destroy();
+        this.agGridMenuHelper.destroy();
         Adaptable.dismissInstance(this);
         const abContainerElement = this.getAdaptableContainerElement();
         if (config && !config.unmount) {
@@ -2894,74 +2910,78 @@ class Adaptable {
             },
         };
         // We plug our filter mechanism and if there is already something like external widgets... we save ref to the function
-        const original_isExternalFilterPresent = this.gridOptions.isExternalFilterPresent;
-        this.gridOptions.isExternalFilterPresent = (params) => {
-            if (this.isDestroyed) {
-                return true;
-            }
-            const columnFilters = this.api.filterApi.getColumnFilters();
-            const isFilterActive = ArrayExtensions_1.ArrayExtensions.IsNotNullOrEmpty(columnFilters);
-            const isQueryActive = StringExtensions_1.StringExtensions.IsNotNullOrEmpty(this.api.queryApi.getCurrentQuery());
-            return (isFilterActive ||
-                isQueryActive ||
-                // it means that originaldoesExternalFilterPass will be called so we reinit that collection
-                (original_isExternalFilterPresent ? original_isExternalFilterPresent(params) : false));
-        };
-        const originaldoesExternalFilterPass = this.gridOptions.doesExternalFilterPass;
-        const evaluateQueryOnClient = this.api.internalApi.runModuleInAdaptableQL('Query');
-        const evaluateFilterOnClient = this.api.internalApi.runModuleInAdaptableQL('Filter');
-        this.gridOptions.doesExternalFilterPass = (node) => {
-            if (this.isDestroyed) {
-                return true;
-            }
-            // first we assess Query (if its running locally)
-            if (evaluateQueryOnClient && !this.isGroupRowNode(node)) {
-                const currentQuery = this.api.queryApi.getCurrentQuery();
-                if (currentQuery) {
-                    const isCurrentQueryValid = this.api.queryLanguageApi.isValidBooleanExpression(currentQuery, ModuleConstants_1.QueryModuleId, `Invalid CurrentQuery '${currentQuery}'`);
-                    if (!isCurrentQueryValid ||
-                        !this.api.internalApi
-                            .getQueryLanguageService()
-                            .evaluateBooleanExpression(currentQuery, ModuleConstants_1.QueryModuleId, node)) {
-                        return false;
-                    }
+        this.setGridOptionsProperty('isExternalFilterPresent', (originalIsExternalFilterPresent) => {
+            return (params) => {
+                if (this.isDestroyed) {
+                    return true;
                 }
-            }
-            try {
-                // we then assess filters (if running locally)
-                if (evaluateFilterOnClient) {
-                    const columnFilters = this.api.filterApi.getColumnFilters();
-                    if (columnFilters.length > 0) {
-                        for (const columnFilter of columnFilters) {
-                            if (!this.api.filterApi.evaluateColumnFilter(columnFilter, node)) {
+                const columnFilters = this.api.filterApi.getActiveColumnFilters();
+                const isFilterActive = ArrayExtensions_1.ArrayExtensions.IsNotNullOrEmpty(columnFilters);
+                const isQueryActive = StringExtensions_1.StringExtensions.IsNotNullOrEmpty(this.api.queryApi.getCurrentQuery());
+                return (isFilterActive ||
+                    isQueryActive ||
+                    // it means that originalIsExternalFilterPresent will be called so we reinit that collection
+                    (originalIsExternalFilterPresent ? originalIsExternalFilterPresent(params) : false));
+            };
+        });
+        this.setGridOptionsProperty('doesExternalFilterPass', (originalDoesExternalFilterPass) => {
+            return (node) => {
+                if (this.isDestroyed) {
+                    return true;
+                }
+                // first we assess Query (if its running locally)
+                if (!this.isGroupRowNode(node)) {
+                    const currentQuery = this.api.queryApi.getCurrentQuery();
+                    if (currentQuery) {
+                        const evaluateQueryOnClient = this.api.internalApi.evaluateExpressionInAdaptableQL('Query', currentQuery);
+                        if (evaluateQueryOnClient) {
+                            const isCurrentQueryValid = this.api.queryLanguageApi.isValidBooleanExpression(currentQuery, ModuleConstants_1.QueryModuleId, `Invalid CurrentQuery '${currentQuery}'`);
+                            if (!isCurrentQueryValid ||
+                                !this.api.internalApi
+                                    .getQueryLanguageService()
+                                    .evaluateBooleanExpression(currentQuery, ModuleConstants_1.QueryModuleId, node)) {
                                 return false;
                             }
                         }
                     }
                 }
-            }
-            catch (ex) {
-                LoggingHelper_1.LogAdaptableError(ex);
-                return false;
-            }
-            return originaldoesExternalFilterPass ? originaldoesExternalFilterPass(node) : true;
-        };
-        // Build the COLUMN MENU.  Note that we do this EACH time the menu is opened (as items can change)
-        const originalgetMainMenuItems = this.gridOptions.getMainMenuItems;
-        this.gridOptions.getMainMenuItems = (params) => {
-            // couldnt find a way to listen for menu close. There is a Menu Item Select, but you can also close menu from filter and clicking outside menu....
-            return this.agGridMenuHelper.buildColumnMenu(params, originalgetMainMenuItems);
-        };
-        // Build the CONTEXT MENU.  Again we do this each time a cell is right clicked as its context-sensitive
-        const originalgetContextMenuItems = this.gridOptions.getContextMenuItems;
-        this.gridOptions.getContextMenuItems = (params) => {
-            return this.agGridMenuHelper.buildContextMenu(params, originalgetContextMenuItems);
-        };
+                const evaluateFilterOnClient = this.api.internalApi.evaluateExpressionInAdaptableQL('Filter');
+                try {
+                    // we then assess filters (if running locally)
+                    if (evaluateFilterOnClient) {
+                        const columnFilters = this.api.filterApi.getActiveColumnFilters();
+                        if (columnFilters.length > 0) {
+                            for (const columnFilter of columnFilters) {
+                                if (!this.api.filterApi.evaluateColumnFilter(columnFilter, node)) {
+                                    return false;
+                                }
+                            }
+                        }
+                    }
+                }
+                catch (ex) {
+                    LoggingHelper_1.LogAdaptableError(ex);
+                    return false;
+                }
+                return originalDoesExternalFilterPass ? originalDoesExternalFilterPass(node) : true;
+            };
+        });
+        this.setGridOptionsProperty('getMainMenuItems', (userPropertyValue) => {
+            return (params) => {
+                // couldnt find a way to listen for menu close. There is a Menu Item Select, but you can also close menu from filter and clicking outside menu....
+                return this.agGridMenuHelper.buildColumnMenu(params, userPropertyValue);
+            };
+        });
+        this.setGridOptionsProperty('getContextMenuItems', (userPropertyValue) => {
+            return (params) => {
+                return this.agGridMenuHelper.buildContextMenu(params, userPropertyValue);
+            };
+        });
         this.prepareGrid();
     }
     updateColumnFilterActiveState() {
         var _a;
-        const columnFilters = this.api.filterApi.getColumnFilters();
+        const columnFilters = this.api.filterApi.getActiveColumnFilters();
         const activeFilters = (_a = columnFilters === null || columnFilters === void 0 ? void 0 : columnFilters.filter) === null || _a === void 0 ? void 0 : _a.call(columnFilters, (columnFilter) => this.api.filterApi.isFilterActive(columnFilter));
         const isFilterActive = ArrayExtensions_1.ArrayExtensions.IsNotNullOrEmpty(activeFilters);
         const columnsWithActiveFilters = {};
@@ -3043,6 +3063,8 @@ class Adaptable {
             this.setupColumnCellEditor(colSetupInfo);
             this.setupColumnHeader(colSetupInfo);
             this.setupColumnQuickFilerText(colSetupInfo);
+            this.setupAllowedAggFuncs(colSetupInfo);
+            this.setupColumnKeyCreator(colSetupInfo);
         });
         this.setupRowStyling();
         // setupAggregationColumnHeaders() is executed on every setLayout()
@@ -3052,6 +3074,14 @@ class Adaptable {
         this.redrawBody();
         this.redrawHeader();
     }
+    revertGridOptionsPropertiesToUserValue(propertyNames) {
+        for (const propertyName of propertyNames) {
+            // see this.setGridOptionsProperty(...)
+            const userKey = `user.${propertyName}`;
+            const userValue = this.gridOptionsPropertyCache.get(userKey);
+            this.gridOptions[propertyName] = userValue;
+        }
+    }
     setGridOptionsProperty(propertyName, propertyGetter) {
         if (this.isDestroyed) {
             return;
@@ -3290,6 +3320,49 @@ class Adaptable {
             };
         });
     }
+    setupAllowedAggFuncs({ col, abColumn }) {
+        this.setColDefProperty(col, 'allowedAggFuncs', () => {
+            return abColumn.availableAggregationFunctions;
+        });
+    }
+    triggerSetupColumnKeyCreator(colId) {
+        const col = this.gridOptions.columnApi.getColumn(colId);
+        const colDef = col.getColDef();
+        const abColumn = this.api.columnApi.getColumnFromId(colId);
+        const colSetupInfo = {
+            col,
+            colDef,
+            colId,
+            abColumn,
+        };
+        this.setupColumnKeyCreator(colSetupInfo);
+    }
+    setupColumnKeyCreator(columnSetupInfo) {
+        const { col, abColumn } = columnSetupInfo;
+        const adaptableOptions = this.adaptableOptions;
+        const adaptableApi = this.api;
+        this.setColDefProperty(col, 'keyCreator', (userPropertyValue) => {
+            return (params) => {
+                var _a;
+                if (typeof userPropertyValue === 'function') {
+                    return userPropertyValue(params);
+                }
+                const value = params.value;
+                const groupUnbalancedGroupsUnderKey = (_a = adaptableOptions.layoutOptions) === null || _a === void 0 ? void 0 : _a.groupUnbalancedGroupsUnderKey;
+                if (!groupUnbalancedGroupsUnderKey) {
+                    return value;
+                }
+                let groupUnbalancedGroupsUnderKeyValue = typeof groupUnbalancedGroupsUnderKey === 'function'
+                    ? groupUnbalancedGroupsUnderKey({
+                        adaptableApi: adaptableApi,
+                        adaptableColumn: abColumn,
+                        params,
+                    })
+                    : groupUnbalancedGroupsUnderKey;
+                return value === null || value === undefined ? groupUnbalancedGroupsUnderKeyValue : value;
+            };
+        });
+    }
     setupColumnHeader({ col, abColumn }) {
         var _a, _b;
         const previousColumnHeader = (_a = col === null || col === void 0 ? void 0 : col.getColDef()) === null || _a === void 0 ? void 0 : _a.headerName;
@@ -3487,11 +3560,6 @@ class Adaptable {
     applyCurrentTheme() {
         this.api.themeApi.applyCurrentTheme();
     }
-    getInitialGroupOrderComparator(gridOptions) {
-        var _a, _b;
-        // fallback to deprecated forms
-        return ((_b = (_a = gridOptions.initialGroupOrderComparator) !== null && _a !== void 0 ? _a : gridOptions.defaultGroupOrderComparator) !== null && _b !== void 0 ? _b : gridOptions.defaultGroupSortComparator);
-    }
     applyFinalRendering() {
         this.embedColumnMenu = this.isModulePresent('menu');
         if (this.gridOptions.treeData && this.gridOptions.treeData == true) {
@@ -4625,6 +4693,54 @@ import "@adaptabletools/adaptable/themes/${themeName}.css"`);
         }
         return this.gridOptions.api.getChartModels();
     }
+    getActiveAdaptableAggFuncForCol(columnId) {
+        if (!columnId) {
+            return null;
+        }
+        const currentLayout = this.api.layoutApi.getCurrentLayout();
+        const aggregationFunctionsColumnsMap = currentLayout.AggregationColumns || {};
+        const adaptableAggFunc = aggregationFunctionsColumnsMap[columnId];
+        if (typeof adaptableAggFunc === 'object' &&
+            'type' in adaptableAggFunc &&
+            adaptableAggFunc.type === 'weightedAverage') {
+            return adaptableAggFunc;
+        }
+        return null;
+    }
+    registerAdaptableAggFuncs() {
+        this.setGridOptionsProperty('aggFuncs', (originalAggFuncs) => {
+            const aggregationFunctions = originalAggFuncs || {};
+            aggregationFunctions[AggregationColumns_1.WEIGHTED_AVERAGE_AGG_FN_NAME] = (params) => {
+                const columnId = params.column.getColId();
+                const adaptableAggFunc = this.getActiveAdaptableAggFuncForCol(columnId);
+                if (!adaptableAggFunc) {
+                    return undefined;
+                }
+                if (adaptableAggFunc.type === 'weightedAverage') {
+                    return weightedAverage_1.weightedAverage(params, params.colDef.colId, adaptableAggFunc.weightedColumnId);
+                }
+                return undefined;
+            };
+            return aggregationFunctions;
+        });
+    }
+    /**
+     * When reading the state from the grid, we have to make sure 'avg' is not overriden with the 'avg' string.
+     */
+    handleUpdateWeightedAvgFromGrid(aggFuncFromGrid) {
+        const currentLayout = this.api.layoutApi.getCurrentLayout();
+        return Object.entries(aggFuncFromGrid).reduce((acc, [colId, agg]) => {
+            const adaptableAggFunc = this.getActiveAdaptableAggFuncForCol(colId);
+            if ((adaptableAggFunc === null || adaptableAggFunc === void 0 ? void 0 : adaptableAggFunc.type) === 'weightedAverage' && agg === AggregationColumns_1.WEIGHTED_AVERAGE_AGG_FN_NAME) {
+                // do not override the agg func
+                acc[colId] = currentLayout.AggregationColumns[colId];
+            }
+            else {
+                acc[colId] = agg;
+            }
+            return acc;
+        }, {});
+    }
 }
 exports.Adaptable = Adaptable;
 class AdaptableNoCodeWizard {

package/src/agGrid/agGridHelper.d.ts

@@ -16,6 +16,7 @@ export declare class agGridHelper {
     private gridOptions;
     private initialAgGridColDefs;
     constructor(adaptable: IAdaptable, gridOptions: GridOptions);
+    destroy(): void;
     getAgGridLightThemeName(): string;
     getAgGridDarkThemeName(): string;
     setUpModules(): Map<AdaptableModule, IModule>;

package/src/agGrid/agGridHelper.js

@@ -41,8 +41,8 @@ const PercentBarRenderer_1 = require("./PercentBarRenderer");
 const Helper_1 = require("../Utilities/Helpers/Helper");
 const StatusBarModule_1 = require("../Strategy/StatusBarModule");
 const GeneralConstants = tslib_1.__importStar(require("../Utilities/Constants/GeneralConstants"));
-const UIHelper_1 = tslib_1.__importDefault(require("../View/UIHelper"));
 const GeneralConstants_1 = require("../Utilities/Constants/GeneralConstants");
+const UIHelper_1 = tslib_1.__importDefault(require("../View/UIHelper"));
 const tinycolor = require('tinycolor2');
 /**
  * Adaptable AG Grid implementation is getting really big and unwieldy
@@ -55,8 +55,10 @@ class agGridHelper {
         this.adaptable = adaptable;
         this.gridOptions = gridOptions;
         this.initialAgGridColDefs = {};
-        this.adaptable = adaptable;
-        this.gridOptions = gridOptions;
+    }
+    destroy() {
+        this.adaptable = null;
+        this.gridOptions = null;
     }
     getAgGridLightThemeName() {
         // we try not to call these two methods, as we try to detect the default grid

package/src/agGrid/agGridMenuHelper.d.ts

@@ -6,6 +6,7 @@ export declare class agGridMenuHelper {
     private adaptable;
     private gridOptions;
     constructor(adaptable: IAdaptable, gridOptions: GridOptions);
+    destroy(): void;
     buildColumnMenu(params: GetMainMenuItemsParams, originalgetMainMenuItems: GetMainMenuItems): (string | MenuItemDef)[];
     buildContextMenu(params: GetContextMenuItemsParams, originalgetContextMenuItems: GetContextMenuItems): (string | MenuItemDef)[];
     createRemoveGroupsMenuItem(x: AdaptableMenuItem): MenuItemDef;

package/src/agGrid/agGridMenuHelper.js

@@ -11,8 +11,10 @@ class agGridMenuHelper {
     constructor(adaptable, gridOptions) {
         this.adaptable = adaptable;
         this.gridOptions = gridOptions;
-        this.adaptable = adaptable;
-        this.gridOptions = gridOptions;
+    }
+    destroy() {
+        this.adaptable = null;
+        this.gridOptions = null;
     }
     buildColumnMenu(params, originalgetMainMenuItems) {
         // couldnt find a way to listen for menu close. There is a Menu Item Select, but you can also close menu from filter and clicking outside menu....

package/src/agGrid/weightedAverage.d.ts

@@ -0,0 +1,6 @@
+import { IAggFuncParams } from '@ag-grid-community/all-modules';
+export declare const weightedAverage: (params: IAggFuncParams, columnId: string, weightColumnId: string) => {
+    [x: string]: number | (() => number | "");
+    toString: () => number | "";
+    valueOf: () => number;
+};