@adaptabletools/adaptable 20.3.0-canary.2 → 21.0.0-canary.0

package/src/agGrid/AdaptableAgGrid.js

@@ -98,6 +98,7 @@ import { agGridDataTypeDefinitions } from './agGridDataTypeDefinitions';
 import { AgGridThemeAdapter } from './AgGridThemeAdapter';
 import { mapOldTypeToDataType } from '../migration/VersionUpgrade20';
 import { tagProvidedByAdaptable } from '../Utilities/adaptableOverrideCheck';
+import { AgGridModulesAdapter } from './AgGridModulesAdapter';
 const LocalEventService_Prototype = LocalEventService.prototype;
 const LocalEventService_dispatchEvent = LocalEventService_Prototype.dispatchEvent;
 LocalEventService_Prototype.dispatchEvent = function (event) {
@@ -108,7 +109,12 @@ LocalEventService_Prototype.dispatchEvent = function (event) {
     }
     LocalEventService_dispatchEvent.apply(this, arguments);
     if (event.type === 'cellChanged' || event.type === 'dataChanged') {
+        // @ts-ignore
         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) {
@@ -181,6 +187,7 @@ export class AdaptableAgGrid {
         this.agGridColumnAdapter = new AgGridColumnAdapter(this);
         this.agGridExportAdapter = new AgGridExportAdapter(this);
         this.agGridThemeAdapter = new AgGridThemeAdapter(this);
+        this.agGridModulesAdapter = new AgGridModulesAdapter(this);
         this.DataService = new DataService(this);
     }
     static forEachAdaptable(fn) {
@@ -348,26 +355,29 @@ export class AdaptableAgGrid {
         this.lifecycleState = 'setupAgGrid';
         const gridOptions = config.gridOptions;
         // Needed here because special column defs are required for deriving the adaptable column state
-        const columnDefs = this.agGridAdapter.getColumnDefinitionsInclSpecialColumns(gridOptions.columnDefs || []);
+        let columnDefs = this.agGridAdapter.getColumnDefinitionsInclSpecialColumns(gridOptions.columnDefs || []);
         gridOptions.columnDefs = columnDefs;
         this.setInitialGridOptions(gridOptions, config.variant);
-        const { gridState: initialGridState, layoutModel } = this.mapAdaptableStateToAgGridState(this.adaptableStore.TheStore.getState(), gridOptions.columnDefs, { isTree: !!gridOptions.treeData });
+        const { gridState: initialGridState, layoutModel } = this.mapAdaptableStateToAgGridState(this.adaptableStore.TheStore.getState(), gridOptions.columnDefs, {
+            isTree: !!gridOptions.treeData,
+            colTypes: gridOptions.columnTypes,
+            defaultColDef: gridOptions.defaultColDef,
+        });
+        columnDefs = LayoutManager.getColumnDefsChangesForLayout(layoutModel, columnDefs) ?? columnDefs;
+        gridOptions.columnDefs = columnDefs;
         gridOptions.initialState = initialGridState;
         if (layoutModel) {
             if (isPivotLayoutModel(layoutModel)) {
                 gridOptions.pivotDefaultExpanded = layoutModel.PivotExpandLevel;
             }
-            else {
-                gridOptions.groupDisplayType =
-                    layoutModel.RowGroupDisplayType === 'multi' ? 'multipleColumns' : 'singleColumn';
-            }
+            gridOptions.groupDisplayType =
+                layoutModel.RowGroupDisplayType === 'multi' ? 'multipleColumns' : 'singleColumn';
+            // fixes issue #3053
+            gridOptions.suppressAggFuncInHeader = !!layoutModel.SuppressAggFuncInHeader;
         }
         this.lifecycleState = 'initAgGrid';
         this.agGridAdapter.initialGridOptions = gridOptions;
         const perfInitAgGrid = this.logger.beginPerf(`initAgGrid()`);
-        // AG Grid evaluates early on the floatingFilter params, so we need to "suppress" the floating filter temporarily
-        // we will reset it once Adaptable is ready
-        this.agGridColumnAdapter.setupColumnFloatingFilterTemporarily(gridOptions);
         this.validateColumnDefTypes(gridOptions.columnDefs);
         const agGridApi = await this.initializeAgGrid(gridOptions, config.modules, config.renderAgGridFrameworkComponent);
         if (agGridApi === false) {
@@ -406,7 +416,9 @@ export class AdaptableAgGrid {
         this.agGridAdapter.monkeyPatchingGridOptionsUpdates();
         this.agGridAdapter.monkeyPatchingAggColumnFilters();
         this.lifecycleState = 'agGridReady';
-        this.logger.info(`Registered AG Grid modules: `, this.agGridAdapter.getAgGridRegisteredModuleNames().sort());
+        this.api.entitlementApi.internalApi.setModulesAgGridDepsInfos();
+        this.ModuleService.logMissingAgGridDepsInfos();
+        this.logger.info(`Registered AG Grid modules (incl. dependent modules): `, this.agGridModulesAdapter.getAgGridRegisteredModuleNames().sort());
         /**
          * At this point AG Grid is initialized!
          */
@@ -418,6 +430,9 @@ export class AdaptableAgGrid {
         this.validatePrimaryKey();
         // TODO AFL MIG: we could just patch the defautl Layout on init? instead
         this.checkShouldClearExistingFiltersOrSearches();
+        // FIXME AFL FILTER: talk with Radu: should ColumnFilters still be ignored?!
+        // see layoutModel.Ignore_ColumnFilters
+        // initial filter model
         this.applyFiltering();
         // apply quick search if there is one
         // yes, we could have put this on the gridOptions.findSearchValue
@@ -436,19 +451,6 @@ export class AdaptableAgGrid {
         checkForDuplicateColumns(currentLayout);
         this._prevLayout = currentLayout;
         this.__prevLayoutForRefresh = currentLayout;
-        if (isPivotLayout(currentLayout)) {
-            // this is very very strange!
-            // for some projects, if the initial layout is pivot, the columnDefs of the pivot resutl columns are NOT derived correctly from the main colDefs
-            // doing the following line fixes the issue because it foces the pivot columns to be created again
-            // this proj works without the hack: /tests/pages/format-column/initial-pivot-layout.page.tsx
-            // but this proj needs the hack: /tests/pages/format-column/initial-pivot-layout-docs.page.tsx
-            this.agGridAdapter.setGridOption('pivotMode', false);
-            this.agGridAdapter.setGridOption('pivotMode', true);
-            // also quick search is not working initially, although the setupColumns is called correctly
-            // so we need to do this to make it work
-            // see test /tests/pages/quick-search/pivot-search.spec.ts
-            this.updateColumnModelAndRefreshGrid();
-        }
         const layoutModelForApply = layoutStateToLayoutModel(currentLayout);
         this.layoutManager.applyRowGroupValues(layoutModelForApply.RowGroupValues, layoutModelForApply.RowGroupedColumns);
         this.layoutManager.applyColumnGroupCollapseExpandState(layoutModelForApply);
@@ -572,21 +574,27 @@ You need to define at least one Layout!`);
             normalize: true,
         });
     }
-    applyFiltering() {
+    applyFiltering(config) {
+        // default updateColumnFilterModel to TRUE, if not provided
+        const updateColumnFilterModel = config?.updateColumnFilterModel ?? true;
         const agGridApi = this.agGridAdapter.getAgGridApi();
-        this._emit('AdapTableFiltersApplied');
+        if (updateColumnFilterModel) {
+            const columnFilters = this.api.filterApi.columnFilterApi
+                .getActiveColumnFilters()
+                // FIXME AFL: we need this additional filter because 'getActiveColumnFilters' checks only for suspended while 'isColumnFilterActive' also checkss for COMPLETE filters
+                .filter((columnFilter) => this.api.filterApi.columnFilterApi.isColumnFilterActive(columnFilter));
+            const filterModel = {};
+            columnFilters.forEach((columnFilter) => {
+                filterModel[columnFilter.ColumnId] = columnFilter;
+            });
+            agGridApi.setFilterModel(filterModel);
+        }
+        // FIXME AFL FILTER why is this needed???
         this.refreshSelectedCellsState();
         this.refreshSelectedRowsState();
-        this.agGridAdapter.updateColumnFilterActiveState();
         agGridApi.onFilterChanged();
+        this._emit('AdapTableFiltersApplied');
     }
-    // refreshAgGridWithAdaptableState() {
-    //   this.refreshColDefs();
-    //   this.api.themeApi.applyCurrentTheme();
-    //   this.api.internalApi.setTreeMode(this.agGridAdapter.initialGridOptions.treeData);
-    //   this.checkShouldClearExistingFiltersOrSearches();
-    //   this.applyColumnFiltering();
-    // }
     showQuickFilter() {
         const height = this.api.optionsApi.getFilterOptions().columnFilterOptions.quickFilterHeight;
         this.agGridAdapter.getAgGridApi().setGridOption('floatingFiltersHeight', height);
@@ -640,12 +648,15 @@ You need to define at least one Layout!`);
          */
         this.agGridOptionsService.setGridOptionsProperty(gridOptions, 'defaultColDef', (original_defaultColDef) => {
             if (original_defaultColDef?.headerValueGetter) {
-                this.logger.warn(`defaultColDef.headerValueGetter and overrides the Adaptable custom header mechanism! We recommend using a ColumnOptions.tableColumnHeader instead!`);
+                this.logger.warn(`defaultColDef.headerValueGetter and overrides the Adaptable custom header mechanism! We recommend using a ColumnOptions.columnHeader instead!`);
                 return original_defaultColDef;
             }
+            // #customize_header
             const defaultColDef = { ...original_defaultColDef };
             defaultColDef.headerValueGetter = tagProvidedByAdaptable((params) => {
-                return this.api.columnApi.internalApi.getColumnHeaderName(params);
+                const columnHeaderName = this.api.columnApi.internalApi.getColumnHeaderName(params);
+                const formattedHeaderName = this.api.formatColumnApi.internalApi.formatColumnHeaderName(columnHeaderName, params);
+                return formattedHeaderName;
             });
             return defaultColDef;
         });
@@ -767,22 +778,36 @@ You need to define at least one Layout!`);
                 ? true
                 : original_allowContextMenuWithControlKey;
         });
+        /**
+         * `enableFilterHandlers`
+         */
+        this.agGridOptionsService.setGridOptionsProperty(gridOptions, 'enableFilterHandlers', (original_enableFilterHandlers) => {
+            const useAdaptableFiltering = this.api.optionsApi.getFilterOptions().useAdaptableFiltering;
+            if (useAdaptableFiltering) {
+                return true;
+            }
+            return original_enableFilterHandlers;
+        });
+        /**
+         * `suppressSetFilterByDefault`
+         */
+        this.agGridOptionsService.setGridOptionsProperty(gridOptions, 'suppressSetFilterByDefault', (original_suppressSetFilterByDefault) => {
+            const useAdaptableFiltering = this.api.optionsApi.getFilterOptions().useAdaptableFiltering;
+            if (useAdaptableFiltering) {
+                return true;
+            }
+            return original_suppressSetFilterByDefault;
+        });
         /**
          * `isExternalFilterPresent`
          */
         this.agGridOptionsService.setGridOptionsProperty(gridOptions, 'isExternalFilterPresent', (original_isExternalFilterPresent) => {
             return (params) => {
                 if (!this.isAvailable) {
-                    return true;
+                    return false;
                 }
                 const isGridFilterActive = StringExtensions.IsNotNullOrEmpty(this.api.filterApi.gridFilterApi.getCurrentGridFilterExpression());
-                const isTableColumnFiltersActive = ArrayExtensions.IsNotNullOrEmpty(this.api.filterApi.columnFilterApi
-                    .getActiveColumnFilters()
-                    .filter((columnFilter) => !this.api.columnApi.isPivotResultColumn(columnFilter.ColumnId)));
                 return (isGridFilterActive ||
-                    // only Table ColumnFilters are handled here
-                    // see #doAggregateFiltersPassMonkeyPatcher for filtering Pivot Columns
-                    isTableColumnFiltersActive ||
                     // it means that userPropertyValue will be called so we re-init that collection
                     (original_isExternalFilterPresent ? original_isExternalFilterPresent(params) : false));
             };
@@ -810,20 +835,11 @@ You need to define at least one Layout!`);
                         return true;
                     }
                 }
-                // first assess if the Row i s filterable - if not, then return true so it appears in Grid
-                const isRowFilterable = this.api.optionsApi.getFilterOptions().isRowFilterable;
-                if (typeof isRowFilterable === 'function') {
-                    const rowFilterableContext = {
-                        ...this.api.internalApi.buildBaseContext(),
-                        rowNode: node,
-                        data: node.data,
-                    };
-                    if (!isRowFilterable(rowFilterableContext)) {
-                        return true;
-                    }
+                // first assess if the Row is filterable - if not, then return true so it always appears in Grid
+                const isRowFilterable = this.api.gridApi.internalApi.isRowFilterable(node);
+                if (!isRowFilterable) {
+                    return true;
                 }
-                // get the Primary Key Value for the Row Node being evaluated
-                const primaryKey = this.getPrimaryKeyValueFromRowNode(node);
                 // next we assess a Grid Filter (if its running locally)
                 const currentGridFilterExpression = this.api.filterApi.gridFilterApi.getCurrentGridFilterExpression();
                 if (StringExtensions.IsNotNullOrEmpty(currentGridFilterExpression)) {
@@ -843,29 +859,6 @@ You need to define at least one Layout!`);
                         }
                     }
                 }
-                // finally we evaluate column filters
-                const tableColumnFilters = this.api.filterApi.columnFilterApi
-                    .getActiveColumnFilters()
-                    .filter((columnFilter) => !this.api.columnApi.isPivotResultColumn(columnFilter.ColumnId));
-                try {
-                    // only Table ColumnFilters are handled here
-                    // see #doAggregateFiltersPassMonkeyPatcher for filtering Pivot Columns
-                    if (tableColumnFilters.length > 0) {
-                        for (const columnFilter of tableColumnFilters) {
-                            const evaluateColumnFilterOnClient = this.api.expressionApi.internalApi.shouldEvaluatePredicatesInAdaptableQL('ColumnFilter', columnFilter, columnFilter.Predicates);
-                            if (evaluateColumnFilterOnClient) {
-                                const columnFilterEvaluationResult = this.api.filterApi.columnFilterApi.internalApi.evaluateColumnFilter(columnFilter, node);
-                                if (!columnFilterEvaluationResult) {
-                                    return false;
-                                }
-                            }
-                        }
-                    }
-                }
-                catch (ex) {
-                    this.logger.error(ex);
-                    return false;
-                }
                 const result = original_doesExternalFilterPass
                     ? original_doesExternalFilterPass(node)
                     : true;
@@ -913,107 +906,111 @@ You need to define at least one Layout!`);
         /**
          * `sidebar`
          */
-        this.agGridOptionsService.setGridOptionsProperty(gridOptions, 'sideBar', (original_sideBar) => {
-            if (!original_sideBar) {
-                // lucky us, no sideBar is defined, so we don't have to do anything
-                return original_sideBar;
-            }
-            const isAdaptableToolPanelHidden = this.api.entitlementApi.isModuleHiddenEntitlement('ToolPanel');
-            const adaptableToolPanelDef = {
-                id: GeneralConstants.ADAPTABLE_TOOLPANEL_ID,
-                toolPanel: GeneralConstants.ADAPTABLE_TOOLPANEL_COMPONENT,
-                labelDefault: GeneralConstants.ADAPTABLE,
-                labelKey: 'adaptable',
-                iconKey: 'menu',
-                width: UIHelper.getAdaptableToolPanelWidth(),
-                minWidth: UIHelper.getAdaptableToolPanelWidth(),
-                // maxWidth = undefined,
-            };
-            const mapToolPanelDefs = (toolPanelDefs = []) => {
-                // if it's an alias for the adaptable tool panel, map it to a ToolPanelDef, otherwise return it as it is
-                return toolPanelDefs.map((toolPanelDef) => toolPanelDef === GeneralConstants.ADAPTABLE_TOOLPANEL_ID
-                    ? adaptableToolPanelDef
-                    : toolPanelDef);
-            };
-            const isSideBarDefObject = (sidebarDef) => {
-                return Array.isArray(sidebarDef?.toolPanels);
-            };
-            let result;
-            if (original_sideBar === true) {
-                // create all tool panels with default settings
-                const toolPanels = [];
-                toolPanels.push(GeneralConstants.AGGRID_TOOLPANEL_FILTERS);
-                toolPanels.push(GeneralConstants.AGGRID_TOOLPANEL_COLUMNS);
-                if (!isAdaptableToolPanelHidden) {
-                    toolPanels.push(adaptableToolPanelDef);
+        if (gridOptions.sideBar != undefined) {
+            this.agGridOptionsService.setGridOptionsProperty(gridOptions, 'sideBar', (original_sideBar) => {
+                if (!original_sideBar) {
+                    // lucky us, no sideBar is defined, so we don't have to do anything
+                    return original_sideBar;
                 }
-                result = {
-                    toolPanels: toolPanels,
+                const isAdaptableToolPanelHidden = this.api.entitlementApi.isModuleHiddenEntitlement('ToolPanel');
+                const adaptableToolPanelDef = {
+                    id: GeneralConstants.ADAPTABLE_TOOLPANEL_ID,
+                    toolPanel: GeneralConstants.ADAPTABLE_TOOLPANEL_COMPONENT,
+                    labelDefault: GeneralConstants.ADAPTABLE,
+                    labelKey: 'adaptable',
+                    iconKey: 'menu',
+                    width: UIHelper.getAdaptableToolPanelWidth(),
+                    minWidth: UIHelper.getAdaptableToolPanelWidth(),
+                    // maxWidth = undefined,
                 };
-            }
-            // if there is only one tool panel, and it's the adaptable one => we have to handle it
-            else if (typeof original_sideBar === 'string') {
-                if (gridOptions.sideBar === GeneralConstants.ADAPTABLE_TOOLPANEL_ID) {
-                    if (!isAdaptableToolPanelHidden)
-                        result = {
-                            toolPanels: [adaptableToolPanelDef],
-                        };
-                }
-                else {
-                    result = original_sideBar;
+                const mapToolPanelDefs = (toolPanelDefs = []) => {
+                    // if it's an alias for the adaptable tool panel, map it to a ToolPanelDef, otherwise return it as it is
+                    return toolPanelDefs.map((toolPanelDef) => toolPanelDef === GeneralConstants.ADAPTABLE_TOOLPANEL_ID
+                        ? adaptableToolPanelDef
+                        : toolPanelDef);
+                };
+                const isSideBarDefObject = (sidebarDef) => {
+                    return Array.isArray(sidebarDef?.toolPanels);
+                };
+                let result;
+                if (original_sideBar === true) {
+                    // create all tool panels with default settings
+                    const toolPanels = [];
+                    toolPanels.push(GeneralConstants.AGGRID_TOOLPANEL_FILTERS);
+                    toolPanels.push(GeneralConstants.AGGRID_TOOLPANEL_COLUMNS);
+                    if (!isAdaptableToolPanelHidden) {
+                        toolPanels.push(adaptableToolPanelDef);
+                    }
+                    result = {
+                        toolPanels: toolPanels,
+                    };
                 }
-            }
-            // if it's an array, process the tool panel definitions
-            else if (Array.isArray(original_sideBar)) {
-                if (!original_sideBar.includes(GeneralConstants.ADAPTABLE_TOOLPANEL_ID) ||
-                    isAdaptableToolPanelHidden) {
-                    result = original_sideBar;
+                // if there is only one tool panel, and it's the adaptable one => we have to handle it
+                else if (typeof original_sideBar === 'string') {
+                    if (gridOptions.sideBar === GeneralConstants.ADAPTABLE_TOOLPANEL_ID) {
+                        if (!isAdaptableToolPanelHidden)
+                            result = {
+                                toolPanels: [adaptableToolPanelDef],
+                            };
+                    }
+                    else {
+                        result = original_sideBar;
+                    }
                 }
                 // if it's an array, process the tool panel definitions
-                const sidebarDef = {};
-                sidebarDef.toolPanels = mapToolPanelDefs(original_sideBar);
-                result = sidebarDef;
-            }
-            // if it's fully-fledged SideBarDef, process its tool panel definitions
-            else if (isSideBarDefObject(original_sideBar)) {
-                if (original_sideBar.toolPanels?.some((toolpanelDef) => typeof toolpanelDef !== 'string' &&
-                    toolpanelDef.id === GeneralConstants.ADAPTABLE_TOOLPANEL_ID &&
-                    !isAdaptableToolPanelHidden)) {
-                    // if there is an Adaptable SideBarDef, don't touch it as it may contain user-defined properties
-                    result = original_sideBar;
-                }
-                else {
-                    result = {
-                        ...original_sideBar,
-                        toolPanels: mapToolPanelDefs(original_sideBar.toolPanels),
-                    };
+                else if (Array.isArray(original_sideBar)) {
+                    if (!original_sideBar.includes(GeneralConstants.ADAPTABLE_TOOLPANEL_ID) ||
+                        isAdaptableToolPanelHidden) {
+                        result = original_sideBar;
+                    }
+                    // if it's an array, process the tool panel definitions
+                    const sidebarDef = {};
+                    sidebarDef.toolPanels = mapToolPanelDefs(original_sideBar);
+                    result = sidebarDef;
                 }
-            }
-            this.hasAdaptableToolPanel =
-                isSideBarDefObject(result) &&
-                    result.toolPanels?.some((toolPanelDef) => typeof toolPanelDef !== 'string' &&
-                        toolPanelDef.id === GeneralConstants.ADAPTABLE_TOOLPANEL_ID);
-            return result;
-        });
-        /**
-         * `statusBar`
-         */
-        this.agGridOptionsService.setGridOptionsProperty(gridOptions, 'statusBar', (original_statusBar) => {
-            const statusPanels = (original_statusBar?.statusPanels ?? [])?.map((statusPanel) => {
-                if (statusPanel.statusPanel === ADAPTABLE_STATUS_PANEL) {
-                    this.adaptableStatusPanelKeys.push(statusPanel.key);
-                    const context = {
-                        Key: statusPanel.key,
-                    };
-                    return {
-                        ...statusPanel,
-                        statusPanel: createAgStatusPanelComponent(AdaptableStatusBar, this, context),
-                    };
+                // if it's fully-fledged SideBarDef, process its tool panel definitions
+                else if (isSideBarDefObject(original_sideBar)) {
+                    if (original_sideBar.toolPanels?.some((toolpanelDef) => typeof toolpanelDef !== 'string' &&
+                        toolpanelDef.id === GeneralConstants.ADAPTABLE_TOOLPANEL_ID &&
+                        !isAdaptableToolPanelHidden)) {
+                        // if there is an Adaptable SideBarDef, don't touch it as it may contain user-defined properties
+                        result = original_sideBar;
+                    }
+                    else {
+                        result = {
+                            ...original_sideBar,
+                            toolPanels: mapToolPanelDefs(original_sideBar.toolPanels),
+                        };
+                    }
                 }
-                return statusPanel;
+                this.hasAdaptableToolPanel =
+                    isSideBarDefObject(result) &&
+                        result.toolPanels?.some((toolPanelDef) => typeof toolPanelDef !== 'string' &&
+                            toolPanelDef.id === GeneralConstants.ADAPTABLE_TOOLPANEL_ID);
+                return result;
             });
-            return { ...original_statusBar, statusPanels };
-        });
+        }
+        if (gridOptions.statusBar != undefined) {
+            /**
+             * `statusBar`
+             */
+            this.agGridOptionsService.setGridOptionsProperty(gridOptions, 'statusBar', (original_statusBar) => {
+                const statusPanels = (original_statusBar?.statusPanels ?? [])?.map((statusPanel) => {
+                    if (statusPanel.statusPanel === ADAPTABLE_STATUS_PANEL) {
+                        this.adaptableStatusPanelKeys.push(statusPanel.key);
+                        const context = {
+                            Key: statusPanel.key,
+                        };
+                        return {
+                            ...statusPanel,
+                            statusPanel: createAgStatusPanelComponent(AdaptableStatusBar, this, context),
+                        };
+                    }
+                    return statusPanel;
+                });
+                return { ...original_statusBar, statusPanels };
+            });
+        }
         /**
          * `getRowStyle`
          */
@@ -1133,7 +1130,6 @@ You need to define at least one Layout!`);
                 result = await renderAgGridFrameworkComponent(gridOptions);
             }
             catch (err) {
-                console.log('Failed to get AG Grid API');
                 result = false;
             }
             if (result === false) {
@@ -1144,7 +1140,6 @@ You need to define at least one Layout!`);
             // in that case, we have to re-populate it with the Adaptable context values
             const agGridContext = agGridApi.getGridOption('context');
             if (!agGridContext) {
-                console.log('Failed to get AG Grid context');
                 return false;
             }
             if (!agGridContext.__adaptable) {
@@ -1184,9 +1179,6 @@ You need to define at least one Layout!`);
     useRowNodeLookUp() {
         return this.agGridAdapter.getAgGridApi().getGridOption('getRowId') != undefined;
     }
-    getAgGridRegisteredModules() {
-        return this.agGridAdapter.getAgGridRegisteredModules();
-    }
     getAgGridContainerElement() {
         if (!this.DANGER_USE_GETTER_agGridContainerElement) {
             this.DANGER_USE_GETTER_agGridContainerElement =
@@ -1235,6 +1227,9 @@ You need to define at least one Layout!`);
         return selectedRowInfo;
     }
     isGridRowSelectable() {
+        if (!this.agGridModulesAdapter.isAgGridModuleRegistered('RowSelectionModule')) {
+            return false;
+        }
         const rowSelection = this.agGridAdapter.getAgGridApi().getGridOption('rowSelection');
         if (rowSelection == undefined) {
             return false;
@@ -1248,9 +1243,11 @@ You need to define at least one Layout!`);
         return false;
     }
     isGridRangeSelectable() {
-        return (this.agGridAdapter.isAgGridModuleRegistered('CellSelection') &&
-            (this.agGridAdapter.getGridOption('enableRangeSelection') ||
-                !!this.agGridAdapter.getGridOption('cellSelection')));
+        if (!this.agGridModulesAdapter.isAgGridModuleRegistered('CellSelectionModule')) {
+            return false;
+        }
+        return (this.agGridAdapter.getGridOption('enableRangeSelection') ||
+            !!this.agGridAdapter.getGridOption('cellSelection'));
     }
     initAdaptableStore() {
         const perfNewAdaptableStore = this.logger.beginPerf(`initAdaptableStore()`);
@@ -1402,8 +1399,7 @@ You need to define at least one Layout!`);
             'chartOptionsChanged',
             'chartDestroyed',
         ];
-        const chartingModule = this.ModuleService.getModuleById('Charting');
-        if (chartingModule.isModuleAvailable()) {
+        if (this.ModuleService.isAdapTableModulePresent('Charting')) {
             // We need to break the loop of charting changes for 'chartOptionsChanged', which is triggered by the subsequent agGridApi.updateChart(...)
             // see #ag_grid_update_chart_loop
             let lastChartOptionsChangePayload = '';
@@ -1451,7 +1447,7 @@ You need to define at least one Layout!`);
     shouldAutoSizeLayout() {
         const { layoutApi } = this.api;
         const currentLayout = layoutApi.getCurrentLayout();
-        if (currentLayout.ColumnWidths && Object.keys(currentLayout.ColumnWidths).length > 0) {
+        if (currentLayout.ColumnSizing && Object.keys(currentLayout.ColumnSizing).length > 0) {
             return;
         }
         return currentLayout.AutoSizeColumns;
@@ -1565,7 +1561,7 @@ You need to define at least one Layout!`);
             const adaptableStatusPanels = this.agGridAdapter
                 .getAgGridApi()
                 .getGridOption('statusBar')
-                ?.statusPanels?.filter((statusPanel) => this.adaptableStatusPanelKeys.includes(statusPanel.key));
+                ?.statusPanels?.filter((statusPanel) => this.adaptableStatusPanelKeys.includes(statusPanel.key)) ?? [];
             const statusBarModule = this.ModuleService.getModuleById(ModuleConstants.StatusBarModuleId);
             // need to add only the adaptable panels
             statusBarModule.syncStateWithOptions(adaptableStatusPanels);
@@ -1596,10 +1592,14 @@ You need to define at least one Layout!`);
             }
         }
     }
+    isInPivotMode() {
+        return (this.agGridModulesAdapter.isAgGridModuleRegistered('PivotModule') &&
+            this.agGridAdapter.getAgGridApi().isPivotMode());
+    }
     deriveAdaptableColumnStateFromAgGrid() {
         const allColumns = [];
         const gridApi = this.agGridAdapter.getAgGridApi();
-        const isPivot = gridApi.isPivotMode();
+        const isPivot = this.isInPivotMode();
         let agGridCols = isPivot
             ? gridApi.getColumns()
             : // we call getAllGridColumns because we want to also have the generated group columns
@@ -2234,9 +2234,17 @@ You need to define at least one Layout!`);
         this.autoSizeColumns([columnId]);
     }
     autoSizeColumns(columnIds) {
+        if (!this.agGridModulesAdapter.isAgGridModuleRegistered('ColumnAutoSizeModule')) {
+            this.logger.consoleError(`Could not auto-size columns [${columnIds}] - missing required AG Grid module 'ColumnAutoSizeModule'`);
+            return;
+        }
         this.layoutManager.autoSizeColumns(columnIds);
     }
     autoSizeAllColumns() {
+        if (!this.agGridModulesAdapter.isAgGridModuleRegistered('ColumnAutoSizeModule')) {
+            this.logger.consoleError(`Could not auto-size all columns - missing required AG Grid module 'ColumnAutoSizeModule'`);
+            return;
+        }
         const agGridApi = this.agGridAdapter.getAgGridApi();
         if (agGridApi) {
             agGridApi.autoSizeAllColumns();
@@ -2247,6 +2255,7 @@ You need to define at least one Layout!`);
     }
     async getDistinctFilterValuesForColumn(options) {
         const { column } = options;
+        const self = this;
         // First get the Grid Cells in the Column
         const currentGridCells = this.getDistinctGridCellsForColumn(column);
         // If there are custom distinct value, return them; otherwise return the Grids Cells just retrieved
@@ -2268,6 +2277,7 @@ You need to define at least one Layout!`);
                             value: gridCell.rawValue,
                             isSelected: gridCell.rowNode.displayed,
                             count: gridCell.count,
+                            tooltip: false,
                             get visible() {
                                 return gridCell.visible;
                             },
@@ -2285,6 +2295,27 @@ You need to define at least one Layout!`);
                             value: gridCell.rawValue,
                             isSelected: gridCell.rowNode.displayed,
                             count: gridCell.count,
+                            tooltip: false,
+                            get visible() {
+                                return gridCell.visible;
+                            },
+                            get visibleCount() {
+                                return gridCell.visibleCount;
+                            },
+                        };
+                    });
+                    return result;
+                },
+                get orderedValues() {
+                    const rowNodes = gridApiInternal.getSortedRowNodesWithCurrentLayoutSortOrder();
+                    const currentGridCells = self.getDistinctGridCellsForColumn(column, rowNodes);
+                    const result = currentGridCells.map((gridCell) => {
+                        return {
+                            label: gridCell.displayValue,
+                            value: gridCell.rawValue,
+                            isSelected: gridCell.rowNode.displayed,
+                            count: gridCell.count,
+                            tooltip: false,
                             get visible() {
                                 return gridCell.visible;
                             },
@@ -2303,12 +2334,16 @@ You need to define at least one Layout!`);
             catch (error) {
                 this.logger.consoleError(`Failed to fetch custom filter values`, column, error);
             }
-            if (customDistinctValues) {
-                return this.getGridCellsForCustomColumnValues(customDistinctValues, column);
-            }
+            return customDistinctValues ?? [];
         }
         // No distinct values so lets return unique grid cells
-        return currentGridCells;
+        return currentGridCells.map((gridCell) => {
+            const inFilterValue = {
+                value: gridCell.rawValue,
+                label: gridCell.displayValue,
+            };
+            return inFilterValue;
+        });
     }
     async getDistinctEditValuesForColumn(options) {
         const { column, gridCell } = options;
@@ -2345,42 +2380,34 @@ You need to define at least one Layout!`);
                 catch (error) {
                     this.logger.consoleError(`Failed to fetch custom edit values`, column, error);
                 }
-                if (customDistinctValues) {
-                    return this.getGridCellsForCustomColumnValues(customDistinctValues, column);
-                }
+                return customDistinctValues ?? [];
             }
         }
         // No distinct values so lets return unique grid cells
-        return currentGridCells;
+        return currentGridCells.map((gridCell) => {
+            const result = {
+                value: gridCell.rawValue,
+                label: gridCell.displayValue,
+            };
+            return result;
+        });
     }
-    getDistinctGridCellsForColumn(column) {
+    getDistinctGridCellsForColumn(column, rowNodes) {
         let gridCells = [];
         const isPivotResultColumn = column.isGeneratedPivotResultColumn;
-        this.agGridAdapter.getAgGridApi().forEachNode((rowNode) => {
+        const rowNodeCallback = (rowNode) => {
             const gridCell = this.addDistinctColumnValue(rowNode, column.columnId, isPivotResultColumn);
             if (gridCell) {
                 gridCells.push(gridCell);
             }
-        });
-        return this.getUniqueGridCells(column, gridCells);
-    }
-    getGridCellsForCustomColumnValues(customColumnValues, column) {
-        let gridCells = [];
-        if (ArrayExtensions.IsNotNullOrEmpty(customColumnValues)) {
-            gridCells = customColumnValues.map((pv) => {
-                return {
-                    rawValue: pv.value,
-                    displayValue: pv.label ?? pv.value,
-                    normalisedValue: pv.value,
-                    columnId: column.columnId,
-                    column: column,
-                    rowNode: undefined,
-                    isPivotCell: false,
-                    isRowGroupCell: false,
-                };
-            });
-            return gridCells;
+        };
+        if (rowNodes) {
+            rowNodes.forEach(rowNodeCallback);
         }
+        else {
+            this.agGridAdapter.getAgGridApi().forEachNode(rowNodeCallback);
+        }
+        return this.getUniqueGridCells(column, gridCells);
     }
     addDistinctColumnValue(rowNode, columnId, isPivotResultColumn) {
         if (!rowNode) {
@@ -2717,11 +2744,11 @@ You need to define at least one Layout!`);
         });
     }
     canGenerateCharts() {
-        return (this.agGridAdapter.isAgGridModuleRegistered('IntegratedCharts') &&
-            this.agGridAdapter.getAgGridApi().getGridOption('enableCharts'));
+        const chartingModule = this.ModuleService.getModuleById('Charting');
+        return chartingModule.isModuleEnabled() && chartingModule.isModuleAvailable();
     }
     canDisplaySparklines() {
-        return this.agGridAdapter.isAgGridModuleRegistered('Sparklines');
+        return this.agGridModulesAdapter.isAgGridModuleRegistered('SparklinesModule');
     }
     showCharts(chartsDefinitions, chartContainer) {
         return chartsDefinitions.map((chartDefinition) => this.showChart(chartDefinition, chartContainer));
@@ -2799,12 +2826,20 @@ You need to define at least one Layout!`);
         return isGroupedActive;
     }
     setAgGridQuickSearch(searchText) {
+        if (!this.agGridModulesAdapter.isAgGridModuleRegistered('QuickFilterModule')) {
+            this.logger.consoleError(`Can NOT set Quick Search text - missing required AG Grid module 'QuickFilterModule'`);
+            return;
+        }
         this.agGridAdapter.setGridOption('quickFilterText', searchText);
     }
     clearAgGridQuickSearch() {
         this.setAgGridQuickSearch('');
     }
     setAgGridFindSearchValue(searchText) {
+        if (!this.agGridModulesAdapter.isAgGridModuleRegistered('FindModule')) {
+            this.logger.consoleError(`Can NOT set Find Search text - missing required AG Grid module 'FindModule'`);
+            return;
+        }
         this.agGridAdapter.setGridOption('findSearchValue', searchText);
     }
     applyAdaptableTheme(theme) {
@@ -3010,6 +3045,7 @@ You need to define at least one Layout!`);
                     'sideBar',
                     'statusBar',
                     'suppressAggFuncInHeader',
+                    'defaultColDef',
                 ]);
                 if (liveGridOptions.components) {
                     liveGridOptions.components.AdaptableToolPanel = null;
@@ -3041,6 +3077,8 @@ You need to define at least one Layout!`);
         this.agGridExportAdapter = null;
         this.agGridThemeAdapter?.destroy();
         this.agGridThemeAdapter = null;
+        this.agGridModulesAdapter?.destroy();
+        this.agGridModulesAdapter = null;
         this.rowListeners = null;
         this.emitter.destroy();
         this.emitter = null;
@@ -3102,10 +3140,10 @@ You need to define at least one Layout!`);
         this.unmountLoadingScreen = null;
     }
     canExportToExcel() {
-        return this.agGridAdapter.isAgGridModuleRegistered('ExcelExport');
+        return this.agGridModulesAdapter.isAgGridModuleRegistered('ExcelExportModule');
     }
     canExportToCsv() {
-        return this.agGridAdapter.isAgGridModuleRegistered('CsvExport');
+        return this.agGridModulesAdapter.isAgGridModuleRegistered('CsvExportModule');
     }
     isQuickFilterAvailable() {
         if (this.api.layoutApi.isCurrentLayoutPivot() &&