@adaptabletools/adaptable 20.1.9 → 20.2.0-canary.1

package/src/agGrid/AdaptableAgGrid.js

@@ -403,7 +403,8 @@ export class AdaptableAgGrid {
         perfInitAgGrid.end();
         // we need to intercept several AG Grid Api methods and trigger Adaptable state changes
         this.agGridAdapter.setAgGridApi(agGridApi);
-        this.agGridAdapter.monkeyPatchingGridOptionsUpdates(agGridApi);
+        this.agGridAdapter.monkeyPatchingGridOptionsUpdates();
+        this.agGridAdapter.monkeyPatchingAggColumnFilters();
         this.lifecycleState = 'agGridReady';
         this.logger.info(`Registered AG Grid modules: `, this.agGridAdapter.getAgGridRegisteredModuleNames().sort());
         /**
@@ -418,12 +419,22 @@ export class AdaptableAgGrid {
         // TODO AFL MIG: we could just patch the defautl Layout on init? instead
         this.checkShouldClearExistingFiltersOrSearches();
         this.applyFiltering();
+        // apply quick search if there is one
+        // yes, we could have put this on the gridOptions.findSearchValue
+        // but we need to wait for setupColumns to run first so as to correctly
+        // determine on which columns the quick search should be applied or not
+        // and also to setup the quick search style
+        const quickSearchState = this.api.stateApi.getQuickSearchState();
+        if (quickSearchState.QuickSearchText) {
+            this.setAgGridFindSearchValue(quickSearchState.QuickSearchText);
+        }
         this.addGridEventListeners();
         this.temporaryAdaptableStateUpdates();
         this.redrawBody();
         this.refreshHeader();
         const currentLayout = this.api.layoutApi.getCurrentLayout();
         checkForDuplicateColumns(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
@@ -437,7 +448,9 @@ export class AdaptableAgGrid {
             // see test /tests/pages/quick-search/pivot-search.spec.ts
             this.updateColumnModelAndRefreshGrid();
         }
-        this.layoutManager.applyRowGroupValues(layoutStateToLayoutModel(currentLayout).RowGroupValues);
+        const layoutModelForApply = layoutStateToLayoutModel(currentLayout);
+        this.layoutManager.applyRowGroupValues(layoutModelForApply.RowGroupValues);
+        this.layoutManager.applyColumnGroupCollapseExpandState(layoutModelForApply);
         this.autoSizeLayoutIfNeeded();
         this.ModuleService.createModuleUIItems();
         const adaptableContainerElem = this.getAdaptableContainerElement();
@@ -761,10 +774,14 @@ You need to define at least one Layout!`);
                 if (!this.isAvailable) {
                     return true;
                 }
-                const isColumnFiltersActive = ArrayExtensions.IsNotNullOrEmpty(this.api.filterApi.columnFilterApi.getActiveColumnFilters());
                 const isGridFilterActive = StringExtensions.IsNotNullOrEmpty(this.api.filterApi.gridFilterApi.getCurrentGridFilterExpression());
-                return (isColumnFiltersActive ||
-                    isGridFilterActive ||
+                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));
             };
@@ -777,10 +794,20 @@ You need to define at least one Layout!`);
                 if (!this.isAvailable) {
                     return true;
                 }
-                // Note: not sure we need this check as doubtful AG Grid ever passes in a Group Row node to filter...
-                // But if it does, then we might change this IF we allow Column filtering (but not Grid Filters) for Group nodes
                 if (this.isGroupRowNode(node)) {
-                    return true;
+                    if (this.api.gridApi.isTreeDataGrid()) {
+                        if (node.data == undefined) {
+                            // Filler Groups are not filterable
+                            // see https://www.ag-grid.com/javascript-data-grid/tree-data-paths/#filler-groups
+                            return false;
+                        }
+                    }
+                    else {
+                        // for non-Tree Data Grids, we don't filter Group Rows
+                        // not sure if that's 100% correct, but we did it like this in the past
+                        // so we keep it like this for now until bugs are reported
+                        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;
@@ -816,11 +843,15 @@ You need to define at least one Layout!`);
                     }
                 }
                 // finally we evaluate column filters
-                const columnFilters = this.api.filterApi.columnFilterApi.getActiveColumnFilters();
+                const tableColumnFilters = this.api.filterApi.columnFilterApi
+                    .getActiveColumnFilters()
+                    .filter((columnFilter) => !this.api.columnApi.isPivotResultColumn(columnFilter.ColumnId));
                 try {
-                    if (columnFilters.length > 0) {
-                        for (const columnFilter of columnFilters) {
-                            const evaluateColumnFilterOnClient = this.api.expressionApi.internalApi.evaluatePredicatesInAdaptableQL('ColumnFilter', columnFilter, columnFilter.Predicates);
+                    // 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) {
@@ -1043,18 +1074,6 @@ You need to define at least one Layout!`);
             // this array reference will be used for the entire AG Grid session
             return this.agGridExportAdapter.DANGER_excelStyles;
         });
-        /**
-         * `processPivotResultColDef`
-         */
-        this.agGridOptionsService.setGridOptionsProperty(gridOptions, 'processPivotResultColDef', (original_processPivotResultColDef) => {
-            return (colDef) => {
-                if (this.adaptableOptions.filterOptions.useAdaptableFiltering) {
-                    colDef.floatingFilter = false;
-                    colDef.filter = false;
-                }
-                original_processPivotResultColDef?.(colDef);
-            };
-        });
         /**
          * `maintainColumnOrder`
          */
@@ -1095,6 +1114,12 @@ You need to define at least one Layout!`);
             const revertedDateTypeDefinitions = agGridDataTypeDefinitions;
             return revertedDateTypeDefinitions;
         });
+        this.agGridOptionsService.setGridOptionsProperty(gridOptions, 'findOptions', (original_findOptions) => {
+            return {
+                ...original_findOptions,
+                caseSensitive: !!this.adaptableOptions.quickSearchOptions.isQuickSearchCaseSensitive,
+            };
+        });
     }
     /**
      * Either initializes the AG Grid instance or delegates it to the framework wrappers (React/Anglar)
@@ -1296,6 +1321,17 @@ You need to define at least one Layout!`);
             }
             this.autoSizeLayoutIfNeeded();
         }));
+        /**
+         * Use Case: A format column that has ColumnGroupState needs to be re-evaluated
+         * whenever a column group is expanded or collapsed
+         */
+        this.agGridAdapter.getAgGridApi().addEventListener('columnGroupOpened', (this.listenerColumnGroupOpened = () => {
+            if (this.api.formatColumnApi.getActiveFormatColumns().some((fc) => {
+                return fc.ColumnGroupState != null;
+            })) {
+                this.updateColumnModelAndRefreshGrid();
+            }
+        }));
         /**
          * Use Case: A pivot column has changed
          * Action: Autosize pivot columns (if autosize pivot in Layout is true)
@@ -1631,13 +1667,18 @@ You need to define at least one Layout!`);
         let _rawValue;
         let _displayValue;
         let _normalisedValue;
-        let _isPivotCell;
         let _isRowGroupCell;
+        const _isPivotCell = this.api.columnApi.isPivotResultColumn(columnId);
         const self = this;
         const api = this.api;
         const getRawValue = () => {
             if (_rawValue === undefined) {
                 _rawValue = self.getRawValueFromRowNode(rowNode, columnId);
+                if (_isPivotCell && _rawValue?.value != undefined) {
+                    // for pivot result columns, the raw value is an object with a value property
+                    // we want to return the value property as the raw value
+                    _rawValue = _rawValue.value;
+                }
             }
             return _rawValue;
         };
@@ -1676,9 +1717,6 @@ You need to define at least one Layout!`);
                 return _primaryKeyValue;
             },
             get isPivotCell() {
-                if (_isPivotCell === undefined) {
-                    _isPivotCell = api.columnApi.isPivotResultColumn(columnId);
-                }
                 return _isPivotCell;
             },
             get isRowGroupCell() {
@@ -1747,6 +1785,26 @@ You need to define at least one Layout!`);
                 return formattedValue || '';
             }
         }
+        else if (this.api.columnApi.isPivotResultColumn(columnId)) {
+            const pivotResultColumn = this.agGridAdapter
+                .getAgGridApi()
+                .getPivotResultColumns()
+                .find((col) => col.getColId() === columnId);
+            const pivotResultColDef = pivotResultColumn?.getColDef();
+            if (pivotResultColDef && typeof pivotResultColDef.valueFormatter === 'function') {
+                const params = {
+                    value: rawValue,
+                    node: rowNode,
+                    data: rowNode.data,
+                    colDef: pivotResultColDef,
+                    column: pivotResultColumn,
+                    api: this.agGridAdapter.getAgGridApi(),
+                    context: this.agGridAdapter.getGridOption('context'),
+                };
+                const formattedValue = pivotResultColDef.valueFormatter(params);
+                return formattedValue || '';
+            }
+        }
         return this.getCleanValue(rawValue);
     }
     getCleanValue(value) {
@@ -2190,6 +2248,9 @@ You need to define at least one Layout!`);
                             get visible() {
                                 return gridCell.visible;
                             },
+                            get visibleCount() {
+                                return gridCell.visibleCount;
+                            },
                         };
                     });
                     return result;
@@ -2204,6 +2265,9 @@ You need to define at least one Layout!`);
                             get visible() {
                                 return gridCell.visible;
                             },
+                            get visibleCount() {
+                                return gridCell.visibleCount;
+                            },
                         };
                     });
                     return result;
@@ -2268,8 +2332,9 @@ You need to define at least one Layout!`);
     }
     getDistinctGridCellsForColumn(column) {
         let gridCells = [];
+        const isPivotResultColumn = column.isGeneratedPivotResultColumn;
         this.agGridAdapter.getAgGridApi().forEachNode((rowNode) => {
-            const gridCell = this.addDistinctColumnValue(rowNode, column.columnId);
+            const gridCell = this.addDistinctColumnValue(rowNode, column.columnId, isPivotResultColumn);
             if (gridCell) {
                 gridCells.push(gridCell);
             }
@@ -2294,17 +2359,36 @@ You need to define at least one Layout!`);
             return gridCells;
         }
     }
-    addDistinctColumnValue(rowNode, columnId) {
-        // we do not return the values of the aggregates when in grouping mode
-        // otherwise they would appear in the filter dropdown etc....
-        if (rowNode && !this.isGroupRowNode(rowNode)) {
-            const returnValue = this.getGridCellFromRowNode(rowNode, columnId);
-            if (Helper.objectExists(returnValue)) {
-                return returnValue;
+    addDistinctColumnValue(rowNode, columnId, isPivotResultColumn) {
+        if (!rowNode) {
+            return;
+        }
+        if (!isPivotResultColumn && this.isGroupRowNode(rowNode)) {
+            if (this.api.gridApi.isTreeDataGrid()) {
+                if (rowNode.data == undefined) {
+                    // skip Tree Filler Groups
+                    // see https://www.ag-grid.com/javascript-data-grid/tree-data-paths/#filler-groups
+                    return;
+                }
+            }
+            else {
+                // for normal Table Columns we do NOT return the values of the aggregates
+                return;
             }
         }
-        else {
-            return undefined;
+        if (isPivotResultColumn) {
+            // if it's a Pivot Result Column, we are interested only in the aggregated(pivoted) data
+            if (!rowNode.aggData) {
+                return;
+            }
+            if (!rowNode.leafGroup) {
+                // if it's a Pivot Result Column, we are interested only in the leaf groups (pivot results, NOT group aggregates)
+                return;
+            }
+        }
+        const returnValue = this.getGridCellFromRowNode(rowNode, columnId);
+        if (Helper.objectExists(returnValue)) {
+            return returnValue;
         }
     }
     getUniqueGridCells(column, gridCells) {
@@ -2352,6 +2436,11 @@ You need to define at least one Layout!`);
                     return (rowNodesWithSameCellValue.findIndex((pk) => self.isRowNodeAvailableAfterFiltering(pk) === true) !== -1);
                 },
             });
+            Object.defineProperty(cellWithCount, 'visibleCount', {
+                get: () => {
+                    return rowNodesWithSameCellValue.filter((pk) => self.isRowNodeAvailableAfterFiltering(pk) === true).length;
+                },
+            });
             result.push(cellWithCount);
         });
         return result;
@@ -2667,6 +2756,9 @@ You need to define at least one Layout!`);
     clearAgGridQuickSearch() {
         this.setAgGridQuickSearch('');
     }
+    setAgGridFindSearchValue(searchText) {
+        this.agGridAdapter.setGridOption('findSearchValue', searchText);
+    }
     applyAdaptableTheme(theme) {
         const container = this.getAgGridContainerElement();
         if (container != null) {
@@ -2835,10 +2927,12 @@ You need to define at least one Layout!`);
             agGridApi.removeEventListener('columnPivotChanged', this.listenerPivotChanged);
             agGridApi.removeEventListener('cellEditingStarted', this.listenerCellEditingStarted);
             agGridApi.removeEventListener('cellSelectionChanged', this.listenerCellSelectionChanged);
+            agGridApi.removeEventListener('columnGroupOpened', this.listenerColumnGroupOpened);
             agGridApi.removeEventListener('sortChanged', this.listenerSortChanged);
             agGridApi.removeGlobalListener(this.listenerGlobalSetRowSelection);
             this.listenerFirstDataRendered = null;
             this.listenerPivotChanged = null;
+            this.listenerColumnGroupOpened = null;
             this.listenerCellEditingStarted = null;
             this.listenerCellSelectionChanged = null;
             this.listenerGlobalSetRowSelection = null;

package/src/agGrid/AgGridAdapter.d.ts

@@ -9,6 +9,8 @@ export declare class AgGridAdapter {
     private DANGER_USE_GETTER_gridApi;
     private DANGER_gridApi_from_args;
     private DANGER_updateGridOptionsMonkeyPatcher;
+    private DANGER_doAggregateFiltersPassMonkeyPatcher;
+    private DANGER_isAggregateFilterPresentMonkeyPatcher;
     initialGridOptions: GridOptions;
     private _agGridId;
     constructor(_adaptableInstance: AdaptableAgGrid, config?: {
@@ -22,7 +24,8 @@ export declare class AgGridAdapter {
     setAgGridId(agGridId: string): void;
     setAgGridApi(gridApi: GridApi): void;
     getAgGridApi(skipLogging?: boolean): GridApi | undefined;
-    monkeyPatchingGridOptionsUpdates(agGridApi: GridApi<any>): void;
+    monkeyPatchingGridOptionsUpdates(): void;
+    monkeyPatchingAggColumnFilters(): void;
     private DANGER_getPrivateAgGridBeans;
     DANGER_getLiveGridOptions(): GridOptions<any>;
     isAgGridModuleRegistered(moduleName: ModuleName): boolean;

package/src/agGrid/AgGridAdapter.js

@@ -1,6 +1,6 @@
 import { ColumnApiModule, } from 'ag-grid-enterprise';
 import { ACTION_COLUMN_TYPE, CALCULATED_COLUMN_TYPE, FDC3_COLUMN_TYPE, FREE_TEXT_COLUMN_TYPE, } from '../AdaptableState/Common/AdaptableColumn';
-import { ADAPTABLE_FDC3_ACTION_COLUMN_FRIENDLY_NAME, AG_GRID_GROUPED_COLUMN, AG_GRID_SELECTION_COLUMN, } from '../Utilities/Constants/GeneralConstants';
+import { ADAPTABLE_FDC3_ACTION_COLUMN_FRIENDLY_NAME } from '../Utilities/Constants/GeneralConstants';
 import { createUuid } from '../AdaptableState/Uuid';
 import ArrayExtensions from '../Utilities/Extensions/ArrayExtensions';
 import * as ModuleConstants from '../Utilities/Constants/ModuleConstants';
@@ -16,6 +16,8 @@ export class AgGridAdapter {
     constructor(_adaptableInstance, config) {
         this._adaptableInstance = _adaptableInstance;
         const columnApiModuleReference = config?.getAgGridColumnApiModuleReference?.() ?? getColumnApiModule();
+        const beans = columnApiModuleReference?.beans;
+        console.log(beans?.length);
         const ColumnDefFactory_Prototype = columnApiModuleReference?.beans?.[0]?.prototype;
         if (!ColumnDefFactory_Prototype) {
             console.error(`CRITICAL: could not get hold of AG Grid beans, this should never happen!`);
@@ -38,6 +40,8 @@ export class AgGridAdapter {
         this.DANGER_gridApi_from_args = null;
         this.DANGER_USE_GETTER_gridApi = null;
         this.DANGER_updateGridOptionsMonkeyPatcher = null;
+        this.DANGER_doAggregateFiltersPassMonkeyPatcher = null;
+        this.DANGER_isAggregateFilterPresentMonkeyPatcher = null;
         this._adaptableInstance = null;
     }
     get adaptableOptions() {
@@ -71,7 +75,7 @@ export class AgGridAdapter {
     }
     // #gridOpts_monkey_patch
     // we need to intercept some of the GridOptions updates and refresh the Adaptable state
-    monkeyPatchingGridOptionsUpdates(agGridApi) {
+    monkeyPatchingGridOptionsUpdates() {
         const agGridOptionsService = this.DANGER_getPrivateAgGridBeans()?.gos;
         if (!agGridOptionsService) {
             return;
@@ -107,6 +111,57 @@ export class AgGridAdapter {
         };
         agGridOptionsService.updateGridOptions = this.DANGER_updateGridOptionsMonkeyPatcher;
     }
+    monkeyPatchingAggColumnFilters() {
+        if (!this.adaptableApi.optionsApi.getFilterOptions().useAdaptableFiltering) {
+            // monkey patching is only needed if Adaptable is used for filtering
+            return;
+        }
+        const agGridColumnFilterService = this.DANGER_getPrivateAgGridBeans()?.colFilter;
+        if (!agGridColumnFilterService) {
+            this.logger.consoleError('Could not get hold of ColumnFilterService! This is a critical error and will prevent Adaptable from working correctly.');
+            return;
+        }
+        const self = this;
+        // https://github.com/ag-grid/ag-grid/blob/8409e99c8010473356a878e9bdfb836a5ea16718/packages/ag-grid-community/src/filter/columnFilterService.ts#L240
+        // monkey patch ColumnFilterService.doAggregateFiltersPass because currently Adaptable does NOT override the ColumnFilters
+        // (it uses the `doesExternalFilterPass` to evaluate the filters on the client side)
+        // #doAggregateFiltersPassMonkeyPatcher
+        this.DANGER_doAggregateFiltersPassMonkeyPatcher = function (rowNode, filterToSkip) {
+            if (!self.adaptableApi.layoutApi.isCurrentLayoutPivot()) {
+                // should NEVER happen
+                return true;
+            }
+            const pivotColumnFilters = self.adaptableApi.filterApi.columnFilterApi
+                .getActiveColumnFilters()
+                .filter((columnFilter) => self.adaptableApi.columnApi.isPivotResultColumn(columnFilter.ColumnId));
+            try {
+                if (pivotColumnFilters.length > 0) {
+                    for (const columnFilter of pivotColumnFilters) {
+                        const evaluateColumnFilterOnClient = self.adaptableApi.expressionApi.internalApi.shouldEvaluatePredicatesInAdaptableQL('ColumnFilter', columnFilter, columnFilter.Predicates);
+                        if (evaluateColumnFilterOnClient) {
+                            const columnFilterEvaluationResult = self.adaptableApi.filterApi.columnFilterApi.internalApi.evaluateColumnFilter(columnFilter, rowNode);
+                            if (!columnFilterEvaluationResult) {
+                                return false;
+                            }
+                        }
+                    }
+                }
+            }
+            catch (ex) {
+                self.logger.error(ex);
+                return true;
+            }
+            return true;
+        };
+        agGridColumnFilterService.doAggregateFiltersPass =
+            this.DANGER_doAggregateFiltersPassMonkeyPatcher;
+        this.DANGER_isAggregateFilterPresentMonkeyPatcher = function () {
+            const columnFilters = self.adaptableApi.filterApi.columnFilterApi.getActiveColumnFilters();
+            return columnFilters.some((colFilter) => self.adaptableApi.columnApi.isPivotResultColumn(colFilter.ColumnId));
+        };
+        agGridColumnFilterService.isAggregateFilterPresent =
+            this.DANGER_isAggregateFilterPresentMonkeyPatcher;
+    }
     DANGER_getPrivateAgGridBeans() {
         const beans = DANGER_AG_GRID_BEANS_MAP[this._agGridId];
         if (!beans) {
@@ -159,12 +214,21 @@ export class AgGridAdapter {
         }
     }
     updateGridOptions(options) {
+        if (this.getAgGridApi()?.isDestroyed()) {
+            return;
+        }
         this.getAgGridApi()?.updateGridOptions(options);
     }
     getGridOption(key) {
+        if (this.getAgGridApi()?.isDestroyed()) {
+            return;
+        }
         return this.getAgGridApi()?.getGridOption(key);
     }
     setGridOption(key, value) {
+        if (this.getAgGridApi()?.isDestroyed()) {
+            return;
+        }
         this.getAgGridApi()?.setGridOption(key, value);
     }
     getUserGridOptionsProperty(propertyName) {
@@ -453,10 +517,21 @@ export class AgGridAdapter {
             this.logger.warn(`Column is undefined, returning 'text' for Type`);
             return 'text';
         }
-        if (agColumn.getId() === AG_GRID_GROUPED_COLUMN ||
-            agColumn.getId() === AG_GRID_SELECTION_COLUMN) {
+        if (this.adaptableApi.columnApi.isAutoRowGroupColumnForSingle(agColumn.getId()) ||
+            this.adaptableApi.columnApi.isSelectionColumn(agColumn.getId())) {
             return 'unknown';
         }
+        if (this.adaptableApi.columnApi.isAutoRowGroupColumnForMulti(agColumn.getId())) {
+            const rowGroupKey = agColumn.getColDef().showRowGroup;
+            if (typeof rowGroupKey !== 'string') {
+                return 'unknown';
+            }
+            const groupedColumn = this.adaptableApi.agGridApi.getColumn(rowGroupKey);
+            if (!groupedColumn) {
+                return 'unknown';
+            }
+            return this.deriveAdaptableColumnDataType(groupedColumn, logWarning);
+        }
         const colDefType = [].concat(agColumn.getColDef()?.type || []).filter(Boolean);
         const skippedSpecialCols = ['actionColumn', 'fdc3Column'];
         if (skippedSpecialCols.some((specialColType) => colDefType.includes(specialColType))) {
@@ -483,15 +558,17 @@ export class AgGridAdapter {
             this.logger.consoleError(`No data in grid, returning type "unknown" for Column: "${agColumn.getColId()}". This will impact several Adaptable features, such as Filters and ColumnFormats.`);
             return 'unknown';
         }
-        // if it's a group we need the content of the group
-        if (row.group) {
-            const childNodes = row.childrenAfterGroup;
-            if (ArrayExtensions.IsNullOrEmpty(childNodes)) {
-                this.logger.consoleError(`No data in grid, returning type "unknown" for Column: "${agColumn.getColId()}". This will impact several Adaptable features, such as Filters and ColumnFormats.`);
-                return 'unknown';
-            }
-            row = childNodes[0];
-        }
+        // // if it's a group we need the content of the group
+        // if (row.group) {
+        //   const childNodes = row.childrenAfterGroup;
+        //   if (ArrayExtensions.IsNullOrEmpty(childNodes)) {
+        //     this.logger.consoleError(
+        //       `No data in grid, returning type "unknown" for Column: "${agColumn.getColId()}". This will impact several Adaptable features, such as Filters and ColumnFormats.`
+        //     );
+        //     return 'unknown';
+        //   }
+        //   row = childNodes[0];
+        // }
         const value = this._agGridApi_getValue(agColumn, row);
         switch (typeof value) {
             case 'string':

package/src/agGrid/AgGridColumnAdapter.d.ts

@@ -35,6 +35,8 @@ export declare class AgGridColumnAdapter {
     private setupColumnEditable;
     private setupColumnValueSetter;
     private setupColumnComparator;
+    private setupColumnGetFindText;
+    private isCellSearchable;
     private isQuickSearchActive;
     private getEditableCellClass;
     private getReadonlyCellClass;
@@ -45,6 +47,8 @@ export declare class AgGridColumnAdapter {
     private getCommentCellClassName;
     private getFormatColumnCellClass;
     private getQuickSearchCellStyle;
+    private getQuickSearchTextMatchStyle;
+    private getQuickSearchCurrentTextMatchStyle;
     private getReadOnlyCellStyle;
     private getEditableCellStyle;
     private getEditedCellStyle;