@adaptabletools/adaptable-cjs 21.2.0 → 21.2.2-canary.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adaptabletools/adaptable-cjs",
-  "version": "21.2.0",
+  "version": "21.2.2-canary.0",
   "description": "Powerful data-agnostic HTML5 AG Grid extension which provides advanced, cutting-edge functionality to meet all DataGrid requirements",
   "keywords": [
     "web-components",

package/src/AdaptableState/Common/AdaptablePredicate.js

@@ -89,7 +89,14 @@ exports.SystemPredicateDefs = [
             if (column.columnId === GeneralConstants_1.AG_GRID_GROUPED_COLUMN) {
                 const { node, treeSelectionState } = context;
                 const groupValues = getGroupValuesForNode({ node, value });
-                if (!treeSelectionState) {
+                // for non-trees, this line is reached for every leaf-row
+                // so for 2 levels-deep, groupValues is an array of ['level1-value','level2-value','leaf-value']
+                // but for trees, the groupValues is first an array with only
+                // one value, the current branch root - and if we go via the treeSelectionState
+                // that root might have a leaf selected, but if we return true here
+                // ag grid would include all rows of that branch - which is not what we want
+                // so we want to enter the `if` block and use the startsWith check
+                if (column.isTreeColumn || !treeSelectionState) {
                     // in case we don't have treeSelectionState
                     // this is another possible implementation
                     // though it won't be as performant as using the treeSelectionState

package/src/Api/Implementation/PredicateApiImpl.d.ts

@@ -4,6 +4,7 @@ import { AdaptableColumnPredicate, AdaptablePredicate, AdaptablePredicateDef, Pr
 import { IAdaptable } from '../../AdaptableInterfaces/IAdaptable';
 import { PredicateInternalApi } from '../Internal/PredicateInternalApi';
 import { TreeSelectionState } from '@infinite-table/infinite-react';
+export declare const clearPredicateDefMapMemo: () => void;
 export declare const getTreeSelectionStateForPredicateInputs: (inputs: any[], cache?: WeakMap<any[], TreeSelectionState>) => TreeSelectionState<any>;
 export declare class PredicateApiImpl extends ApiBase implements PredicateApi {
     internalApi: PredicateInternalApi;

package/src/Api/Implementation/PredicateApiImpl.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PredicateApiImpl = exports.getTreeSelectionStateForPredicateInputs = void 0;
+exports.PredicateApiImpl = exports.getTreeSelectionStateForPredicateInputs = exports.clearPredicateDefMapMemo = void 0;
 const tslib_1 = require("tslib");
 const ApiBase_1 = require("./ApiBase");
 const ArrayExtensions_1 = tslib_1.__importDefault(require("../../Utilities/Extensions/ArrayExtensions"));
@@ -9,6 +9,11 @@ const PredicateInternalApi_1 = require("../Internal/PredicateInternalApi");
 const AdaptablePredicate_1 = require("../../AdaptableState/Common/AdaptablePredicate");
 const GeneralConstants_1 = require("../../Utilities/Constants/GeneralConstants");
 const infinite_react_1 = require("@infinite-table/infinite-react");
+const predicateDefMap_MEMO = new Map();
+const clearPredicateDefMapMemo = () => {
+    predicateDefMap_MEMO.clear();
+};
+exports.clearPredicateDefMapMemo = clearPredicateDefMapMemo;
 const treeSelectionStatesForPredicates = new WeakMap();
 const getTreeSelectionStateForPredicateInputs = (inputs, cache = treeSelectionStatesForPredicates) => {
     const treeSelectionState = cache.get(inputs);
@@ -141,7 +146,14 @@ class PredicateApiImpl extends ApiBase_1.ApiBase {
         if (!predicate) {
             return defaultReturn;
         }
-        const predicateDef = this.getPredicateDefById(predicate.PredicateId);
+        // memoization to avoid repeated lookups
+        // during filtering of large datasets
+        // see #column_filter_predicates_evaluation
+        let predicateDef = predicateDefMap_MEMO.get(predicate.PredicateId);
+        if (predicateDef === undefined) {
+            predicateDef = this.getPredicateDefById(predicate.PredicateId);
+            predicateDefMap_MEMO.set(predicate.PredicateId, predicateDef);
+        }
         if (predicateDef === undefined) {
             return defaultReturn;
         }
@@ -169,6 +181,9 @@ class PredicateApiImpl extends ApiBase_1.ApiBase {
         if (predicates === undefined || predicates === null || predicates?.length === 0) {
             return this.handlePredicate(undefined, params, defaultReturn);
         }
+        if (predicates.length === 1) {
+            return this.handlePredicate(predicates[0], params, defaultReturn);
+        }
         if (params.predicatesOperator && params.predicatesOperator === 'OR') {
             return predicates?.some((p) => this.handlePredicate(p, params, defaultReturn));
         }

package/src/Api/Internal/ColumnFilterInternalApi.js

@@ -101,6 +101,7 @@ class ColumnFilterInternalApi extends ApiBase_1.ApiBase {
             predicatesOperator: columnFilter.PredicatesOperator,
             ...this.getAdaptableInternalApi().buildBaseContext(),
         };
+        // #column_filter_predicates_evaluation
         return this.getPredicateApi().handlePredicates(columnFilter.Predicates, predicateDefHandlerContext, true);
     }
     /**

package/src/Api/Internal/LayoutInternalApi.d.ts

@@ -34,4 +34,5 @@ export declare class LayoutInternalApi extends ApiBase {
     }, type?: 'table' | 'pivot'): Layout;
     private getLayoutCreationDefaultProperties;
     cloneLayout(layoutToClone: Layout): Omit<Layout, 'Name'>;
+    getCurrentLayout_perfOptimized(): Layout | null;
 }

package/src/Api/Internal/LayoutInternalApi.js

@@ -190,5 +190,14 @@ class LayoutInternalApi extends ApiBase_1.ApiBase {
         delete result.Name;
         return result;
     }
+    getCurrentLayout_perfOptimized() {
+        // perf-optimized version of getCurrentLayout()
+        const layoutState = this.getAdaptableState().Layout;
+        const currentLayoutName = layoutState.CurrentLayout;
+        if (!currentLayoutName) {
+            return null;
+        }
+        return layoutState.Layouts.find((layout) => layout.Name === currentLayoutName);
+    }
 }
 exports.LayoutInternalApi = LayoutInternalApi;

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

@@ -106,6 +106,7 @@ 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 LocalEventService_Prototype = ag_grid_enterprise_1.LocalEventService.prototype;
 const LocalEventService_dispatchEvent = LocalEventService_Prototype.dispatchEvent;
 LocalEventService_Prototype.dispatchEvent = function (event) {
@@ -450,10 +451,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 +630,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;
@@ -1768,14 +1814,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 +1871,7 @@ You need to define at least one Layout!`);
                 return _primaryKeyValue;
             },
             get isPivotCell() {
-                return _isPivotCell;
+                return getIsPivotCell();
             },
             get isRowGroupCell() {
                 if (_isRowGroupCell === undefined) {
@@ -3390,6 +3443,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);

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

@@ -4,9 +4,17 @@ exports.AdaptableFilterHandler = void 0;
 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))
@@ -15,6 +23,7 @@ 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) {
@@ -26,11 +35,11 @@ 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);
@@ -49,7 +58,7 @@ class AdaptableFilterHandler {
         }
         return this.fetchFilterDisplayValues(options);
     }
-    fetchFilterDisplayValues(options) {
+    async fetchFilterDisplayValues(options) {
         return this.adaptableApi.gridApi.internalApi
             .getDistinctFilterDisplayValuesForColumn({
             columnId: this.colId,
@@ -91,6 +100,7 @@ class AdaptableFilterHandler {
     destroy() {
         this.filterDisplayValuesResult = undefined;
         this.previousFilterDisplayValuesResult = undefined;
+        this.currentColumnFilters_MEMO = undefined;
     }
 }
 exports.AdaptableFilterHandler = AdaptableFilterHandler;

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/env.js

@@ -2,6 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.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: 1767878413718 || Date.now(),
-    VERSION: "21.2.0" || '--current-version--',
+    PUBLISH_TIMESTAMP: 1768333338805 || Date.now(),
+    VERSION: "21.2.2-canary.0" || '--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

@@ -1633,6 +1633,26 @@ class LayoutManager extends LMEmitter_1.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);