@adaptabletools/adaptable 20.1.8 → 20.2.0-canary.0

package/src/agGrid/AgGridColumnAdapter.js

@@ -134,6 +134,7 @@ export class AgGridColumnAdapter {
             this.setupColumnEditable(colSetupInfo);
             this.setupColumnValueSetter(colSetupInfo);
             this.setupColumnComparator(colSetupInfo);
+            this.setupColumnGetFindText(colSetupInfo);
             this.setupColumnCellEditor(colSetupInfo);
             this.setupColumnHeader(colSetupInfo);
             this.setupColumnQuickFilterText(colSetupInfo);
@@ -152,6 +153,8 @@ export class AgGridColumnAdapter {
         this.setColDefProperty(col, 'cellClass', (userCellClass) => {
             const formatColumns = this.adaptableApi.formatColumnApi.internalApi.getFormatColumnWithStyleClassNameForColumn(abColumn);
             const quickSearchStyleClassName = this.adaptableApi.quickSearchApi.getQuickSearchStyle().ClassName;
+            const quickSearchTextMatchStyle = this.getQuickSearchTextMatchStyle();
+            const quickSearchCurrentTextMatchStyle = this.getQuickSearchCurrentTextMatchStyle();
             const hasQuickSearchStyleClassName = StringExtensions.IsNotNullOrEmpty(quickSearchStyleClassName);
             const cellClass = (params) => {
                 const gridCell = this.adaptableApi.gridApi.getGridCellFromRowNode(params.node, abColumn.columnId);
@@ -164,7 +167,7 @@ export class AgGridColumnAdapter {
                     const cellClassKey = AgGridExportAdapter.getExcelClassNameForCell(colId, gridCell.primaryKeyValue, userDefinedCellClass);
                     return this.adaptableInstance.agGridExportAdapter.getExcelStyleIdForCellClassKey(cellClassKey);
                 }
-                const isQuickSearchActive = hasQuickSearchStyleClassName && this.isQuickSearchActive(gridCell, params);
+                const isQuickSearchActive = this.isQuickSearchActive(gridCell);
                 const editableClassName = this.getEditableCellClass(gridCell, params);
                 const readonlyClassName = this.getReadonlyCellClass(gridCell, params);
                 const editedClassName = this.getEditedCellClass(gridCell, params);
@@ -179,7 +182,10 @@ export class AgGridColumnAdapter {
                     !hasStyledColumn && formatColumns.length
                         ? this.getFormatColumnCellClass(formatColumns, abColumn, params)
                         : null,
-                    isQuickSearchActive ? quickSearchStyleClassName : null,
+                    isQuickSearchActive && hasQuickSearchStyleClassName ? quickSearchStyleClassName : null,
+                    isQuickSearchActive && (quickSearchTextMatchStyle || quickSearchCurrentTextMatchStyle)
+                        ? 'ab-QuickSearchFind'
+                        : null,
                     editableClassName,
                     readonlyClassName,
                     editedClassName,
@@ -197,19 +203,39 @@ export class AgGridColumnAdapter {
             return cellClass;
         });
     }
-    setupColumnCellStyle({ col, colId, abColumn }) {
+    setupColumnCellStyle({ col }) {
         this.setColDefProperty(col, 'cellStyle', (userCellStyle) => {
             const quickSearchStyle = this.getQuickSearchCellStyle();
-            const hasQuickSearchStyle = quickSearchStyle != undefined;
+            const quickSearchTextMatchStyle = this.getQuickSearchTextMatchStyle();
+            const quickSearchCurrentTextMatchStyle = this.getQuickSearchCurrentTextMatchStyle();
+            const textMatchStyle = quickSearchTextMatchStyle
+                ? Object.entries(quickSearchTextMatchStyle).reduce((acc, [key, value]) => {
+                    // @ts-ignore
+                    acc[`--ab-dynamic-${key}`] = value;
+                    return acc;
+                }, {})
+                : undefined;
+            const currentTextMatchStyle = quickSearchCurrentTextMatchStyle
+                ? Object.entries(quickSearchCurrentTextMatchStyle).reduce((acc, [key, value]) => {
+                    // @ts-ignore
+                    acc[`--ab-dynamic-${key}`] = value;
+                    return acc;
+                }, {})
+                : undefined;
+            const hasQuickSearchStyle = quickSearchStyle != undefined || quickSearchCurrentTextMatchStyle != undefined;
             const cellStyle = (params) => {
                 const columnId = params.column.getColId();
                 const gridCell = this.adaptableApi.gridApi.getGridCellFromRowNode(params.node, columnId);
                 if (!gridCell || !gridCell.column) {
                     return {};
                 }
-                const isQuickSearchActive = hasQuickSearchStyle && this.isQuickSearchActive(gridCell, params);
+                const isQuickSearchActive = hasQuickSearchStyle && this.isQuickSearchActive(gridCell);
+                const isCurrentMatch = this.adaptableApi.agGridApi.findGetActiveMatch()?.node === params.node;
+                const textStyleToApply = isCurrentMatch
+                    ? { ...textMatchStyle, ...currentTextMatchStyle }
+                    : textMatchStyle;
                 let baseStyles = {};
-                // this is required because otherwise, when AG Grid filters, it refershed the pivotResultColDef and the base styles get lost
+                // this is required because otherwise, when AG Grid filters, it refreshed the pivotResultColDef and the base styles get lost
                 // if pivot result col: inherit styles from base column
                 if (this.adaptableApi.columnApi.isPivotResultColumn(columnId)) {
                     const baseColumn = params.column.getColDef()?.pivotValueColumn;
@@ -233,6 +259,7 @@ export class AgGridColumnAdapter {
                     ...this.getEditedCellStyle(gridCell, params),
                     ...this.getFormatColumnAndStyledColumnCellStyle(gridCell, params),
                     ...(isQuickSearchActive ? quickSearchStyle : {}),
+                    ...(isQuickSearchActive && textStyleToApply ? textStyleToApply : {}),
                     ...this.getAlertCellStyle(gridCell, params),
                     ...this.getFlashingCellStyle(gridCell, params),
                     ...this.getCellHighlightStyle(gridCell, params),
@@ -398,18 +425,45 @@ export class AgGridColumnAdapter {
         });
     }
     setupColumnFilter({ col, colDef }) {
+        if (!this.adaptableOptions.filterOptions.useAdaptableFiltering) {
+            return;
+        }
+        // setup Auto Group Column Filter
+        if (this.adaptableApi.columnApi.isAutoRowGroupColumn(col.getColId())) {
+            if (this.adaptableApi.gridApi.isTreeDataGrid()) {
+                this.setColDefProperty(col, 'filter', (original_filter) => {
+                    const autoGroupColumnDef = this.agGridApi.getGridOption('autoGroupColumnDef');
+                    if (autoGroupColumnDef.filter != undefined) {
+                        // we plan to provide a TreeListColumnFilter
+                        // until then, it's the user's responsibility to explicitly set the filter in the provided `autoGroupColumnDef`
+                        return original_filter;
+                    }
+                    else {
+                        // if no filter is explicitly set, we do NOT provide a filter
+                        return false;
+                    }
+                });
+            }
+            else {
+                this.setColDefProperty(col, 'filter', () => {
+                    return 'agGroupColumnFilter';
+                });
+            }
+            return;
+        }
+        // setup "normal" column filter
         this.setColDefProperty(col, 'filter', () => {
             if (!colDef.filter) {
                 return;
             }
-            if (!this.adaptableOptions.filterOptions.useAdaptableFiltering) {
-                return;
-            }
             this.agGridApi.destroyFilter(col);
             return FilterWrapperFactory(this.adaptableInstance);
         });
     }
     setupColumnFloatingFilterTemporarily(initialGridOptions) {
+        if (!this.adaptableOptions.filterOptions.useAdaptableFiltering) {
+            return;
+        }
         initialGridOptions.columnDefs
             ?.filter((colDef) => !this.isColGroupDef(colDef))
             .map((colDef) => {
@@ -423,6 +477,21 @@ export class AgGridColumnAdapter {
         const isFloatingFilterDisabled = !colDef.floatingFilter ||
             !this.adaptableOptions.filterOptions.useAdaptableFiltering ||
             !this.adaptableOptions.filterOptions.columnFilterOptions.showQuickFilter;
+        if (this.adaptableApi.columnApi.isAutoRowGroupColumn(col.getColId())) {
+            this.setColDefProperty(col, 'floatingFilter', (original_floatingFilter) => {
+                // the floating filter for the group column is "inherited" from the base column
+                // via the colDef.filter =  'agGroupColumnFilter'
+                // see #group_inherit_column_filter
+                // https://www.ag-grid.com/javascript-data-grid/grouping-single-group-column/#inherit-row-grouped-columns-filters
+                // https://www.ag-grid.com/javascript-data-grid/grouping-multiple-group-columns/#filtering
+                return original_floatingFilter;
+            });
+            this.setColDefProperty(col, 'suppressFloatingFilterButton', () => {
+                // hide button for multi column groups
+                return this.adaptableApi.columnApi.isAutoRowGroupColumnForMulti(col.getColId());
+            });
+            return;
+        }
         this.setColDefProperty(col, 'floatingFilterComponent', () => {
             if (isFloatingFilterDisabled) {
                 return;
@@ -607,42 +676,66 @@ export class AgGridColumnAdapter {
         this.setColDefProperty(col, 'comparator', comparatorGetter('comparator'));
         this.setColDefProperty(col, 'pivotComparator', comparatorGetter('pivotComparator'));
     }
-    isQuickSearchActive(gridCell, params) {
-        const quickSearchValue = this.adaptableApi.quickSearchApi.getQuickSearchValue();
-        if (StringExtensions.IsNullOrEmpty(quickSearchValue)) {
-            return false;
-        }
-        if (!gridCell.rowNode) {
+    setupColumnGetFindText({ col, abColumn }) {
+        this.setColDefProperty(col, 'getFindText', (userGetFindText) => {
+            return (params) => {
+                const gridCell = this.adaptableApi.gridApi.getGridCellFromRowNode(params.node, abColumn.columnId);
+                if (!this.isCellSearchable(gridCell)) {
+                    return null;
+                }
+                const getCellSearchText = this.adaptableOptions.quickSearchOptions.getCellSearchText;
+                if (getCellSearchText) {
+                    const quickSearchValue = this.adaptableApi.quickSearchApi.getQuickSearchValue();
+                    const quickSearchContext = {
+                        ...this.adaptableApi.internalApi.buildBaseContext(),
+                        gridCell,
+                        quickSearchValue,
+                    };
+                    return getCellSearchText(quickSearchContext);
+                }
+                return userGetFindText?.(params) ?? gridCell.displayValue;
+            };
+        });
+    }
+    isCellSearchable(gridCell) {
+        const isCellSearchableFn = this.adaptableOptions.quickSearchOptions.isCellSearchable;
+        if (!gridCell.column) {
             return false;
         }
-        let quickSearchContext;
-        const isCellSearchable = this.adaptableOptions.quickSearchOptions.isCellSearchable;
-        if (isCellSearchable) {
-            quickSearchContext = {
+        if (isCellSearchableFn) {
+            const quickSearchValue = this.adaptableApi.quickSearchApi.getQuickSearchValue();
+            const quickSearchContext = {
                 ...this.adaptableApi.internalApi.buildBaseContext(),
                 gridCell,
                 quickSearchValue,
             };
-            if (!isCellSearchable(quickSearchContext)) {
+            if (!isCellSearchableFn(quickSearchContext)) {
                 return false;
             }
         }
-        const runCustomQuickSearch = this.adaptableOptions.quickSearchOptions.runCustomQuickSearch;
-        if (runCustomQuickSearch) {
-            if (!quickSearchContext) {
-                quickSearchContext = {
-                    ...this.adaptableApi.internalApi.buildBaseContext(),
-                    gridCell,
-                    quickSearchValue,
-                };
-            }
-            return runCustomQuickSearch(quickSearchContext);
+        return true;
+    }
+    isQuickSearchActive(gridCell) {
+        const quickSearchValue = this.adaptableApi.quickSearchApi.getQuickSearchValue();
+        if (!quickSearchValue) {
+            return false;
+        }
+        if (!this.isCellSearchable(gridCell)) {
+            return false;
+        }
+        let column = this.agGridApi.getColumn(gridCell.column.columnId);
+        if (!column && this.adaptableApi.layoutApi.isCurrentLayoutPivot()) {
+            column = this.agGridApi
+                .getAllGridColumns()
+                .find((col) => col.getColId() === gridCell.column.columnId);
+        }
+        if (!column) {
+            return false;
         }
-        const isCaseSensitive = this.adaptableOptions.quickSearchOptions.isQuickSearchCaseSensitive;
-        const cellDisplayValue = String(gridCell.displayValue);
-        const displayValue = isCaseSensitive ? cellDisplayValue : cellDisplayValue.toLocaleLowerCase();
-        const searchText = isCaseSensitive ? quickSearchValue : quickSearchValue.toLocaleLowerCase();
-        return displayValue.indexOf(searchText) !== -1;
+        return (this.agGridApi.findGetNumMatches({
+            column,
+            node: gridCell.rowNode,
+        }) > 0);
     }
     getEditableCellClass(gridCell, params) {
         const editableCellStyle = this.adaptableApi.userInterfaceApi.getEditableCellStyle();
@@ -741,6 +834,20 @@ export class AgGridColumnAdapter {
         }
         return convertAdaptableStyleToCSS(quickSearchStyle);
     }
+    getQuickSearchTextMatchStyle() {
+        const quickSearchTextMatchStyle = this.adaptableApi.quickSearchApi.getQuickSearchTextMatchStyle();
+        if (!quickSearchTextMatchStyle) {
+            return undefined;
+        }
+        return convertAdaptableStyleToCSS(quickSearchTextMatchStyle);
+    }
+    getQuickSearchCurrentTextMatchStyle() {
+        const quickSearchCurrentTextMatchStyle = this.adaptableApi.quickSearchApi.getQuickSearchCurrentTextMatchStyle();
+        if (!quickSearchCurrentTextMatchStyle) {
+            return undefined;
+        }
+        return convertAdaptableStyleToCSS(quickSearchCurrentTextMatchStyle);
+    }
     getReadOnlyCellStyle(gridCell, params) {
         const editableCellStyle = this.adaptableApi.userInterfaceApi.getReadOnlyCellStyle();
         if (!editableCellStyle) {

package/src/agGrid/AgGridExportAdapter.d.ts

@@ -1,13 +1,14 @@
 import { AdaptableAgGrid } from './AdaptableAgGrid';
 import { Report, ReportFormatType } from '../AdaptableState/ExportState';
 import { CsvExportParams, ExcelExportParams, ExcelStyle } from 'ag-grid-enterprise';
-import { ExportDestinationType, ExportResultData } from '../AdaptableOptions/ExportOptions';
+import { CustomExportParams, ExportDestinationType, ExportResultData } from '../AdaptableOptions/ExportOptions';
 import { Layout } from '../AdaptableState/LayoutState';
 export interface ExportConfig {
     report: Report;
     format: ReportFormatType;
     destination: ExportDestinationType;
     showProgressIndicator: boolean;
+    customExportParams?: (defaultExportParams: CustomExportParams) => CustomExportParams;
 }
 interface ExportProcessContext extends ExportConfig {
     exportedColumnIds: string[];
@@ -71,5 +72,9 @@ export declare class AgGridExportAdapter {
     private getCsvSeparator;
     private computeSkipColumnHeaders;
     private computeGetCustomContentBelowRow;
+    private getCellExportValueFromRawValue;
+    private getCustomExportDateFormat;
+    private getCellExportValueFromRawValueByType;
+    private getCellExportFormatType;
 }
 export {};

package/src/agGrid/AgGridExportAdapter.js

@@ -1,7 +1,7 @@
 import { ExportModuleId } from '../Utilities/Constants/ModuleConstants';
 import { waitForTimeout } from '../Utilities/waitForTimeout';
 import { convertCSSAbsoluteFontSizeToPt, getVariableColor, sanitizeStyle, } from '../Utilities/Helpers/StyleHelper';
-import { DateFormatter } from '../Utilities/Helpers/FormatHelper';
+import FormatHelper, { DateFormatter } from '../Utilities/Helpers/FormatHelper';
 import tinycolor from 'tinycolor2';
 import StringExtensions from '../Utilities/Extensions/StringExtensions';
 import { createUuid } from '../AdaptableState/Uuid';
@@ -72,7 +72,7 @@ export class AgGridExportAdapter {
             if (exportContext.isVisualExcelReport) {
                 // FIXME AFL patch styles only for exported columns!
                 // or even better, only cells
-                this.patchExcelStyles();
+                this.patchExcelStyles(exportContext);
                 excelStylesWerePatched = true;
             }
             // 1. easiest case, we download the file using AG Grid
@@ -128,7 +128,11 @@ export class AgGridExportAdapter {
      */
     buildExportProcessData(config) {
         const exportContext = this.buildExportProcessContext(config);
-        const exportParams = this.buildExportParams(exportContext);
+        let exportParams = this.buildExportParams(exportContext);
+        if (typeof config?.customExportParams === 'function') {
+            this.logger.info(`Custom export params for ${config.report.Name} in ${config.format} format`);
+            exportParams = config.customExportParams(exportParams);
+        }
         exportContext.exportedColumnIds = exportParams.columnKeys;
         return {
             exportContext,
@@ -139,7 +143,10 @@ export class AgGridExportAdapter {
         const baseExportParams = this.buildBaseExportParams(exportContext);
         if (exportContext.format === 'Excel' || exportContext.format === 'VisualExcel') {
             const excelExportParams = baseExportParams;
-            excelExportParams.sheetName = 'Sheet 1';
+            const sheetName = typeof this.exportOptions.excelSheetName === 'function'
+                ? this.exportOptions.excelSheetName(this.adaptableApi.exportApi.internalApi.buildBaseExportContext(exportContext.report.Name, exportContext.format, exportContext.destination))
+                : this.exportOptions.excelSheetName;
+            excelExportParams.sheetName = sheetName;
             return excelExportParams;
         }
         // for everything else we use the CSV export
@@ -398,7 +405,7 @@ export class AgGridExportAdapter {
                 return isoFormattedDate;
             }
         }
-        return this.adaptableApi.exportApi.internalApi.getCellExportValueFromRowNode(rowNode, columnId, exportContext.isVisualExcelReport);
+        return this.getCellExportValueFromRawValue(rowNode, this.adaptableApi.gridApi.getRawValueFromRowNode(rowNode, columnId), columnId, exportContext);
     }
     processRowGroupForExcelExport(rowNode, exportContext) {
         if (this.isTreeDataGrid()) {
@@ -423,10 +430,10 @@ export class AgGridExportAdapter {
                 rawValue = dateRawValue;
             }
         }
-        return this.adaptableApi.exportApi.internalApi.getCellExportValueFromRawValue(rowNode, rawValue, columnId, exportContext.isVisualExcelReport);
+        return this.getCellExportValueFromRawValue(rowNode, rawValue, columnId, exportContext);
     }
-    patchExcelStyles() {
-        const exportExcelStyles = this.buildExcelStyles();
+    patchExcelStyles(exportContext) {
+        const exportExcelStyles = this.buildExcelStyles(exportContext);
         // set DANGER_excelStyles without changing the array reference
         this.DANGER_excelStyles.splice(0, this.DANGER_excelStyles.length, ...exportExcelStyles);
     }
@@ -436,7 +443,7 @@ export class AgGridExportAdapter {
         this.cellClassKey2excelStyleIdMap = {};
         this.excelStylesWithFormattedDate = {};
     }
-    buildExcelStyles() {
+    buildExcelStyles(exportContext) {
         // we make sure that we start with a clean slate
         // theoretically this should have happened at the end of the export process, but just in case
         this.resetExcelStyles();
@@ -488,7 +495,7 @@ export class AgGridExportAdapter {
                     this.logger.warn(`Export Styling: Column with id ${columnId} not found in Adaptable`);
                     return;
                 }
-                const isDateCellExportedAsFormattedValue = this.isDateCellExportedAsFormattedValue(adaptableColumn);
+                const isDateCellExportedAsFormattedValue = this.isDateCellExportedAsFormattedValue(adaptableColumn, exportContext);
                 let cellClassParams;
                 const getLazyCellClassParams = () => {
                     if (!cellClassParams) {
@@ -555,6 +562,12 @@ export class AgGridExportAdapter {
                                 mostRelevantFormatColumn?.DisplayFormat?.Options?.Pattern;
                     }
                     if (dateFormatPattern) {
+                        const customDateFormatPattern = typeof dateFormatPattern === 'function'
+                            ? dateFormatPattern({
+                                ...this.adaptableApi.exportApi.internalApi.buildBaseExportContext(exportContext.report.Name, exportContext.format, exportContext.destination),
+                                column: adaptableColumn,
+                            })
+                            : dateFormatPattern;
                         const normalisedValue = this._adaptableInstance.getNormalisedValueFromRawValue(rawValue, abColumn);
                         if (normalisedValue) {
                             // we have to pass the date in the ISO format to Excel
@@ -565,7 +578,7 @@ export class AgGridExportAdapter {
                             });
                             if (isoFormattedValue) {
                                 finalCellExcelStyle.dataType = 'DateTime';
-                                finalCellExcelStyle.numberFormat = { format: dateFormatPattern };
+                                finalCellExcelStyle.numberFormat = { format: customDateFormatPattern };
                                 // create a new cell key to ensure any user provided className does not interfere
                                 const cellKey = AgGridExportAdapter.getExcelClassNameForCell(column.getColId(), this.adaptableApi.gridApi.getPrimaryKeyValueForRowNode(node));
                                 // we need to register so that later the cellProcessor will put the isoFormattedValue through (thus giving the formatting responsability to Excel)
@@ -591,11 +604,10 @@ export class AgGridExportAdapter {
     registerExcelStyleWithFormattedDate(cellClassId, isoFormattedValue) {
         this.excelStylesWithFormattedDate[cellClassId] = isoFormattedValue;
     }
-    isDateCellExportedAsFormattedValue(abColumn) {
+    isDateCellExportedAsFormattedValue(abColumn, exportContext) {
         return (!!this.exportOptions.exportDateFormat ||
             // FIXME AFL move this method here
-            this.adaptableApi.exportApi.internalApi.getCellExportFormatType(abColumn, 'date') ===
-                'formattedValue');
+            this.getCellExportFormatType(abColumn, 'date', exportContext) === 'formattedValue');
     }
     convertCSSToExcelStyle(style) {
         const getHexColor = (color) => {
@@ -785,4 +797,81 @@ export class AgGridExportAdapter {
             return detailRows;
         };
     }
+    getCellExportValueFromRawValue(rowNode, cellRawValue, columnId, exportContext) {
+        if (StringExtensions.IsNullOrEmpty(cellRawValue)) {
+            return cellRawValue;
+        }
+        const column = this.adaptableApi.columnApi.getColumnWithColumnId(columnId);
+        const columnDataType = column.dataType;
+        // 1. if it is a VisualExcel report format, we always ONLY send the formatted value and ignore all other properties
+        if (exportContext.isVisualExcelReport) {
+            return this.getCellExportValueFromRawValueByType(rowNode, cellRawValue, columnId, 'formattedValue');
+        }
+        const isDateColumn = columnDataType === 'date' || columnDataType === 'dateString';
+        // 2. if this is a date column and there is a custom export date format provided, that will next take precedence
+        if (isDateColumn) {
+            const customExportDateFormat = this.getCustomExportDateFormat(column, exportContext);
+            if (!!customExportDateFormat) {
+                return FormatHelper.DateFormatter(cellRawValue, {
+                    Pattern: customExportDateFormat,
+                });
+            }
+        }
+        // 3. in all other cases check the general export format types
+        const cellExportFormat = this.getCellExportFormatType(column, columnDataType, exportContext);
+        return this.getCellExportValueFromRawValueByType(rowNode, cellRawValue, columnId, cellExportFormat);
+    }
+    getCustomExportDateFormat(column, exportContext) {
+        const exportDateFormatOption = this.adaptableApi.optionsApi.getExportOptions().exportDateFormat;
+        return typeof exportDateFormatOption === 'function'
+            ? exportDateFormatOption({
+                ...this.adaptableApi.exportApi.internalApi.buildBaseExportContext(exportContext.report.Name, exportContext.format, exportContext.destination),
+                column,
+            })
+            : exportDateFormatOption;
+    }
+    getCellExportValueFromRawValueByType(rowNode, cellRawValue, columnId, 
+    // default to rawValue if, for some reason, the configs provide invalid values
+    type = 'rawValue') {
+        return type === 'rawValue'
+            ? cellRawValue
+            : // type === formattedValue
+                this.adaptableApi.gridApi.getDisplayValueFromRawValue(rowNode, columnId, cellRawValue);
+    }
+    getCellExportFormatType(column, columnDataType, exportContext) {
+        const exportDataFormat = this.exportOptions.exportDataFormat;
+        // First check if a function was provided and return the result
+        if (exportDataFormat != null && typeof exportDataFormat === 'function') {
+            const context = {
+                ...this.adaptableApi.exportApi.internalApi.buildBaseExportContext(exportContext.report.Name, exportContext.format, exportContext.destination),
+                column: column,
+            };
+            return exportDataFormat(context);
+        }
+        // Next Check if a "hard-coded" value has been provided and return that
+        if (exportDataFormat === 'rawValue') {
+            return 'rawValue';
+        }
+        if (exportDataFormat === 'formattedValue') {
+            return 'formattedValue';
+        }
+        // Finally test if a DataType object has been provided and return the relevant property
+        const dataFormatDataType = exportDataFormat;
+        if (dataFormatDataType) {
+            // format is customized based on column data type
+            switch (columnDataType) {
+                case 'text':
+                    return dataFormatDataType.text;
+                case 'number':
+                    return dataFormatDataType.number;
+                case 'date':
+                case 'dateString':
+                    return dataFormatDataType.date;
+                default:
+                    // default to rawValue for all other column types
+                    return 'rawValue';
+            }
+        }
+        return 'rawValue';
+    }
 }

package/src/agGrid/FloatingFilterWrapper.js

@@ -29,11 +29,37 @@ export const FloatingFilterWrapperFactory = (adaptable) => {
     function getNotifyModel(colId, onModelChange) {
         return getAgGridFilterNotifyModelFn(adaptableApi, colId, onModelChange);
     }
+    function findParentWithClass(element, className, stopClasses, applyToAll) {
+        let current = element.parentElement;
+        while (current) {
+            // Stop traversing if we hit any of the stop classes
+            if (stopClasses.some((stopClass) => current.classList.contains(stopClass))) {
+                return null;
+            }
+            if (current.classList.contains(className)) {
+                return current;
+            }
+            applyToAll?.(current);
+            current = current.parentElement;
+        }
+        return null;
+    }
     function patchParentElement(filterContainer) {
-        if (filterContainer) {
-            // todo: consider theme
-            filterContainer.parentElement.style.overflow = 'visible';
-            filterContainer.parentElement.parentElement.style.padding = 'var(--ab-space-1)';
+        if (!filterContainer) {
+            return;
+        }
+        const stopClasses = ['ag-header-row', 'ag-header-row-column-filter'];
+        // Find and update floating filter body
+        const filterBody = findParentWithClass(filterContainer, 'ag-floating-filter-full-body', stopClasses, (currentElem) => {
+            currentElem.style.height = '100%';
+        });
+        if (filterBody) {
+            filterBody.style.overflow = 'visible';
+        }
+        // Find and update header cell
+        const headerCell = findParentWithClass(filterContainer, 'ag-header-cell', stopClasses);
+        if (headerCell?.classList.contains('ag-floating-filter')) {
+            headerCell.style.padding = 'var(--ab-space-1)';
         }
     }
     if (adaptable.isAgGridInitialising) {

package/src/env.js

@@ -1,5 +1,5 @@
 export default {
     NEXT_PUBLIC_INFINITE_TABLE_LICENSE_KEY: "StartDate=2021-06-29|EndDate=2030-01-01|Owner=Adaptable|Type=distribution|TS=1624971462479|C=137829811,1004007071,2756196225,1839832928,3994409405,636616862" || '',
-    PUBLISH_TIMESTAMP: 1748626733832 || Date.now(),
-    VERSION: "20.1.8" || '--current-version--',
+    PUBLISH_TIMESTAMP: 1748873595292 || Date.now(),
+    VERSION: "20.2.0-canary.0" || '--current-version--',
 };

package/src/layout-manager/src/LayoutManagerModel.d.ts

@@ -73,6 +73,20 @@ export interface BaseLayoutModel {
         RowGroupDisplay: 'collapsed';
         Values: any[][];
     };
+    /**
+     * Behaviour for Expanding / Collapsing Column Groups
+     */
+    ColumnGroupValues?: {
+        ColumnGroupDisplay: 'always-expanded';
+    } | {
+        ColumnGroupDisplay: 'expanded';
+        Values: any[];
+    } | {
+        ColumnGroupDisplay: 'always-collapsed';
+    } | {
+        ColumnGroupDisplay: 'collapsed';
+        Values: any[];
+    };
     /**
      * Hides aggFunc name in the column header: e.g. 'sum(Bank Balance)' will just be 'Bank Balance'
      */
@@ -85,9 +99,9 @@ export interface BaseLayoutModel {
         [columnId: string]: 'left' | 'right';
     };
     /**
-     * Display Grand Total Row at the top or bottom of the Pivot Table
+     * Display Grand Total Row of the Pivot Table
      */
-    GrandTotalRow?: 'top' | 'bottom' | boolean;
+    GrandTotalRow?: 'top' | 'bottom' | 'pinnedTop' | 'pinnedBottom' | boolean;
 }
 export type ColumnAggregationModel = {
     aggFunc: string | true;

package/src/layout-manager/src/index.d.ts

@@ -76,7 +76,7 @@ export declare class LayoutManager<DATA_TYPE = any> extends LMEmitter {
     autoSizeColumns(columnIds?: string[]): false | string[];
     private applyPivotLayout;
     applyPivotTotals(layout: PivotLayoutModel): void;
-    applyPivotExpandLevel(layout: PivotLayoutModel): void;
+    applyColumnGroupCollapseExpandState(layout: PivotLayoutModel | TableLayoutModel): void;
     private withSuppressColumnAnimation;
     private patchColDefType;
     private setupPivotTotals;