@adaptabletools/adaptable-cjs 21.2.1 → 22.0.0-canary.0

package/src/agGrid/AdaptableAgGrid.js

@@ -106,6 +106,10 @@ const AgGridModulesAdapter_1 = require("./AgGridModulesAdapter");
 const devTools_1 = require("../devTools");
 const infinite_react_1 = require("@infinite-table/infinite-react");
 const FormatHelper_1 = require("../Utilities/Helpers/FormatHelper");
+const PredicateApiImpl_1 = require("../Api/Implementation/PredicateApiImpl");
+const AgGridFilterAdapter_1 = require("./AgGridFilterAdapter");
+const AdaptableFilterHandler_1 = require("./AdaptableFilterHandler");
+const AgGridFloatingFilterAdapter_1 = require("./AgGridFloatingFilterAdapter");
 const LocalEventService_Prototype = ag_grid_enterprise_1.LocalEventService.prototype;
 const LocalEventService_dispatchEvent = LocalEventService_Prototype.dispatchEvent;
 LocalEventService_Prototype.dispatchEvent = function (event) {
@@ -450,10 +454,14 @@ class AdaptableAgGrid {
         this.api.themeApi.applyCurrentTheme();
         this.validatePrimaryKey();
         this.checkShouldClearExistingFiltersOrSearches();
-        // FIXME AFL FILTER: talk with Radu: should ColumnFilters still be ignored?!
-        // see layoutModel.Ignore_ColumnFilters
         // initial filter model
-        this.applyFiltering();
+        const filteringApplied = this.applyFiltering();
+        // We may need to re-apply sort if there are ColumnSorts for columns with CustomSort defined
+        // This is required because AG Grid wasn't aware of the CustomSort when applying sorting initially
+        // this is not required when filtering was applied because filtering also triggers a sort refresh internally
+        if (!filteringApplied) {
+            this.refreshInitialSortIfNeeded();
+        }
         // 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
@@ -625,26 +633,67 @@ You need to define at least one Layout!`);
             normalize: true,
         });
     }
+    /**
+     * Returns TRUE if filtering was applied, FALSE otherwise
+     * This is important in the INIT phase because applying filtering will automatically refresh AG Grids columnState,
+     * implicitly refreshing the sorting state too (hence we don't need to apply sorting separately)
+     */
     applyFiltering(config) {
+        let filteringApplied = false;
         // default updateColumnFilterModel to TRUE, if not provided
         const updateColumnFilterModel = config?.updateColumnFilterModel ?? true;
         const agGridApi = this.agGridAdapter.getAgGridApi();
         if (updateColumnFilterModel) {
             const columnFilters = this.api.filterApi.columnFilterApi
                 .getActiveColumnFilters()
-                // FIXME AFL: we need this additional filter because 'getActiveColumnFilters' checks only for suspended while 'isColumnFilterActive' also checkss for COMPLETE filters
+                // we need this additional filter because 'getActiveColumnFilters' checks only for suspended while 'isColumnFilterActive' also checkss for COMPLETE filters
                 .filter((columnFilter) => this.api.filterApi.columnFilterApi.isColumnFilterActive(columnFilter));
             const filterModel = {};
             columnFilters.forEach((columnFilter) => {
                 filterModel[columnFilter.ColumnId] = columnFilter;
             });
             agGridApi.setFilterModel(filterModel);
+            filteringApplied = Object.keys(filterModel).length > 0;
         }
         // FIXME AFL FILTER why is this needed???
         this.refreshSelectedCellsState();
         this.refreshSelectedRowsState();
-        agGridApi.onFilterChanged();
+        // FIXME AFL: this is temporary, will be replaced with v22's new autoCol filtering
+        const currentPivotLayoutHasAutoCols = this.api.layoutApi.isCurrentLayoutPivot() &&
+            !!this.api.layoutApi.getCurrentRowGroupsColumnIds()?.length;
+        // agGridApi.setFilterModel() already triggered onFilterChanged(), so we skip it if updateColumnFilterModel is TRUE
+        if (!filteringApplied || currentPivotLayoutHasAutoCols) {
+            agGridApi.onFilterChanged();
+            filteringApplied = true;
+        }
         this._emit('AdapTableFiltersApplied');
+        return filteringApplied;
+    }
+    /**
+     * Checks if the current layout has ColumnSorts for columns that have CustomSort defined
+     * (either via initialState CustomSorts or via customSortComparers option) and refreshes the sort if needed.
+     */
+    refreshInitialSortIfNeeded() {
+        const currentLayout = this.api.layoutApi.getCurrentLayout();
+        const columnSorts = currentLayout?.ColumnSorts;
+        if (!columnSorts || columnSorts.length === 0) {
+            return;
+        }
+        const hasCustomSortForSortedColumn = columnSorts.some((columnSort) => {
+            // Check if there's a CustomSort defined in state for this column
+            const customSort = this.api.customSortApi.getCustomSortForColumn(columnSort.ColumnId);
+            if (customSort && !customSort.IsSuspended) {
+                return true;
+            }
+            // Check if there's a customSortComparer defined in options for this column
+            if (this.api.customSortApi.internalApi.columnHasCustomSortComparer(columnSort.ColumnId)) {
+                return true;
+            }
+            return false;
+        });
+        if (hasCustomSortForSortedColumn) {
+            this.layoutManager.refreshSort();
+        }
     }
     showQuickFilter() {
         const height = this.api.optionsApi.getFilterOptions().columnFilterOptions.quickFilterHeight;
@@ -725,6 +774,92 @@ You need to define at least one Layout!`);
             });
             return defaultColGroupDef;
         });
+        /**
+         * `autoGroupColumnDef`
+         */
+        this.agGridOptionsService.setGridOptionsProperty(gridOptions, 'autoGroupColumnDef', (original_autoGroupColumnDef) => {
+            // #autoGroupColumnDef
+            const useAdaptableFilter = this.adaptableOptions.filterOptions.useAdaptableFiltering;
+            if (!useAdaptableFilter) {
+                return original_autoGroupColumnDef;
+            }
+            if (original_autoGroupColumnDef?.filter === false) {
+                // if user disables filter on autoGroupColumnDef, we respect that
+                this.logger.info(`autoGroupColumnDef.filter is disabled as per user configuration.`);
+                return original_autoGroupColumnDef;
+            }
+            if (typeof original_autoGroupColumnDef?.filter === 'object') {
+                this.logger.warn(`autoGroupColumnDef.filter is set and overrides the Adaptable custom filter mechanism! We recommend using a ColumnOptions.columnHeader instead!`);
+                return original_autoGroupColumnDef;
+            }
+            const autoGroupColumnDef = { ...original_autoGroupColumnDef };
+            // this is required to make sure that AG Grid doesn't disable the filter
+            // !! DO NOT REMOVE THIS !!
+            // see https://github.com/ag-grid/ag-grid/blob/6f43ff257c2e285068eb425b655e58d6eeb89816/packages/ag-grid-enterprise/src/rowHierarchy/autoColService.ts#L225
+            autoGroupColumnDef.filterValueGetter = (params) => {
+                this.logger.error('autoGroupColumnDef.filterValueGetter was called unexpectedly; this is not an expected execution path!', params);
+                return '';
+            };
+            // !! it is important that we always return the same component / handler instances
+            // otherwise AG Grid will re-create the filter instance on each filterModel change
+            const autoGroupFilterComponent = (0, AgGridFilterAdapter_1.AgGridFilterAdapterFactory)(this);
+            const autoGroupFilterHandlerGenerator = () => new AdaptableFilterHandler_1.AdaptableFilterHandler(this.api);
+            // Use a getter to dynamically return different filter values based on Layout.RowGroupDisplayType
+            Object.defineProperty(autoGroupColumnDef, 'filter', {
+                get: () => {
+                    const rowGroupDisplayType = this.api.layoutApi.internalApi.getCurrentLayoutRowGroupDisplayType();
+                    if (rowGroupDisplayType === 'single') {
+                        return {
+                            component: autoGroupFilterComponent,
+                            handler: autoGroupFilterHandlerGenerator,
+                        };
+                    }
+                    const groupedColumnFilterConfig = this.api.layoutApi.internalApi.areAllGroupedColumnsFilterable();
+                    if (groupedColumnFilterConfig.filter) {
+                        return 'agGroupColumnFilter';
+                    }
+                    return original_autoGroupColumnDef?.filter;
+                },
+                enumerable: true,
+                configurable: true,
+            });
+            if (original_autoGroupColumnDef?.floatingFilter !== false) {
+                autoGroupColumnDef.suppressFloatingFilterButton = true;
+                Object.defineProperty(autoGroupColumnDef, 'floatingFilter', {
+                    get: () => {
+                        const rowGroupDisplayType = this.api.layoutApi.internalApi.getCurrentLayoutRowGroupDisplayType();
+                        if (rowGroupDisplayType === 'single') {
+                            return true;
+                        }
+                        if (rowGroupDisplayType === 'multi') {
+                            const groupedColumnFilterConfig = this.api.layoutApi.internalApi.areAllGroupedColumnsFilterable();
+                            if (groupedColumnFilterConfig.floatingFilter) {
+                                return true;
+                            }
+                        }
+                        return original_autoGroupColumnDef?.floatingFilter;
+                    },
+                    enumerable: true,
+                    configurable: true,
+                });
+                // !! it is important that we always return the same component / handler instances
+                // otherwise AG Grid will re-create the filter instance on each filterModel change
+                const autoGroupFloatingFilterComponent = (0, AgGridFloatingFilterAdapter_1.AgGridFloatingFilterAdapterFactory)(this);
+                // Use a getter to dynamically return different floatingFilterComponent values based on Layout.RowGroupDisplayType
+                Object.defineProperty(autoGroupColumnDef, 'floatingFilterComponent', {
+                    get: () => {
+                        const rowGroupDisplayType = this.api.layoutApi.internalApi.getCurrentLayoutRowGroupDisplayType();
+                        if (rowGroupDisplayType === 'single') {
+                            return autoGroupFloatingFilterComponent;
+                        }
+                        return;
+                    },
+                    enumerable: true,
+                    configurable: true,
+                });
+            }
+            return autoGroupColumnDef;
+        });
         /**
          * `theme`
          */
@@ -1683,19 +1818,7 @@ You need to define at least one Layout!`);
     deriveAdaptableColumnStateFromAgGrid() {
         const allColumns = [];
         const gridApi = this.agGridAdapter.getAgGridApi();
-        const isPivot = this.isInPivotMode();
-        let agGridCols = isPivot
-            ? gridApi.getColumns()
-            : // we call getAllGridColumns because we want to also have the generated group columns
-                gridApi.getAllGridColumns();
-        if (isPivot) {
-            // let's also support the pivot result columns
-            const pivotResultColumns = gridApi.getPivotResultColumns() || [];
-            const autoGroupColumns = gridApi
-                .getAllGridColumns()
-                .filter((column) => this.api.columnApi.isAutoRowGroupColumn(column.getColId()));
-            agGridCols = [...autoGroupColumns, ...agGridCols, ...pivotResultColumns];
-        }
+        let agGridCols = this.agGridColumnAdapter.getAllAgGridColumns();
         const columnGroupChildren = gridApi.getAllDisplayedColumnGroups();
         const groupsCount = {};
         const colsToGroups = (columnGroupChildren ?? []).reduce((acc, columnGroup) => {
@@ -1768,14 +1891,21 @@ You need to define at least one Layout!`);
         let _displayValue = defaults ? defaults.displayValue : undefined;
         let _normalisedValue = defaults ? defaults.normalisedValue : undefined;
         let _isRowGroupCell;
-        const _isPivotCell = this.api.columnApi.isPivotResultColumn(columnId) ||
-            this.api.columnApi.isPivotAggColumnWithNoPivotColumns(columnId);
+        let _isPivotCell;
         const self = this;
         const api = this.api;
+        const getIsPivotCell = () => {
+            if (_isPivotCell === undefined) {
+                _isPivotCell =
+                    api.columnApi.isPivotResultColumn(columnId) ||
+                        api.columnApi.isPivotAggColumnWithNoPivotColumns(columnId);
+            }
+            return _isPivotCell;
+        };
         const getRawValue = () => {
             if (_rawValue === undefined) {
                 _rawValue = self.getRawValueFromRowNode(rowNode, columnId);
-                if (_isPivotCell && _rawValue?.value != undefined) {
+                if (_rawValue?.value != undefined && getIsPivotCell()) {
                     // 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;
@@ -1818,7 +1948,7 @@ You need to define at least one Layout!`);
                 return _primaryKeyValue;
             },
             get isPivotCell() {
-                return _isPivotCell;
+                return getIsPivotCell();
             },
             get isRowGroupCell() {
                 if (_isRowGroupCell === undefined) {
@@ -3390,6 +3520,7 @@ You need to define at least one Layout!`);
         this.__prevLayoutForRefresh = undefined;
         this.layoutManager?.destroy();
         this.layoutManager = null;
+        (0, PredicateApiImpl_1.clearPredicateDefMapMemo)();
         const agGridApi = this.agGridAdapter?.getAgGridApi();
         if (agGridApi && !agGridApi.isDestroyed()) {
             agGridApi.removeEventListener('firstDataRendered', this.listenerFirstDataRendered);
@@ -3971,7 +4102,8 @@ You need to define at least one Layout!`);
                 }
             }
             // also we need to reset the cache for the group column, when we have rowGripDisplayType single
-            if (layout.RowGroupDisplayType === 'single') {
+            if (layout.RowGroupDisplayType === 'single' &&
+                (layout.RowGroupedColumns?.length || layout.PivotGroupedColumns?.length)) {
                 this.api.filterApi.columnFilterApi.resetFilterValues(GeneralConstants_1.AG_GRID_GROUPED_COLUMN);
             }
         }

package/src/agGrid/AdaptableFilterHandler.d.ts

@@ -1,16 +1,15 @@
 import { DoesFilterPassParams, FilterHandler, FilterHandlerParams } from 'ag-grid-enterprise';
 import { AdaptableApi } from '../Api/AdaptableApi';
-import { ColumnSetupInfo } from '../AdaptableState/Common/ColumnSetupInfo';
 import { InFilterValueResult } from '../AdaptableOptions/FilterOptions';
 import { ColumnFilter } from '../types';
-export declare class AdaptableFilterHandler implements FilterHandler {
+export declare class AdaptableFilterHandler implements FilterHandler<any, any, ColumnFilter> {
     private adaptableApi;
-    readonly colId: string;
+    colId: string;
     private filterDisplayValuesResult;
     private previousFilterDisplayValuesResult;
-    constructor(adaptableApi: AdaptableApi, columnSetup: ColumnSetupInfo);
-    getCurrentColumnFilters(): ColumnFilter[];
-    doesFilterPass(params: DoesFilterPassParams): boolean;
+    constructor(adaptableApi: AdaptableApi);
+    init(params: FilterHandlerParams): void;
+    doesFilterPass(params: DoesFilterPassParams<any, any, ColumnFilter>): boolean;
     getCachedFilterDisplayValues(): InFilterValueResult | undefined;
     getLastCachedFilterDisplayValues(): InFilterValueResult | undefined;
     getFromCacheOrFetchFilterDisplayValues(options: {

package/src/agGrid/AdaptableFilterHandler.js

@@ -2,20 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AdaptableFilterHandler = void 0;
 class AdaptableFilterHandler {
-    constructor(adaptableApi, columnSetup) {
+    constructor(adaptableApi) {
         this.adaptableApi = adaptableApi;
-        this.colId = columnSetup.colId;
     }
-    getCurrentColumnFilters() {
-        const columnFilters = this.adaptableApi.filterApi.columnFilterApi
-            .getActiveColumnFilters()
-            .filter((columnFilter) => this.adaptableApi.filterApi.columnFilterApi.isColumnFilterActive(columnFilter))
-            .filter((columnFilter) => columnFilter.ColumnId === this.colId)
-            .filter((columnFilter) => {
-            const shouldEvaluateFilterOnClient = this.adaptableApi.expressionApi.internalApi.shouldEvaluatePredicatesInAdaptableQL('ColumnFilter', columnFilter, columnFilter.Predicates);
-            return shouldEvaluateFilterOnClient;
-        });
-        return columnFilters;
+    init(params) {
+        this.colId = params.column.getColId();
     }
     doesFilterPass(params) {
         try {
@@ -25,12 +16,15 @@ class AdaptableFilterHandler {
             if (!isRowFilterable) {
                 return true;
             }
-            const columnFilters = this.getCurrentColumnFilters();
-            const anyFilterFailed = columnFilters.some((columnFilter) => {
-                const result = !this.adaptableApi.filterApi.columnFilterApi.internalApi.evaluateColumnFilter(columnFilter, rowNode);
-                return result;
-            });
-            return anyFilterFailed ? false : true;
+            const columnFilterModel = params.model;
+            if (!columnFilterModel) {
+                this.adaptableApi.logWarn(`AdaptableFilterHandler.doesFilterPass: No filter model found for column ${this.colId}`);
+                return true;
+            }
+            if (columnFilterModel.IsSuspended) {
+                return true;
+            }
+            return this.adaptableApi.filterApi.columnFilterApi.internalApi.evaluateColumnFilter(columnFilterModel, rowNode);
         }
         catch (ex) {
             this.adaptableApi.consoleError(ex);
@@ -49,7 +43,7 @@ class AdaptableFilterHandler {
         }
         return this.fetchFilterDisplayValues(options);
     }
-    fetchFilterDisplayValues(options) {
+    async fetchFilterDisplayValues(options) {
         return this.adaptableApi.gridApi.internalApi
             .getDistinctFilterDisplayValuesForColumn({
             columnId: this.colId,

package/src/agGrid/AgGridAdapter.d.ts

@@ -11,6 +11,7 @@ export declare class AgGridAdapter {
     private DANGER_updateGridOptionsMonkeyPatcher;
     private DANGER_doFiltersPassMonkeyPatcher;
     private DANGER_isAggFilterPresentMonkeyPatcher;
+    private activePivotColumnFilters_MEMO;
     initialGridOptions: GridOptions;
     private _agGridId;
     constructor(_adaptableInstance: AdaptableAgGrid, config?: {
@@ -20,6 +21,7 @@ export declare class AgGridAdapter {
     private get adaptableOptions();
     private get adaptableApi();
     private get logger();
+    private getActivePivotColumnFilters;
     private get agGridOptionsService();
     setAgGridId(agGridId: string): void;
     setAgGridApi(gridApi: GridApi): void;

package/src/agGrid/AgGridAdapter.js

@@ -19,6 +19,7 @@ const getColumnApiModule = () => ag_grid_enterprise_1.ColumnApiModule;
 class AgGridAdapter {
     constructor(_adaptableInstance, config) {
         this._adaptableInstance = _adaptableInstance;
+        this.activePivotColumnFilters_MEMO = new WeakMap();
         const columnApiModuleReference = config?.getAgGridColumnApiModuleReference?.() ?? getColumnApiModule();
         const ColumnDefFactory_Prototype = columnApiModuleReference?.beans?.[0]?.prototype;
         if (!ColumnDefFactory_Prototype) {
@@ -44,6 +45,7 @@ class AgGridAdapter {
         this.DANGER_updateGridOptionsMonkeyPatcher = null;
         this.DANGER_doFiltersPassMonkeyPatcher = null;
         this.DANGER_isAggFilterPresentMonkeyPatcher = null;
+        this.activePivotColumnFilters_MEMO = null;
         this._adaptableInstance = null;
     }
     get adaptableOptions() {
@@ -55,6 +57,27 @@ class AgGridAdapter {
     get logger() {
         return this._adaptableInstance.logger;
     }
+    getActivePivotColumnFilters() {
+        // we memoize based on layout column filters object reference
+        // this method is called for each row during filtering so we need to optimize it
+        const layoutColumnFilters = this.adaptableApi.layoutApi.internalApi.getCurrentLayout_perfOptimized()?.ColumnFilters;
+        if (!layoutColumnFilters) {
+            return [];
+        }
+        const memoizedColumnFilters = this.activePivotColumnFilters_MEMO.get(layoutColumnFilters);
+        if (memoizedColumnFilters) {
+            return memoizedColumnFilters;
+        }
+        const pivotColumnFilters = this.adaptableApi.filterApi.columnFilterApi
+            .getActiveColumnFilters()
+            .filter((columnFilter) => this.adaptableApi.columnApi.isPivotResultColumn(columnFilter.ColumnId) ||
+            this.adaptableApi.columnApi.isAutoRowGroupColumnForSingle(columnFilter.ColumnId) ||
+            this.adaptableApi.columnApi.isPivotAggColumnWithNoPivotColumns(columnFilter.ColumnId))
+            .filter((columnFilter) => this.adaptableApi.filterApi.columnFilterApi.isColumnFilterActive(columnFilter))
+            .filter((columnFilter) => this.adaptableApi.expressionApi.internalApi.shouldEvaluatePredicatesInAdaptableQL('ColumnFilter', columnFilter, columnFilter.Predicates));
+        this.activePivotColumnFilters_MEMO.set(layoutColumnFilters, pivotColumnFilters);
+        return pivotColumnFilters;
+    }
     get agGridOptionsService() {
         return this._adaptableInstance.agGridOptionsService;
     }
@@ -155,21 +178,15 @@ class AgGridAdapter {
                 // should NEVER happen
                 return true;
             }
-            const pivotColumnFilters = self.adaptableApi.filterApi.columnFilterApi
-                .getActiveColumnFilters()
-                .filter((columnFilter) => self.adaptableApi.columnApi.isPivotResultColumn(columnFilter.ColumnId) ||
-                self.adaptableApi.columnApi.isAutoRowGroupColumnForSingle(columnFilter.ColumnId) ||
-                self.adaptableApi.columnApi.isPivotAggColumnWithNoPivotColumns(columnFilter.ColumnId));
+            const pivotColumnFilters = self.getActivePivotColumnFilters();
             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;
-                            }
+                        const columnFilterEvaluationResult = self.adaptableApi.filterApi.columnFilterApi.internalApi.evaluateColumnFilter(columnFilter, rowNode);
+                        if (!columnFilterEvaluationResult) {
+                            return false;
                         }
+                        // else continue to next filter
                     }
                 }
             }
@@ -181,10 +198,7 @@ class AgGridAdapter {
         };
         agGridColumnFilterService.doFiltersPass = this.DANGER_doFiltersPassMonkeyPatcher;
         this.DANGER_isAggFilterPresentMonkeyPatcher = function () {
-            const columnFilters = self.adaptableApi.filterApi.columnFilterApi.getActiveColumnFilters();
-            return columnFilters.some((colFilter) => self.adaptableApi.columnApi.isPivotResultColumn(colFilter.ColumnId) ||
-                self.adaptableApi.columnApi.isAutoRowGroupColumnForSingle(colFilter.ColumnId) ||
-                self.adaptableApi.columnApi.isPivotAggColumnWithNoPivotColumns(colFilter.ColumnId));
+            return self.getActivePivotColumnFilters().length > 0;
         };
         agGridColumnFilterService.isAggFilterPresent = this.DANGER_isAggFilterPresentMonkeyPatcher;
     }

package/src/agGrid/AgGridColumnAdapter.d.ts

@@ -16,7 +16,12 @@ export declare class AgGridColumnAdapter {
     setColDefProperty<T extends keyof ColDef>(col: Column, propertyName: T, propertyGetter: (userPropertyValue: ColDef[T]) => ColDef[T] | undefined): void;
     getUserColDefProperty<T extends keyof ColDef>(columnId: string, propertyName: T): ColDef[T] | undefined;
     shouldSkipColumn(colId: string): boolean;
-    setupColumns(): void;
+    getAllAgGridColumns(): Column<any>[];
+    /**
+     * Setup all columns, or only those with the given Ids
+     * @param specificColumnIds - optional list of column Ids to setup. If not provided, all columns are setup
+     */
+    setupColumns(specificColumnIds?: string[]): void;
     private setupColumnValueGetter;
     private setupColumnCellClass;
     private setupColumnHeaderClass;

package/src/agGrid/AgGridColumnAdapter.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AgGridColumnAdapter = exports.getEditorForColumnDataType = void 0;
+exports.AgGridColumnAdapter = void 0;
+exports.getEditorForColumnDataType = getEditorForColumnDataType;
 const tslib_1 = require("tslib");
 const kebabCase_1 = tslib_1.__importDefault(require("lodash/kebabCase"));
 const merge_1 = tslib_1.__importDefault(require("lodash/merge"));
@@ -30,7 +31,6 @@ function getEditorForColumnDataType(columnDataType, variant) {
         return variant === 'react' ? AdaptableDateEditor_1.AdaptableReactDateEditor : AdaptableDateEditor_1.AdaptableDateEditor;
     }
 }
-exports.getEditorForColumnDataType = getEditorForColumnDataType;
 class AgGridColumnAdapter {
     constructor(adaptableInstance) {
         this.adaptableInstance = adaptableInstance;
@@ -107,7 +107,7 @@ class AgGridColumnAdapter {
             !this.adaptableApi.columnApi.isAutoRowGroupColumn(colId) &&
             !this.adaptableApi.columnApi.isSelectionColumn(colId));
     }
-    setupColumns() {
+    getAllAgGridColumns() {
         const pivotMode = this.adaptableInstance.isInPivotMode();
         let cols = pivotMode
             ? // for pivot mode, we take only the initial columns
@@ -122,6 +122,17 @@ class AgGridColumnAdapter {
                 .filter((column) => this.adaptableApi.columnApi.isAutoRowGroupColumn(column.getColId()));
             cols = [...autoGroupColumns, ...cols, ...pivotResultColumns];
         }
+        return cols;
+    }
+    /**
+     * Setup all columns, or only those with the given Ids
+     * @param specificColumnIds - optional list of column Ids to setup. If not provided, all columns are setup
+     */
+    setupColumns(specificColumnIds) {
+        let cols = this.getAllAgGridColumns();
+        if (specificColumnIds?.length) {
+            cols = cols.filter((col) => specificColumnIds.includes(col.getColId()));
+        }
         // this needs to be here, before the other setup below
         // so the setup methods below reference the correct columns in adaptable store
         cols.forEach((col) => {
@@ -137,6 +148,7 @@ class AgGridColumnAdapter {
                 colId,
                 abColumn,
             };
+            const isAutoRowGroupColumn = this.adaptableApi.columnApi.isAutoRowGroupColumn(colId);
             this.setupColumnCellRenderer(colSetupInfo);
             this.setupColumnCellStyle(colSetupInfo);
             this.setupColumnCellClass(colSetupInfo);
@@ -144,8 +156,13 @@ class AgGridColumnAdapter {
             this.setupColumnHeaderClass(colSetupInfo);
             this.setupColumnValueGetter(colSetupInfo);
             this.setupColumnTooltipValueGetter(colSetupInfo);
-            this.setupColumnFilter(colSetupInfo);
-            this.setupColumnFloatingFilter(colSetupInfo);
+            if (!isAutoRowGroupColumn) {
+                // we do NOT setup filtering for  auto row group columns
+                // this is done via gridOptions.autoGroupColumnDef
+                // see #autoGroupColumnDef
+                this.setupColumnFilter(colSetupInfo);
+                this.setupColumnFloatingFilter(colSetupInfo);
+            }
             this.setupColumnValueFormatter(colSetupInfo);
             this.setupColumnEditable(colSetupInfo);
             this.setupColumnValueSetter(colSetupInfo);
@@ -460,8 +477,12 @@ class AgGridColumnAdapter {
                         valueToLabelMap.set(option.value, option.label);
                         return option.value;
                     }));
+                    const fetchSelectItems = (_params) => {
+                        return values;
+                    };
                     return {
-                        values,
+                        // we need to pass a function which returns a Promise, that's what AG Grid expects
+                        values: fetchSelectItems,
                         formatValue: (value) => valueToLabelMap.get(value) ?? value,
                     };
                 };
@@ -644,7 +665,7 @@ class AgGridColumnAdapter {
             }
             return {
                 component: (0, AgGridFilterAdapter_1.AgGridFilterAdapterFactory)(this.adaptableInstance),
-                handler: () => new AdaptableFilterHandler_1.AdaptableFilterHandler(this.adaptableApi, columnSetup),
+                handler: () => new AdaptableFilterHandler_1.AdaptableFilterHandler(this.adaptableApi),
             };
         });
     }

package/src/agGrid/AgGridFilterAdapter.js

@@ -40,7 +40,7 @@ const AgGridFilterAdapterFactory = (adaptable) => {
             if (column) {
                 this.unmountReactRoot = adaptable.renderReactRoot((0, renderWithAdaptableContext_1.renderWithAdaptableContext)(React.createElement(AdaptableColumnFilter_1.AdaptableColumnFilter, {
                     columnId,
-                    wrapperProps: { p: 2 },
+                    wrapperProps: { className: 'twa:p-2' },
                     location: 'columnMenu',
                 }), adaptable), this.filterContainer);
             }

package/src/agGrid/AgGridFloatingFilterAdapter.js

@@ -61,26 +61,6 @@ const AgGridFloatingFilterAdapterFactory = (adaptable) => {
             headerCell.style.padding = 'var(--ab-space-1)';
         }
     }
-    if (adaptable.isAgGridInitialising) {
-        if (adaptable.variant === 'react') {
-            return () => React.createElement(React.Fragment, null);
-        }
-        return class FloatingFilterStub {
-            init(params) {
-                this.filterContainer = document.createElement('div');
-            }
-            getGui() {
-                return this.filterContainer;
-            }
-            destroy() {
-                this.unmountReactRoot?.();
-                this.filterContainer = null;
-            }
-            onParentModelChanged() {
-                // nothing yet
-            }
-        };
-    }
     return class AgGridFloatingFilterAdapter {
         init(params) {
             const colId = params.column.getColId();
@@ -111,7 +91,7 @@ const AgGridFloatingFilterAdapterFactory = (adaptable) => {
         }
         refresh(params) {
             // always reuse the current instance
-            // the filte ris refreshed in the underlying React component
+            // the filter is refreshed in the underlying React component
             return true;
         }
         destroy() {

package/src/agGrid/editors/AdaptableNumberEditor/InternalAdaptableNumberEditor.js

@@ -68,11 +68,7 @@ exports.InternalAdaptableNumberEditor = React.forwardRef(function InternalAdapta
         React.createElement("input", { "data-name": "AdaptableNumberEditorInput", type: props.type ?? 'number', value: value, onKeyDown: preventDisallowedChars, onChange: React.useCallback((event) => {
                 setValue(event.target.value);
             }, []), style: inputStyle, ref: inputRef }),
-        showClear ? (React.createElement("div", { style: {
-                display: 'inline-block',
-                marginRight: 'var(--ab-space-1)',
-                marginLeft: 'var(--ab-space-1)',
-            }, onClick: (e) => {
+        showClear ? (React.createElement("div", { className: "twa:inline-block twa:mx-1", onClick: (e) => {
                 if (props.emptyValue != null) {
                     setValue(props.emptyValue);
                     e.stopPropagation();

package/src/agGrid/editors/AdaptableNumberEditor/index.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AdaptableNumberEditor = exports.AdaptableReactNumberEditor = exports.getStartValue = void 0;
+exports.AdaptableNumberEditor = exports.AdaptableReactNumberEditor = void 0;
+exports.getStartValue = getStartValue;
 const tslib_1 = require("tslib");
 const React = tslib_1.__importStar(require("react"));
 const renderWithAdaptableContext_1 = require("../../../View/renderWithAdaptableContext");
@@ -24,7 +25,6 @@ function getStartValue(params) {
     }
     return params.value;
 }
-exports.getStartValue = getStartValue;
 const defaultValueParser = ({ newValue, oldValue: _ }) => {
     return newValue;
 };

package/src/agGrid/editors/AdaptablePercentageEditor/InternalAdaptablePercentageEditor.js

@@ -61,11 +61,7 @@ exports.InternalAdaptablePercentageEditor = React.forwardRef(function InternalAd
         React.createElement(NumberInput_1.NumberInput, { type: props.type ?? 'number', className: "ab-PercentageEditor-Input", value: value, noArrows: true, autoFocus: true, onChange: React.useCallback((value) => {
                 setValue(value);
             }, []), style: inputStyle, ref: inputRef }),
-        showClear ? (React.createElement("div", { style: {
-                display: 'inline-block',
-                marginRight: 'var(--ab-space-1)',
-                marginLeft: 'var(--ab-space-1)',
-            }, onClick: (e) => {
+        showClear ? (React.createElement("div", { className: "twa:inline-block twa:mx-1", onClick: (e) => {
                 if (props.emptyValue != null) {
                     setValue(props.emptyValue);
                     e.stopPropagation();

package/src/agGrid/index.js

@@ -1,13 +1,11 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AdaptableLogger = exports.AdaptableNoCodeWizard = exports.AdaptableWizardView = void 0;
+const tslib_1 = require("tslib");
 const Adaptable_1 = require("./Adaptable");
 const AdaptableLogger_1 = require("./AdaptableLogger");
 var AdaptableWizardView_1 = require("../View/AdaptableWizardView");
-Object.defineProperty(exports, "AdaptableWizardView", { enumerable: true, get: function () { return __importDefault(AdaptableWizardView_1).default; } });
+Object.defineProperty(exports, "AdaptableWizardView", { enumerable: true, get: function () { return tslib_1.__importDefault(AdaptableWizardView_1).default; } });
 exports.default = Adaptable_1.Adaptable;
 exports.AdaptableNoCodeWizard = Adaptable_1.AdaptableNoCodeWizard;
 exports.AdaptableLogger = AdaptableLogger_1.AdaptableLogger;