@adaptabletools/adaptable 21.2.1 → 21.2.2

package/src/Utilities/Constants/DocumentationLinkConstants.d.ts

@@ -1,17 +1,18 @@
-export declare const HOST_URL_DOCS = "https://docs.adaptabletools.com";
-export declare const ExpressionEditorDocsLink = "https://docs.adaptabletools.com/guide/ui-expression-editor";
-export declare const BooleanQueryDocsLink = "https://docs.adaptabletools.com/guide/adaptable-ql-expression-standard";
-export declare const ScalarQueryDocsLink = "https://docs.adaptabletools.com/guide/adaptable-ql-expression-standard";
-export declare const ObservableQueryDocsLink = "https://docs.adaptabletools.com/guide/adaptable-ql-expression-observable";
-export declare const AggregatedBooleanQueryDocsLink = "https://docs.adaptabletools.com/guide/adaptable-ql-expression-aggregation";
-export declare const AggregatedScalarQueryDocsLink = "https://docs.adaptabletools.com/guide/adaptable-ql-expression-aggregation";
-export declare const CumulativeAggregatedScalarQueryDocsLink = "https://docs.adaptabletools.com/guide/adaptable-ql-expression-cumulative";
-export declare const QuantileAggregatedScalarQueryDocsLink = "https://docs.adaptabletools.com/guide/adaptable-ql-expression-quantile";
-export declare const PredicateDocsLink = "https://docs.adaptabletools.com/guide/adaptable-predicate";
-export declare const PrimaryKeyDocsLink = "https://docs.adaptabletools.com/guide/getting-started-primary-key";
-export declare const LicenseDocsLink = "https://docs.adaptabletools.com/guide/licensing";
-export declare const AdaptableOptionsDocsLink = "https://docs.adaptabletools.com/guide/reference-options-overview";
-export declare const AgGridModulesDocsLink = "https://docs.adaptabletools.com/guide/dev-guide-aggrid-modules-overview";
-export declare const AlertMessageDocsLink = "https://docs.adaptabletools.com/guide/handbook-alerting-message";
-export declare const FormatColumnPlaceholderDocsLink = "https://docs.adaptabletools.com/guide/handbook-column-formatting-display-format-placeholder";
-export declare const AgGridRequiredModulesDocsLink = "https://docs.adaptabletools.com/guide/dev-guide-aggrid-modules-overview#mandatory-modules";
+export declare const HOST_URL_ROOT = "https://www.adaptabletools.com";
+export declare const HOST_URL_DOCS = "https://www.adaptabletools.com/docs";
+export declare const ExpressionEditorDocsLink = "https://www.adaptabletools.com/docs/ui-expression-editor";
+export declare const BooleanQueryDocsLink = "https://www.adaptabletools.com/docs/adaptable-ql-expression-standard";
+export declare const ScalarQueryDocsLink = "https://www.adaptabletools.com/docs/adaptable-ql-expression-standard";
+export declare const ObservableQueryDocsLink = "https://www.adaptabletools.com/docs/adaptable-ql-expression-observable";
+export declare const AggregatedBooleanQueryDocsLink = "https://www.adaptabletools.com/docs/adaptable-ql-expression-aggregation";
+export declare const AggregatedScalarQueryDocsLink = "https://www.adaptabletools.com/docs/adaptable-ql-expression-aggregation";
+export declare const CumulativeAggregatedScalarQueryDocsLink = "https://www.adaptabletools.com/docs/adaptable-ql-expression-cumulative";
+export declare const QuantileAggregatedScalarQueryDocsLink = "https://www.adaptabletools.com/docs/adaptable-ql-expression-quantile";
+export declare const PredicateDocsLink = "https://www.adaptabletools.com/docs/adaptable-predicate";
+export declare const PrimaryKeyDocsLink = "https://www.adaptabletools.com/docs/getting-started-primary-key";
+export declare const LicenseDocsLink = "https://www.adaptabletools.com/buy/buying-adaptable-licensing";
+export declare const AdaptableOptionsDocsLink = "https://www.adaptabletools.com/docs/technical-reference-adaptable-options";
+export declare const AgGridModulesDocsLink = "https://www.adaptabletools.com/docs/dev-guide-aggrid-modules-overview";
+export declare const AlertMessageDocsLink = "https://www.adaptabletools.com/docs/handbook-alerting-message";
+export declare const FormatColumnPlaceholderDocsLink = "https://www.adaptabletools.com/docs/handbook-column-formatting-display-format-placeholder";
+export declare const AgGridRequiredModulesDocsLink = "https://www.adaptabletools.com/docs/dev-guide-aggrid-modules-overview#mandatory-modules";

package/src/Utilities/Constants/DocumentationLinkConstants.js

@@ -1,18 +1,19 @@
-export const HOST_URL_DOCS = 'https://docs.adaptabletools.com';
+export const HOST_URL_ROOT = 'https://www.adaptabletools.com';
+export const HOST_URL_DOCS = `${HOST_URL_ROOT}/docs`;
 //export const HOST_URL_DOCS = 'http://localhost:3000';
-export const ExpressionEditorDocsLink = `${HOST_URL_DOCS}/guide/ui-expression-editor`;
-export const BooleanQueryDocsLink = `${HOST_URL_DOCS}/guide/adaptable-ql-expression-standard`;
-export const ScalarQueryDocsLink = `${HOST_URL_DOCS}/guide/adaptable-ql-expression-standard`;
-export const ObservableQueryDocsLink = `${HOST_URL_DOCS}/guide/adaptable-ql-expression-observable`;
-export const AggregatedBooleanQueryDocsLink = `${HOST_URL_DOCS}/guide/adaptable-ql-expression-aggregation`;
-export const AggregatedScalarQueryDocsLink = `${HOST_URL_DOCS}/guide/adaptable-ql-expression-aggregation`;
-export const CumulativeAggregatedScalarQueryDocsLink = `${HOST_URL_DOCS}/guide/adaptable-ql-expression-cumulative`;
-export const QuantileAggregatedScalarQueryDocsLink = `${HOST_URL_DOCS}/guide/adaptable-ql-expression-quantile`;
-export const PredicateDocsLink = `${HOST_URL_DOCS}/guide/adaptable-predicate`;
-export const PrimaryKeyDocsLink = `${HOST_URL_DOCS}/guide/getting-started-primary-key`;
-export const LicenseDocsLink = `${HOST_URL_DOCS}/guide/licensing`;
-export const AdaptableOptionsDocsLink = `${HOST_URL_DOCS}/guide/reference-options-overview`;
-export const AgGridModulesDocsLink = `${HOST_URL_DOCS}/guide/dev-guide-aggrid-modules-overview`;
-export const AlertMessageDocsLink = `${HOST_URL_DOCS}/guide/handbook-alerting-message`;
-export const FormatColumnPlaceholderDocsLink = `${HOST_URL_DOCS}/guide/handbook-column-formatting-display-format-placeholder`;
-export const AgGridRequiredModulesDocsLink = `${HOST_URL_DOCS}/guide/dev-guide-aggrid-modules-overview#mandatory-modules`;
+export const ExpressionEditorDocsLink = `${HOST_URL_DOCS}/ui-expression-editor`;
+export const BooleanQueryDocsLink = `${HOST_URL_DOCS}/adaptable-ql-expression-standard`;
+export const ScalarQueryDocsLink = `${HOST_URL_DOCS}/adaptable-ql-expression-standard`;
+export const ObservableQueryDocsLink = `${HOST_URL_DOCS}/adaptable-ql-expression-observable`;
+export const AggregatedBooleanQueryDocsLink = `${HOST_URL_DOCS}/adaptable-ql-expression-aggregation`;
+export const AggregatedScalarQueryDocsLink = `${HOST_URL_DOCS}/adaptable-ql-expression-aggregation`;
+export const CumulativeAggregatedScalarQueryDocsLink = `${HOST_URL_DOCS}/adaptable-ql-expression-cumulative`;
+export const QuantileAggregatedScalarQueryDocsLink = `${HOST_URL_DOCS}/adaptable-ql-expression-quantile`;
+export const PredicateDocsLink = `${HOST_URL_DOCS}/adaptable-predicate`;
+export const PrimaryKeyDocsLink = `${HOST_URL_DOCS}/getting-started-primary-key`;
+export const LicenseDocsLink = `${HOST_URL_ROOT}/buy/buying-adaptable-licensing`;
+export const AdaptableOptionsDocsLink = `${HOST_URL_DOCS}/technical-reference-adaptable-options`;
+export const AgGridModulesDocsLink = `${HOST_URL_DOCS}/dev-guide-aggrid-modules-overview`;
+export const AlertMessageDocsLink = `${HOST_URL_DOCS}/handbook-alerting-message`;
+export const FormatColumnPlaceholderDocsLink = `${HOST_URL_DOCS}/handbook-column-formatting-display-format-placeholder`;
+export const AgGridRequiredModulesDocsLink = `${HOST_URL_DOCS}/dev-guide-aggrid-modules-overview#mandatory-modules`;

package/src/Utilities/Services/ModuleService.js

@@ -105,84 +105,83 @@ export class ModuleService {
     }
     getModuleDocumentationPageByModule(adaptableModule) {
         let url = `${HOST_URL_DOCS}/`;
-        let learnUrl = url + 'guide/';
         switch (adaptableModule) {
             case 'Alert':
-                return learnUrl + 'handbook-alerting';
+                return url + 'handbook-alerting';
             case 'BulkUpdate':
                 return url + 'handbook-editing-bulk-update';
             case 'CalculatedColumn':
-                return learnUrl + 'handbook-calculated-column';
+                return url + 'handbook-calculated-column';
             case 'CellSummary':
-                return learnUrl + 'handbook-summarising';
+                return url + 'handbook-summarising';
             case 'Charting':
-                return learnUrl + 'handbook-charts';
+                return url + 'handbook-charts';
             case 'ColumnFilter':
-                return learnUrl + 'handbook-column-filter';
+                return url + 'handbook-column-filter';
             case 'ColumnInfo':
-                return learnUrl + 'dev-guide-column-grid-column-info';
+                return url + 'dev-guide-column-grid-column-info';
             case 'Comment':
-                return learnUrl + 'handbook-comments';
+                return url + 'handbook-comments';
             case 'CustomSort':
-                return learnUrl + 'handbook-custom-sorting';
+                return url + 'handbook-custom-sorting';
             case 'Dashboard':
-                return learnUrl + 'ui-dashboard';
+                return url + 'ui-dashboard';
             case 'DataChangeHistory':
-                return learnUrl + 'handbook-monitoring-data-change-history';
+                return url + 'handbook-monitoring-data-change-history';
             case 'DataImport':
-                return learnUrl + 'handbook-importing';
+                return url + 'handbook-importing';
             case 'DataSet':
-                return learnUrl + 'handbook-data-sets';
+                return url + 'handbook-data-sets';
             case 'Export':
-                return learnUrl + 'handbook-exporting';
+                return url + 'handbook-exporting';
             case 'Fdc3':
-                return learnUrl + 'handbook-fdc3';
+                return url + 'handbook-fdc3';
             case 'FlashingCell':
-                return learnUrl + 'handbook-flashing-cell';
+                return url + 'handbook-flashing-cell';
             case 'FormatColumn':
-                return learnUrl + 'handbook-column-formatting';
+                return url + 'handbook-column-formatting';
             case 'FreeTextColumn':
-                return learnUrl + 'handbook-freetext-column';
+                return url + 'handbook-freetext-column';
             case 'GridFilter':
-                return learnUrl + 'handbook-grid-filter';
+                return url + 'handbook-grid-filter';
             case 'GridInfo':
-                return learnUrl + 'dev-guide-column-grid-column-info';
+                return url + 'dev-guide-column-grid-column-info';
             case 'Layout':
-                return learnUrl + 'handbook-layouts';
+                return url + 'handbook-layouts';
             case 'NamedQuery':
-                return learnUrl + 'handbook-named-queries';
+                return url + 'handbook-named-queries';
             case 'Note':
-                return learnUrl + 'handbook-notes';
+                return url + 'handbook-notes';
             case 'PlusMinus':
-                return learnUrl + 'handbook-editing-plus-minus';
+                return url + 'handbook-editing-plus-minus';
             case 'QuickSearch':
-                return learnUrl + 'handbook-quick-search';
+                return url + 'handbook-quick-search';
             case 'Schedule':
-                return learnUrl + 'handbook-scheduling';
+                return url + 'handbook-scheduling';
             case 'SettingsPanel':
-                return learnUrl + 'ui-settings-panel';
+                return url + 'ui-settings-panel';
             case 'Shortcut':
-                return learnUrl + 'handbook-editing-shortcut';
+                return url + 'handbook-editing-shortcut';
             case 'SmartEdit':
-                return learnUrl + 'handbook-editing-smart-edit';
+                return url + 'handbook-editing-smart-edit';
             case 'StateManagement':
-                return learnUrl + 'dev-guide-adaptable-state-management';
+                return url + 'dev-guide-adaptable-state-management';
             case 'StatusBar':
-                return learnUrl + 'ui-status-bar';
+                return url + 'ui-status-bar';
             case 'StyledColumn':
-                return learnUrl + 'handbook-styled-column-overview';
+                return url + 'handbook-styled-column-overview';
             case 'SystemStatus':
-                return learnUrl + 'handbook-system-status-message';
+                return url + 'handbook-system-status-message';
             case 'TeamSharing':
-                return learnUrl + 'handbook-team-sharing';
+                return url + 'handbook-team-sharing';
             case 'Theme':
-                return learnUrl + 'handbook-theming';
+                return url + 'handbook-theming';
             case 'ToolPanel':
-                return learnUrl + 'ui-tool-panel';
+                return url + 'ui-tool-panel';
             case 'IPushPull':
-                return learnUrl + 'integrations-ipushpull';
+                return url + 'integrations-ipushpull';
             case 'OpenFin':
-                return learnUrl + 'integrations-openfin';
+                return url + 'integrations-openfin';
             default:
                 return 'good';
         }

package/src/agGrid/AdaptableAgGrid.d.ts

@@ -149,9 +149,19 @@ export declare class AdaptableAgGrid implements IAdaptable {
     private normaliseToolPanelState;
     private getCurrentLayoutModel;
     silentUpdateCurrentLayoutModel(layoutModel?: TableLayoutModel | PivotLayoutModel): void;
+    /**
+     * 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?: {
         updateColumnFilterModel?: boolean;
-    }): void;
+    }): boolean;
+    /**
+     * 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.
+     */
+    private refreshInitialSortIfNeeded;
     showQuickFilter(): void;
     hideQuickFilter(): void;
     private normalizeAdaptableOptions;

package/src/agGrid/AdaptableAgGrid.js

@@ -102,6 +102,7 @@ import { AgGridModulesAdapter } from './AgGridModulesAdapter';
 import { getMarker } from '../devTools';
 import { DeepMap } from '@infinite-table/infinite-react';
 import { DateFormatter } from '../Utilities/Helpers/FormatHelper';
+import { clearPredicateDefMapMemo } from '../Api/Implementation/PredicateApiImpl';
 const LocalEventService_Prototype = LocalEventService.prototype;
 const LocalEventService_dispatchEvent = LocalEventService_Prototype.dispatchEvent;
 LocalEventService_Prototype.dispatchEvent = function (event) {
@@ -446,10 +447,14 @@ export 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
@@ -621,26 +626,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;
@@ -1764,14 +1810,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;
@@ -1814,7 +1867,7 @@ You need to define at least one Layout!`);
                 return _primaryKeyValue;
             },
             get isPivotCell() {
-                return _isPivotCell;
+                return getIsPivotCell();
             },
             get isRowGroupCell() {
                 if (_isRowGroupCell === undefined) {
@@ -3386,6 +3439,7 @@ You need to define at least one Layout!`);
         this.__prevLayoutForRefresh = undefined;
         this.layoutManager?.destroy();
         this.layoutManager = null;
+        clearPredicateDefMapMemo();
         const agGridApi = this.agGridAdapter?.getAgGridApi();
         if (agGridApi && !agGridApi.isDestroyed()) {
             agGridApi.removeEventListener('firstDataRendered', this.listenerFirstDataRendered);

package/src/agGrid/AdaptableFilterHandler.d.ts

@@ -8,6 +8,7 @@ export declare class AdaptableFilterHandler implements FilterHandler {
     readonly colId: string;
     private filterDisplayValuesResult;
     private previousFilterDisplayValuesResult;
+    private currentColumnFilters_MEMO;
     constructor(adaptableApi: AdaptableApi, columnSetup: ColumnSetupInfo);
     getCurrentColumnFilters(): ColumnFilter[];
     doesFilterPass(params: DoesFilterPassParams): boolean;

package/src/agGrid/AdaptableFilterHandler.js

@@ -1,9 +1,17 @@
 export class AdaptableFilterHandler {
     constructor(adaptableApi, columnSetup) {
         this.adaptableApi = adaptableApi;
+        this.currentColumnFilters_MEMO = new WeakMap();
         this.colId = columnSetup.colId;
     }
     getCurrentColumnFilters() {
+        // 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;
+        const memoizedColumnFilters = this.currentColumnFilters_MEMO.get(layoutColumnFilters);
+        if (memoizedColumnFilters) {
+            return memoizedColumnFilters;
+        }
         const columnFilters = this.adaptableApi.filterApi.columnFilterApi
             .getActiveColumnFilters()
             .filter((columnFilter) => this.adaptableApi.filterApi.columnFilterApi.isColumnFilterActive(columnFilter))
@@ -12,6 +20,7 @@ export class AdaptableFilterHandler {
             const shouldEvaluateFilterOnClient = this.adaptableApi.expressionApi.internalApi.shouldEvaluatePredicatesInAdaptableQL('ColumnFilter', columnFilter, columnFilter.Predicates);
             return shouldEvaluateFilterOnClient;
         });
+        this.currentColumnFilters_MEMO.set(layoutColumnFilters, columnFilters);
         return columnFilters;
     }
     doesFilterPass(params) {
@@ -23,11 +32,11 @@ export class AdaptableFilterHandler {
                 return true;
             }
             const columnFilters = this.getCurrentColumnFilters();
-            const anyFilterFailed = columnFilters.some((columnFilter) => {
-                const result = !this.adaptableApi.filterApi.columnFilterApi.internalApi.evaluateColumnFilter(columnFilter, rowNode);
-                return result;
+            // #column_filter_predicates_evaluation
+            const allFiltersMatched = columnFilters.every((columnFilter) => {
+                return this.adaptableApi.filterApi.columnFilterApi.internalApi.evaluateColumnFilter(columnFilter, rowNode);
             });
-            return anyFilterFailed ? false : true;
+            return allFiltersMatched;
         }
         catch (ex) {
             this.adaptableApi.consoleError(ex);
@@ -46,7 +55,7 @@ export class AdaptableFilterHandler {
         }
         return this.fetchFilterDisplayValues(options);
     }
-    fetchFilterDisplayValues(options) {
+    async fetchFilterDisplayValues(options) {
         return this.adaptableApi.gridApi.internalApi
             .getDistinctFilterDisplayValuesForColumn({
             columnId: this.colId,
@@ -88,5 +97,6 @@ export class AdaptableFilterHandler {
     destroy() {
         this.filterDisplayValuesResult = undefined;
         this.previousFilterDisplayValuesResult = undefined;
+        this.currentColumnFilters_MEMO = undefined;
     }
 }

package/src/agGrid/AdaptableLogger.d.ts

@@ -1,5 +1,8 @@
 import { AdaptableMessageType } from '../AdaptableState/Common/AdaptableMessageType';
 export declare const errorOnce: (message: string) => void;
+/**
+ * AdapTable's Logger
+ */
 export declare class AdaptableLogger {
     private adaptableId;
     private debugger;

package/src/agGrid/AdaptableLogger.js

@@ -11,6 +11,9 @@ export const errorOnce = (message) => {
     console.error(message);
     errorOnceFlags[message] = true;
 };
+/**
+ * AdapTable's Logger
+ */
 export class AdaptableLogger {
     // use static loggers whenever access to AdaptableLogger instance is not feasible
     static consoleErrorBase(message, ...optionalParams) {

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

@@ -15,6 +15,7 @@ const getColumnApiModule = () => ColumnApiModule;
 export 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) {
@@ -40,6 +41,7 @@ export class AgGridAdapter {
         this.DANGER_updateGridOptionsMonkeyPatcher = null;
         this.DANGER_doFiltersPassMonkeyPatcher = null;
         this.DANGER_isAggFilterPresentMonkeyPatcher = null;
+        this.activePivotColumnFilters_MEMO = null;
         this._adaptableInstance = null;
     }
     get adaptableOptions() {
@@ -51,6 +53,27 @@ export 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;
     }
@@ -151,21 +174,15 @@ export 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
                     }
                 }
             }
@@ -177,10 +194,7 @@ export 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/index.d.ts

@@ -2,5 +2,11 @@ import { Adaptable, AdaptableNoCodeWizard as ABWizard } from './Adaptable';
 import { AdaptableLogger as ABLogger } from './AdaptableLogger';
 export { default as AdaptableWizardView } from '../View/AdaptableWizardView';
 export default Adaptable;
+/**
+ * AdapTable's No Code Wizard
+ */
 export declare const AdaptableNoCodeWizard: typeof ABWizard;
+/**
+ * AdapTable's Logger
+ */
 export declare const AdaptableLogger: typeof ABLogger;

package/src/agGrid/index.js

@@ -4,5 +4,11 @@ AdaptableNoCodeWizard as ABWizard, } from './Adaptable';
 import { AdaptableLogger as ABLogger } from './AdaptableLogger';
 export { default as AdaptableWizardView } from '../View/AdaptableWizardView';
 export default Adaptable;
+/**
+ * AdapTable's No Code Wizard
+ */
 export const AdaptableNoCodeWizard = ABWizard;
+/**
+ * AdapTable's Logger
+ */
 export const AdaptableLogger = ABLogger;

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: 1768226502639 || Date.now(),
-    VERSION: "21.2.1" || '--current-version--',
+    PUBLISH_TIMESTAMP: 1769503255554 || Date.now(),
+    VERSION: "21.2.2" || '--current-version--',
 };

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

@@ -87,6 +87,12 @@ export declare class LayoutManager<DATA_TYPE = any> extends LMEmitter {
     applyPivotTotals(layout: PivotLayoutModel): void;
     applyColumnGroupCollapseExpandState(layout: PivotLayoutModel | TableLayoutModel): void;
     private withSuppressColumnAnimation;
+    private withSuppressRowAnimation;
+    /**
+     * Refreshes the sort order by refreshing the client side row model.
+     * This is useful when custom sort comparers are defined and the sort needs to be re-applied after filtering.
+     */
+    refreshSort(): void;
     private patchColDefType;
     private setupPivotTotals;
     private patchPivotAggregationTotal;

package/src/layout-manager/src/index.js

@@ -1630,6 +1630,26 @@ export class LayoutManager extends LMEmitter {
         }
         return res;
     }
+    withSuppressRowAnimation(fn) {
+        const animateRows = this.gridApi.getGridOption('animateRows');
+        if (animateRows) {
+            this.gridApi.setGridOption('animateRows', false);
+        }
+        const res = fn();
+        if (animateRows) {
+            this.gridApi.setGridOption('animateRows', true);
+        }
+        return res;
+    }
+    /**
+     * Refreshes the sort order by refreshing the client side row model.
+     * This is useful when custom sort comparers are defined and the sort needs to be re-applied after filtering.
+     */
+    refreshSort() {
+        this.withSuppressRowAnimation(() => {
+            this.gridApi.refreshClientSideRowModel('sort');
+        });
+    }
     patchColDefType(colDef, colTypes) {
         const originalTypes = colDef.type == undefined ? [] : Array.isArray(colDef.type) ? colDef.type : [colDef.type];
         const columnTypes = new Set(originalTypes);