@adaptabletools/adaptable 19.2.4 → 20.0.0-canary.0

package/src/agGrid/AgGridAdapter.js

@@ -1,23 +1,53 @@
-import { ModuleRegistry, } from '@ag-grid-community/core';
-import { ADAPTABLE_FDC3_ACTION_COLUMN_FRIENDLY_NAME, ADAPTABLE_ROW_ACTION_BUTTONS, ADAPTABLE_ROW_ACTION_BUTTONS_FRIENDLY_NAME, } from '../Utilities/Constants/GeneralConstants';
+import { ColumnApiModule, } from 'ag-grid-enterprise';
+import { ACTION_COLUMN_TYPE, CALCULATED_COLUMN_TYPE, FDC3_COLUMN_TYPE, FREE_TEXT_COLUMN_TYPE, } from '../PredefinedConfig/Common/AdaptableColumn';
+import { ADAPTABLE_FDC3_ACTION_COLUMN_FRIENDLY_NAME } from '../Utilities/Constants/GeneralConstants';
 import { createUuid } from '../PredefinedConfig/Uuid';
 import ArrayExtensions from '../Utilities/Extensions/ArrayExtensions';
 import * as ModuleConstants from '../Utilities/Constants/ModuleConstants';
+import { ALL_AG_GRID_MODULES } from './agGridModules';
+import { agGridDataTypeDefinitions, ALL_ADAPTABLE_DATA_TYPES, } from './agGridDataTypeDefinitions';
+// AG GRID obfuscates its internals, this is (currently) the best way to get hold of its internal services
+const DANGER_AG_GRID_BEANS_MAP = {};
+const getColumnApiModule = () => ColumnApiModule;
 export class AgGridAdapter {
-    constructor(adaptableInstance) {
-        this.adaptableInstance = adaptableInstance;
+    constructor(_adaptableInstance, config) {
+        this._adaptableInstance = _adaptableInstance;
+        const columnApiModuleReference = config?.getAgGridColumnApiModuleReference?.() ?? getColumnApiModule();
+        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!`);
+        }
+        else {
+            const ColumnDefFactory_Prototye_preWireBeans = ColumnDefFactory_Prototype.preWireBeans;
+            ColumnDefFactory_Prototype.preWireBeans = function (beans) {
+                ColumnDefFactory_Prototye_preWireBeans?.apply(this, arguments);
+                const gridId = beans?.context?.getGridId();
+                if (!gridId) {
+                    console.error('CRITICAL: No gridId found in beans, this should never happen!');
+                }
+                DANGER_AG_GRID_BEANS_MAP[gridId] = beans;
+            };
+        }
+    }
+    destroy() {
+        delete DANGER_AG_GRID_BEANS_MAP[this._agGridId];
+        this.DANGER_updateGridOptionsMonkeyPatcher = null;
+        this._adaptableInstance = null;
     }
     get adaptableOptions() {
-        return this.adaptableInstance.adaptableOptions;
+        return this._adaptableInstance.adaptableOptions;
     }
     get adaptableApi() {
-        return this.adaptableInstance.api;
+        return this._adaptableInstance.api;
     }
     get logger() {
-        return this.adaptableInstance.logger;
+        return this._adaptableInstance.logger;
     }
-    destroy() {
-        this.adaptableInstance = null;
+    get agGridOptionsService() {
+        return this._adaptableInstance.agGridOptionsService;
+    }
+    setAgGridId(agGridId) {
+        this._agGridId = agGridId;
     }
     setAgGridApi(gridApi) {
         this.DANGER_USE_GETTER_gridApi = gridApi;
@@ -33,13 +63,84 @@ export class AgGridAdapter {
             console.error('AgGridApi is not available yet');
         }
     }
+    // #gridOpts_monkey_patch
+    // we need to intercept some of the GridOptions updates and refresh the Adaptable state
+    monkeyPatchingGridOptionsUpdates(agGridApi) {
+        const agGridOptionsService = this.DANGER_getPrivateAgGridBeans()?.gos;
+        if (!agGridOptionsService) {
+            return;
+        }
+        const agGridOptionsServicePrototype = Object.getPrototypeOf(agGridOptionsService);
+        const GridOptionsService_updateGridOptions = agGridOptionsServicePrototype.updateGridOptions;
+        const self = this;
+        this.DANGER_updateGridOptionsMonkeyPatcher = function ({ options, force, source = 'api', }) {
+            const passedColumnDefs = options.columnDefs;
+            if (passedColumnDefs) {
+                const colDefsWithSpecialColumns = self.getColumnDefinitionsInclSpecialColumns(passedColumnDefs);
+                const allDisplayedColIds = self
+                    .getAgGridApi()
+                    .getAllDisplayedColumns()
+                    .map((col) => col.getColId());
+                // mark as hidden the colDefs of special columns which are not visible
+                self.patchColDefs(colDefsWithSpecialColumns, (colDef) => {
+                    if (self.adaptableApi.columnApi.internalApi.isSpecialColumn(colDef.colId)) {
+                        colDef.hide = !allDisplayedColIds.includes(colDef.colId);
+                    }
+                });
+                options['columnDefs'] = colDefsWithSpecialColumns;
+                self.logger.info(`Added SpecialColumns on GridOptions.columnDefs update (source=${source})`);
+            }
+            // `context`
+            const passedContext = options.context;
+            if (passedContext) {
+                passedContext['__adaptable'] = self;
+                passedContext['adaptableApi'] = self.adaptableApi;
+            }
+            // we mutated the options array, so it's OK to use the 'arguments' object
+            GridOptionsService_updateGridOptions.apply(this, arguments);
+        };
+        agGridOptionsService.updateGridOptions = this.DANGER_updateGridOptionsMonkeyPatcher;
+    }
+    DANGER_getPrivateAgGridBeans() {
+        const beans = DANGER_AG_GRID_BEANS_MAP[this._agGridId];
+        if (!beans) {
+            this.logger.consoleError('Could not get hold of AgGridBeans! This is a critical error and will prevent Adaptable from working correctly.');
+        }
+        return beans;
+    }
+    DANGER_getLiveGridOptions() {
+        return this.DANGER_getPrivateAgGridBeans()?.gridOptions;
+    }
+    isAgGridModuleRegistered(moduleName) {
+        const agGridOptionsService = this.DANGER_getPrivateAgGridBeans()?.gos;
+        if (!agGridOptionsService) {
+            this.logger.consoleError('Could not get hold of GridOptionsService! This is a critical error and will prevent Adaptable from working correctly.');
+            return false;
+        }
+        return agGridOptionsService.isModuleRegistered(moduleName);
+    }
+    getAgGridRegisteredModules() {
+        const allModulesSet = ALL_AG_GRID_MODULES;
+        const registeredModules = [];
+        allModulesSet.forEach((module) => {
+            if (this.isAgGridModuleRegistered(module.moduleName)) {
+                registeredModules.push(module);
+            }
+        });
+        return registeredModules;
+    }
+    getAgGridRegisteredModuleNames() {
+        return this.getAgGridRegisteredModules().map((module) => module.moduleName);
+    }
+    getAgGridRootElement() {
+        return this.DANGER_getPrivateAgGridBeans()?.eGridDiv;
+    }
     /**
      * When AG Grid is rendered the first time, the AG GridApi is not yet set in the Adaptable context (as it's set only AFTER the grid is fully initialised)
      * yet we need it when evaluating custom GridOptions properties on the first render.
      * to handle this edge case, we try to extract the AG GridApi from the invocation arguments
      */
     grabAgGridApiOnTheFly(args) {
-        var _a;
         if (this.DANGER_USE_GETTER_gridApi || this.DANGER_gridApi_from_args) {
             return;
         }
@@ -47,29 +148,25 @@ export class AgGridAdapter {
             args[0] &&
             typeof args[0].api === 'object' &&
             // can't ise instanceof operator because gridApi is exported as interface
-            typeof ((_a = args[0].api) === null || _a === void 0 ? void 0 : _a.getGridId) === 'function') {
+            typeof args[0].api?.getGridId === 'function') {
             this.DANGER_gridApi_from_args = args[0].api;
         }
     }
     updateGridOptions(options) {
-        var _a;
-        (_a = this.getAgGridApi()) === null || _a === void 0 ? void 0 : _a.updateGridOptions(options);
+        this.getAgGridApi()?.updateGridOptions(options);
     }
     getGridOption(key) {
-        var _a;
-        return (_a = this.getAgGridApi()) === null || _a === void 0 ? void 0 : _a.getGridOption(key);
+        return this.getAgGridApi()?.getGridOption(key);
     }
     setGridOption(key, value) {
-        var _a;
-        (_a = this.getAgGridApi()) === null || _a === void 0 ? void 0 : _a.setGridOption(key, value);
+        this.getAgGridApi()?.setGridOption(key, value);
     }
     getUserGridOptionsProperty(propertyName) {
-        return this.adaptableInstance.agGridOptionsService.getUserGridOptionsProperty(propertyName);
+        return this.agGridOptionsService.getUserGridOptionsProperty(propertyName);
     }
     updateColumnFilterActiveState() {
-        var _a;
-        const columnFilters = this.adaptableApi.columnFilterApi.getActiveColumnFilters();
-        const activeFilters = (_a = columnFilters === null || columnFilters === void 0 ? void 0 : columnFilters.filter) === null || _a === void 0 ? void 0 : _a.call(columnFilters, (columnFilter) => this.adaptableApi.columnFilterApi.isColumnFilterActive(columnFilter));
+        const columnFilters = this.adaptableApi.filterApi.columnFilterApi.getActiveColumnFilters();
+        const activeFilters = columnFilters?.filter?.((columnFilter) => this.adaptableApi.filterApi.columnFilterApi.isColumnFilterActive(columnFilter));
         const isFilterActive = ArrayExtensions.IsNotNullOrEmpty(activeFilters);
         const columnsWithActiveFilters = {};
         if (isFilterActive) {
@@ -80,8 +177,8 @@ export class AgGridAdapter {
                 if (agGridCol) {
                     columnsWithActiveFilters[agGridCol.getColId()] = true;
                     if (!agGridCol.isFilterActive()) {
-                        // TODO AFL MIG: added source, not sure it's OK
-                        agGridCol.setFilterActive(true, 'filterChanged');
+                        // FIXME AFL: changed from fn call; is this enough?
+                        agGridCol.filterActive = true;
                     }
                 }
             }
@@ -97,31 +194,108 @@ export class AgGridAdapter {
             if (!isColumnInFilterModel &&
                 !columnsWithActiveFilters[col.getColId()] &&
                 col.isFilterActive()) {
-                // TODO AFL MIG: added source, not sure it's OK
-                col.setFilterActive(false, 'filterChanged');
+                // FIXME AFL: changed from fn call; is this enough?
+                col.filterActive = false;
+            }
+        });
+    }
+    getColumnDefinitionsInclSpecialColumns(agGridColDefs) {
+        const allColDefs = this.enhanceColDefsWithSpecialColumns(agGridColDefs ?? this.getAgGridApi().getColumnDefs());
+        return allColDefs;
+    }
+    enhanceColDefsWithSpecialColumns(agGridColDefs) {
+        this.assignColumnIdsToColDefs(agGridColDefs);
+        const specialColDefs = this.getSpecialColDefs();
+        const isSpecialColDef = (colDef) => {
+            const { type } = colDef;
+            const colTypes = Array.isArray(type) ? type : [type];
+            return colTypes.some((colType) => [
+                ACTION_COLUMN_TYPE,
+                CALCULATED_COLUMN_TYPE,
+                FREE_TEXT_COLUMN_TYPE,
+                FDC3_COLUMN_TYPE,
+            ].includes(colType));
+        };
+        const processedSpecialColDefIds = [];
+        const mapColDefs = (colDefs) => {
+            return colDefs.map((colDef) => {
+                if (this._adaptableInstance.agGridColumnAdapter.isColGroupDef(colDef)) {
+                    // if it's a group column, recursively map its children
+                    colDef.children = mapColDefs(colDef.children);
+                    return colDef;
+                }
+                else {
+                    if (!isSpecialColDef(colDef)) {
+                        // if it's not a special column, return it as is
+                        // without a minWidth, columns in details grid are VERY wide
+                        // so the line below fixes https://github.com/AdaptableTools/adaptable/issues/2559
+                        return { minWidth: 10, ...colDef };
+                    }
+                    const newlyCreatedSpecialColDef = specialColDefs.find((specialColDef) => specialColDef.colId === colDef.colId);
+                    if (newlyCreatedSpecialColDef) {
+                        // if it's a special column and we have a special col def for it, return the special col def
+                        processedSpecialColDefIds.push(colDef.colId);
+                        // merge the user defined colDef with the special col def
+                        // this way the user may provide some custom settings for the special col def (tooltip, etc)
+                        const mergedColDef = {
+                            // see above comment for minWidth
+                            minWidth: 10,
+                            ...colDef,
+                            ...newlyCreatedSpecialColDef,
+                        };
+                        return mergedColDef;
+                    }
+                    else {
+                        // otherwise, return the original col def
+                        return colDef;
+                    }
+                }
+            });
+        };
+        let resultColDefs = mapColDefs(agGridColDefs);
+        // check if there are any special colDefs that were not processed
+        // in that case, add them to the end of the colDefs
+        specialColDefs.forEach((specialColDef) => {
+            if (!processedSpecialColDefIds.includes(specialColDef.colId)) {
+                resultColDefs.push(specialColDef);
             }
         });
+        // remove special column that are no longer defined
+        resultColDefs = resultColDefs.filter((colDef) => {
+            if (isSpecialColDef(colDef)) {
+                // must be in specialColDefs
+                return specialColDefs.some((specialColDef) => specialColDef.colId === colDef.colId);
+            }
+            return true;
+        });
+        return resultColDefs;
+    }
+    getSpecialColDefs() {
+        const specialColDefs = [
+            ...this.adaptableApi.calculatedColumnApi.internalApi.getColDefsForCalculatedColumns(),
+            ...this.adaptableApi.actionColumnApi.internalApi.getColDefsForActionColumns(),
+            ...this.adaptableApi.freeTextColumnApi.internalApi.getColDefsForFreeTextColumns(),
+            ...this.adaptableApi.fdc3Api.internalApi.getFdc3ActionColDefs(),
+        ];
+        this.assignColumnIdsToColDefs(specialColDefs);
+        return specialColDefs;
     }
     deriveSelectedCellInfoFromAgGrid() {
         const selected = this.getAgGridApi().getCellRanges();
         const columns = [];
         const gridCells = [];
-        if (!(selected === null || selected === void 0 ? void 0 : selected.length) || this.adaptableApi.internalApi.isGridInPivotMode()) {
-            return { columns: [], gridCells: [] };
-        }
         // we iterate for each ranges
         selected.forEach((rangeSelection) => {
             let shouldIncludeRange = true;
             if (rangeSelection.startRow && rangeSelection.endRow) {
                 let isStartRowPin = rangeSelection.startRow.rowPinned != null;
                 let isEndRowPin = rangeSelection.endRow.rowPinned != null;
-                // Warn user if trying to select pinned rows
-                // If only selecting pinned rows then stop
+                // Warn user if trying to select pinned rows and if only selecting them, stop
                 if (isStartRowPin) {
                     if (isEndRowPin) {
                         shouldIncludeRange = false;
                     }
-                    this.adaptableInstance.logger.consoleWarn('Cannot select pinned rows in AG Grid.');
+                    this.logger.consoleWarn('Cannot select pinned rows in AG Grid.');
                 }
                 if (shouldIncludeRange) {
                     const y1 = Math.min(rangeSelection.startRow.rowIndex, rangeSelection.endRow.rowIndex);
@@ -130,8 +304,7 @@ export class AgGridAdapter {
                         if (column != null) {
                             const colId = column.getColId();
                             const selectedColumn = this.adaptableApi.columnApi.getColumnWithColumnId(colId);
-                            if (selectedColumn &&
-                                columns.find((c) => c.columnId == selectedColumn.columnId) == null) {
+                            if (selectedColumn && !columns.includes(selectedColumn)) {
                                 columns.push(selectedColumn);
                             }
                             for (let rowIndex = y1; rowIndex <= y2; rowIndex++) {
@@ -139,7 +312,7 @@ export class AgGridAdapter {
                                 // we used NOT to return grouped rows but I think that was wrong - if someone wants to return them then that is up to them...
                                 // we definitely dont return pinned rows as they cannot be selected
                                 if (rowNode && !this.isPinnedRowNode(rowNode)) {
-                                    const selectedCell = this.adaptableInstance.getGridCellFromRowNode(rowNode, colId);
+                                    const selectedCell = this.adaptableApi.gridApi.getGridCellFromRowNode(rowNode, colId);
                                     gridCells.push(selectedCell);
                                 }
                             }
@@ -148,10 +321,11 @@ export class AgGridAdapter {
                 }
             }
         });
-        return {
+        const selectedCellInfo = {
             columns,
             gridCells,
         };
+        return selectedCellInfo;
     }
     deriveSelectedRowInfoFromAgGrid() {
         const nodes = this.getAgGridApi().getSelectedNodes();
@@ -171,7 +345,7 @@ export class AgGridAdapter {
                     rowGroupLevel: node.level,
                 };
                 const gridRow = {
-                    primaryKeyValue: this.adaptableInstance.getPrimaryKeyValueFromRowNode(node),
+                    primaryKeyValue: this.adaptableApi.gridApi.getPrimaryKeyValueForRowNode(node),
                     rowData: node.data,
                     rowNode: node,
                     rowInfo,
@@ -181,20 +355,6 @@ export class AgGridAdapter {
         }
         return { gridRows: selectedRows };
     }
-    isModulePresent(moduleName) {
-        const standardAgGridRegistrationCheck = ModuleRegistry.__isRegistered(moduleName, this.getAgGridApi().getGridId());
-        if (standardAgGridRegistrationCheck) {
-            return true;
-        }
-        return this.getRegisteredModuleNames().some((name) => name === moduleName);
-    }
-    getRegisteredModuleNames() {
-        return this.getRegisteredModules().map((module) => module.moduleName);
-    }
-    getRegisteredModules() {
-        const gridId = this.getAgGridApi().getGridId();
-        return ModuleRegistry.__getRegisteredModules(gridId);
-    }
     isPinnedRowNode(rowNode) {
         if (!rowNode) {
             return false;
@@ -206,28 +366,31 @@ export class AgGridAdapter {
     }
     // TODO AFL MIG rename to getFirstGroupedColumnId()
     getFirstGroupedColumn() {
-        var _a, _b, _c, _d;
-        return (_d = (_c = (_b = (_a = this.getAgGridApi) === null || _a === void 0 ? void 0 : _a.call(this)) === null || _b === void 0 ? void 0 : _b.getRowGroupColumns()) === null || _c === void 0 ? void 0 : _c[0]) === null || _d === void 0 ? void 0 : _d.getColId();
+        return this.getAgGridApi?.()?.getRowGroupColumns()?.[0]?.getColId();
     }
     createAdaptableColumnFromAgGridColumn(agGridColumn, colsToGroups) {
         const colId = agGridColumn.getColId();
         const colDef = agGridColumn.getColDef();
+        const { columnApi } = this.adaptableApi;
         const ColumnId = colId;
-        const pkColumn = this.adaptableInstance.adaptableOptions.primaryKey;
-        const ColumnGroup = colsToGroups === null || colsToGroups === void 0 ? void 0 : colsToGroups[ColumnId];
+        const pkColumn = this.adaptableOptions.primaryKey;
+        const ColumnGroup = colsToGroups?.[ColumnId];
         const isRealColumnGroup = ColumnGroup
             ? ColumnGroup.columnGroupId !== ColumnGroup.friendlyName
             : false;
-        const isActionRowButtonColumn = this.adaptableInstance.api.columnApi.isActionRowButtonColumn(colId);
-        const isFdc3MainActionColumn = this.adaptableInstance.api.fdc3Api.internalApi.isFdc3MainActionColumn(colId);
+        const isFdc3MainActionColumn = this.adaptableApi.fdc3Api.internalApi.isFdc3MainActionColumn(colId);
         let friendlyName;
-        const colExists = this.adaptableInstance.api.columnApi.doesColumnExist(ColumnId);
+        const isGeneratedRowGroupColumn = columnApi.isAutoRowGroupColumn(ColumnId);
+        const isGeneratedPivotResultColumn = columnApi.isPivotResultColumn(ColumnId) && !agGridColumn.isPrimary();
+        const colExists = columnApi.doesColumnExist(ColumnId) ||
+            isGeneratedRowGroupColumn ||
+            isGeneratedPivotResultColumn;
         if (colExists) {
-            friendlyName = this.adaptableInstance.api.columnApi.getFriendlyNameForColumnId(ColumnId);
+            friendlyName = columnApi.getFriendlyNameForColumnId(ColumnId);
         }
         else {
             const displayName = this.getAgGridApi().getDisplayNameForColumn(agGridColumn, 'header');
-            const columnFriendlyName = this.adaptableInstance.adaptableOptions.columnOptions.columnFriendlyName;
+            const columnFriendlyName = this.adaptableOptions.columnOptions.columnFriendlyName;
             const customFriendlyName = typeof columnFriendlyName === 'function'
                 ? columnFriendlyName({
                     colId: colId,
@@ -237,167 +400,138 @@ export class AgGridAdapter {
                 })
                 : null;
             friendlyName =
-                customFriendlyName !== null && customFriendlyName !== void 0 ? customFriendlyName : (isActionRowButtonColumn
-                    ? ADAPTABLE_ROW_ACTION_BUTTONS_FRIENDLY_NAME
-                    : isFdc3MainActionColumn
-                        ? ADAPTABLE_FDC3_ACTION_COLUMN_FRIENDLY_NAME
-                        : displayName);
+                customFriendlyName ??
+                    (isFdc3MainActionColumn ? ADAPTABLE_FDC3_ACTION_COLUMN_FRIENDLY_NAME : displayName);
             // Add Column Group;s friendlyname to the Column Friendly Name if its in a legitimate Column Group
-            if (this.adaptableInstance.adaptableOptions.columnOptions.addColumnGroupToColumnFriendlyName &&
-                colDef.columnGroupShow &&
+            if (this.adaptableOptions.columnOptions.addColumnGroupToColumnFriendlyName &&
                 ColumnGroup &&
                 ColumnGroup.columnGroupId !== ColumnGroup.friendlyName) {
                 friendlyName += ' [' + ColumnGroup.friendlyName + ']';
             }
         }
-        const dataType = this.getColumnDataType(agGridColumn, false);
+        const dataType = isGeneratedPivotResultColumn
+            ? 'number'
+            : this.deriveAdaptableColumnDataType(agGridColumn, false);
+        const isTreeColumn = this.isTreeColumn(isGeneratedRowGroupColumn);
+        const visible = agGridColumn.isVisible();
+        const alwaysHidden = !visible &&
+            !isTreeColumn &&
+            colDef.lockVisible === true &&
+            colDef.suppressColumnsToolPanel === true &&
+            colDef.suppressFiltersToolPanel === true;
+        const isGenerated = isGeneratedRowGroupColumn || isGeneratedPivotResultColumn;
         const abColumn = {
             Uuid: createUuid(),
+            isTreeColumn,
             columnId: ColumnId,
             field: colDef.field,
             friendlyName: friendlyName,
             isPrimaryKey: ColumnId === pkColumn,
             dataType: dataType,
-            visible: agGridColumn.isVisible(),
+            visible,
+            alwaysHidden,
             readOnly: this.isColumnReadonly(colDef),
             columnGroup: ColumnGroup,
-            fieldOnly: this.isColumnFieldonly(colDef),
-            sortable: this.isColumnSortable(colDef),
+            fieldOnly: isGenerated ? false : this.isColumnFieldonly(colDef),
+            sortable: isGenerated ? false : this.isColumnSortable(colDef),
             filterable: this.isColumnFilterable(colDef),
-            groupable: this.isColumnRowGroupable(colDef),
-            pivotable: this.isColumnPivotable(colDef),
-            aggregatable: this.isColumnAggregetable(colDef),
+            queryable: true, // override later when we have the column object
+            exportable: true, // override later when we have the column object
+            groupable: isGenerated ? false : this.isColumnRowGroupable(colDef),
+            pivotable: isGenerated ? false : this.isColumnPivotable(colDef),
+            aggregatable: isGenerated ? false : this.isColumnAggregetable(colDef),
             availableAggregationFunctions: null,
             aggregationFunction: null,
             moveable: this.isColumnMoveable(colDef),
             hideable: this.isColumnHideable(colDef),
-            queryable: this.isColumnQueryable(colDef, ColumnId, friendlyName, dataType),
-            exportable: this.isColumnExportable(colDef, ColumnId, friendlyName, dataType),
-            isGrouped: this.isColumnRowGrouped(colDef),
+            isGrouped: isGenerated ? false : this.isColumnRowGrouped(colDef),
+            isGeneratedRowGroupColumn,
+            isGeneratedPivotResultColumn,
             isFixed: this.isColumnFixed(colDef),
             pinned: this.getColumnPinnedPosition(colDef),
             columnTypes: this.getColumnTypes(colDef),
-            isExcludedFromQuickSearch: false,
             isSparkline: this.isColumnSparkline(colDef),
+            isCalculatedColumn: this.isCalculatedColumn(colDef),
+            isFreeTextColumn: this.isFreeTextColumn(colDef),
+            isActionColumn: this.isActionColumn(colDef),
         };
+        abColumn.queryable = this.isColumnQueryable(abColumn);
+        abColumn.exportable = this.isColumnExportable(abColumn);
         if (abColumn.aggregatable) {
             abColumn.availableAggregationFunctions = this.getColumnAggregationFunctions(colDef);
             if (typeof colDef.aggFunc === 'string') {
                 abColumn.aggregationFunction = colDef.aggFunc;
             }
         }
-        // lets set this here one as the function cannot change the result so dont need to run it each time
-        let excludeColumnFromQuickSearch = this.adaptableInstance.adaptableOptions.quickSearchOptions.excludeColumnFromQuickSearch;
-        if (excludeColumnFromQuickSearch) {
-            if (excludeColumnFromQuickSearch(abColumn)) {
-                abColumn.isExcludedFromQuickSearch = true;
-            }
-        }
         return abColumn;
     }
-    getColumnDataType(column, logWarning = true) {
+    deriveAdaptableColumnDataType(agColumn, logWarning = true) {
         // Some columns can have no ID or Title. we return string as a consequence but it needs testing
-        if (!column) {
-            this.adaptableInstance.logger.warn('column is undefined returning String for Type');
-            return 'String';
+        if (!agColumn) {
+            this.logger.warn(`Column is undefined, returning 'text' for Type`);
+            return 'text';
         }
-        let dataType = 'Unknown';
+        let dataType = 'unknown';
         // get the column type if already in store (and not unknown)
-        const existingColumn = this.adaptableInstance.api.columnApi.getColumnWithColumnId(column.getId(), logWarning);
-        if (existingColumn && existingColumn.dataType !== 'Unknown') {
+        const existingColumn = this.adaptableApi.columnApi.getColumnWithColumnId(agColumn.getId(), logWarning);
+        if (existingColumn && existingColumn.dataType !== 'unknown') {
             return existingColumn.dataType;
         }
-        // check for column type
-        const colType = column.getColDef().type;
-        if (colType) {
-            if (Array.isArray(colType)) {
-                colType.forEach((c) => {
-                    if (dataType == 'Unknown') {
-                        dataType = this.getAbColDefValue(c);
-                    }
-                });
-            }
-            else {
-                dataType = this.getAbColDefValue(colType);
-            }
-            if (dataType != 'Unknown') {
-                return dataType;
-            }
+        // check for colDef dataType
+        const colDefDataType = agColumn.getColDef().cellDataType;
+        if (typeof colDefDataType === 'string' && ALL_ADAPTABLE_DATA_TYPES.includes(colDefDataType)) {
+            return colDefDataType;
         }
+        // see #agGridDataTypeDefinitions
+        // theoretically, if AG Grid was not able to infer the type, we should not be able to either
+        // but we give it a try, AG Grid is limited when the colDef has a valueGetter, valueParser, etc
+        // see https://www.ag-grid.com/javascript-data-grid/cell-data-types/#inferring-data-types
         let row = this.getAgGridApi().getDisplayedRowAtIndex(0);
         if (row == null) {
             // possible that there will be no data.
-            this.adaptableInstance.logger.consoleError(`No data in grid, returning type "Unknown" for Column: "${column.getColId()}". This will impact several Adaptable features, such as Filters and ColumnFormats.`);
-            return 'Unknown';
+            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.adaptableInstance.logger.consoleError(`No data in grid, returning type "Unknown" for Column: "${column.getColId()}". This will impact several Adaptable features, such as Filters and ColumnFormats.`);
-                return 'Unknown';
+                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(column, row);
-        if (value instanceof Date) {
-            dataType = 'Date';
+        const value = this._agGridApi_getValue(agColumn, row);
+        switch (typeof value) {
+            case 'string':
+                dataType = 'text';
+                break;
+            case 'number':
+                dataType = 'number';
+                break;
+            case 'boolean':
+                dataType = 'boolean';
+                break;
+            case 'object':
+                dataType = 'object';
+                break;
         }
-        else if (Array.isArray(value) && value.length && typeof value[0] === 'number') {
-            dataType = 'Unknown';
+        if (value instanceof Date) {
+            dataType = 'date';
         }
-        else {
-            switch (typeof value) {
-                case 'string':
-                    dataType = 'String';
-                    break;
-                case 'number':
-                    dataType = 'Number';
-                    break;
-                case 'boolean':
-                    dataType = 'Boolean';
-                    break;
-                case 'object':
-                    dataType = 'Object';
-                    break;
-                default:
-                    break;
+        else if (Array.isArray(value)) {
+            const arrayDataType = ALL_ADAPTABLE_DATA_TYPES.find((arrayType) => {
+                const dataTypeDefinition = agGridDataTypeDefinitions[arrayType];
+                const dataTypeMatching = dataTypeDefinition.dataTypeMatcher(value);
+                return dataTypeMatching;
+            });
+            if (arrayDataType) {
+                dataType = arrayDataType;
             }
         }
-        this.adaptableInstance.logger.consoleWarn(`No defined type for column '${column.getColId()}'. Defaulting to type of first row value: ${dataType}`);
+        this.logger.consoleWarn(`No defined type for column '${agColumn.getColId()}'. Defaulting to type of first row value: ${dataType}`);
         return dataType;
     }
-    getAbColDefValue(colType) {
-        if (colType == 'numericColumn') {
-            return 'Number';
-        }
-        if (colType.startsWith('abColDef')) {
-            const abColType = colType;
-            switch (abColType) {
-                case 'abColDefNumber':
-                    return 'Number';
-                case 'abColDefString':
-                    return 'String';
-                case 'abColDefBoolean':
-                    return 'Boolean';
-                case 'abColDefDate':
-                    return 'Date';
-                case 'abColDefObject':
-                    return 'Object';
-                case 'abColDefStringArray':
-                    return 'StringArray';
-                case 'abColDefNumberArray':
-                    return 'NumberArray';
-                case 'abColDefTupleNumberArray':
-                    return 'TupleNumberArray';
-                case 'abColDefObjectNumberArray':
-                    return 'ObjectNumberArray';
-                default:
-                    return 'Unknown';
-            }
-        }
-        return 'Unknown';
-    }
     isColumnReadonly(colDef) {
         if (!colDef) {
             return true;
@@ -442,6 +576,9 @@ export class AgGridAdapter {
     getColumnAggregationFunctions(colDef) {
         return colDef.allowedAggFuncs || ['sum', 'min', 'max', 'count', 'avg', 'first', 'last']; // those are the default fns aggrid supports out-of-the-box
     }
+    isTreeColumn(isGeneratedRowGroupColumn) {
+        return this.adaptableApi.gridApi.isTreeDataGrid() ? isGeneratedRowGroupColumn : false;
+    }
     isColumnMoveable(colDef) {
         if (!colDef) {
             return false;
@@ -454,43 +591,37 @@ export class AgGridAdapter {
         }
         return true;
     }
-    isColumnQueryable(colDef, columnId, friendlyName, datatype) {
-        if (!colDef) {
-            return false;
-        }
-        if (colDef.colId === ADAPTABLE_ROW_ACTION_BUTTONS) {
-            return false;
-        }
-        const abColumnBase = {
-            columnId: columnId,
-            friendlyName: friendlyName,
-            dataType: datatype,
-        };
-        return this.adaptableInstance.api.expressionApi.isColumnQueryable(abColumnBase);
+    isColumnQueryable(abColumn) {
+        return (
+            // !this.adaptableApi.columnApi.isPivotResultColumn(abColumn.columnId) &&
+            (this.adaptableApi.expressionApi.isColumnQueryable(abColumn))
+        );
     }
-    isColumnExportable(colDef, columnId, friendlyName, datatype) {
-        if (!colDef) {
-            return false;
-        }
-        if (colDef.colId === ADAPTABLE_ROW_ACTION_BUTTONS) {
-            return false;
-        }
-        const abColumnBase = {
-            columnId,
-            friendlyName,
-            dataType: datatype,
-        };
-        return this.adaptableInstance.api.exportApi.isColumnExportable(abColumnBase);
+    isColumnExportable(abColumn) {
+        return this.adaptableApi.exportApi.isColumnExportable(abColumn);
     }
     isColumnHideable(colDef) {
         if (!colDef) {
             return false;
         }
+        if (this.adaptableApi.gridApi.isTreeDataGrid() &&
+            this.adaptableApi.columnApi.isAutoRowGroupColumn(colDef.colId)) {
+            return false;
+        }
         if (colDef.lockVisible != null && colDef.lockVisible == true) {
             return false;
         }
         return true;
     }
+    isCalculatedColumn(colDef) {
+        return (this.adaptableApi.calculatedColumnApi.getCalculatedColumnForColumnId(colDef.colId) != null);
+    }
+    isFreeTextColumn(colDef) {
+        return this.adaptableApi.freeTextColumnApi.getFreeTextColumnForColumnId(colDef.colId) != null;
+    }
+    isActionColumn(colDef) {
+        return this.adaptableApi.actionColumnApi.getActionColumnForColumnId(colDef.colId) != null;
+    }
     isColumnFilterable(colDef) {
         // follow agGrid logic which is that ONLY filterable if explicitly set
         if (this.adaptableApi.entitlementApi.getEntitlementAccessLevelForModule(ModuleConstants.ColumnFilterModuleId) == 'Hidden') {
@@ -539,11 +670,12 @@ export class AgGridAdapter {
     }
     isColumnSparkline(colDef) {
         // see https://www.ag-grid.com/javascript-data-grid/sparklines-overview/#enabling-sparklines
-        return (colDef === null || colDef === void 0 ? void 0 : colDef.cellRenderer) === 'agSparklineCellRenderer';
+        return colDef?.cellRenderer === 'agSparklineCellRenderer';
     }
     isVisibleNode(rowNode) {
-        var _a;
-        const foundNode = (_a = this.getAgGridApi()) === null || _a === void 0 ? void 0 : _a.getRenderedNodes().find((n) => n.id == rowNode.id);
+        const foundNode = this.getAgGridApi()
+            ?.getRenderedNodes()
+            .find((n) => n.id == rowNode.id);
         return foundNode != null;
     }
     getFlattenedColDefs(colDefs = []) {
@@ -594,7 +726,7 @@ export class AgGridAdapter {
         const applyModification = (colDef) => {
             if ('children' in colDef) {
                 const updatedChildren = colDef.children.map(applyModification).filter(Boolean);
-                return Object.assign(Object.assign({}, colDef), { children: updatedChildren });
+                return { ...colDef, children: updatedChildren };
             }
             else {
                 return modifyFn(colDef);
@@ -603,17 +735,11 @@ export class AgGridAdapter {
         return colDefs.map(applyModification).filter(Boolean);
     }
     getDefaultColumnDefinition() {
-        var _a, _b;
         // for early init phase, gridApi might not be ready yet
-        return (_b = (_a = this.getAgGridApi(true)) === null || _a === void 0 ? void 0 : _a.getGridOption('defaultColDef')) !== null && _b !== void 0 ? _b : {};
+        return this.getAgGridApi(true)?.getGridOption('defaultColDef') ?? {};
     }
     _agGridApi_getValue(colKey, rowNode, gridApi) {
-        return _agGridApi_getValue(colKey, rowNode, gridApi || this.getAgGridApi());
+        gridApi = gridApi || this.getAgGridApi();
+        return gridApi.getCellValue({ colKey, rowNode });
     }
 }
-// FIXME remove this once we support only AG Grid >=30.3.x
-export const _agGridApi_getValue = (colKey, rowNode, gridApi) => {
-    return typeof gridApi.getCellValue === 'function'
-        ? gridApi.getCellValue({ colKey, rowNode })
-        : gridApi.getValue(colKey, rowNode);
-};