@adaptabletools/adaptable 20.3.0 → 21.0.0-canary.0

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

@@ -8,7 +8,7 @@ import { ColumnScope } from '../../AdaptableState/Common/ColumnScope';
 import { AdaptablePredicateDef } from '../../AdaptableState/Common/AdaptablePredicate';
 import { AdaptableMessageType } from '../../AdaptableState/Common/AdaptableMessageType';
 import { IRowNode } from 'ag-grid-enterprise';
-import { RowDataChangedInfo } from '../../types';
+import { LayoutExtendedConfig, RowDataChangedInfo } from '../../types';
 export declare class AlertInternalApi extends ApiBase {
     getExpressionForAlertRule(alertRule: AlertRule): string | undefined;
     /**
@@ -20,18 +20,18 @@ export declare class AlertInternalApi extends ApiBase {
      * Retrieves all Alert Definitions in Alert State which are NOT Reactive (BooleanQuery)
      * @returns alert definitions
      */
-    getNonReactiveAlertDefinitions(): AlertDefinition[];
+    getNonReactiveAlertDefinitions(config?: LayoutExtendedConfig): AlertDefinition[];
     /**
      * Retrieves all active (non-suspended) Alert Definitions in Alert State which are NOT Reactive (BooleanQuery)
      * @returns alert definitions
      */
-    getActiveNonReactiveAlertDefinitions(): AlertDefinition[];
+    getActiveNonReactiveAlertDefinitions(config?: LayoutExtendedConfig): AlertDefinition[];
     /**
      *
      * Retrieves all Alert Definitions in Alert State which are reactive (ObservableQuery & AggregationQuery)
      * @returns alert definitions
      */
-    getReactiveAlertDefinitions(): AlertDefinition[];
+    getReactiveAlertDefinitions(config?: LayoutExtendedConfig): AlertDefinition[];
     /**
      *
      * Retrieves all active (non-suspended) Alert Definitions in Alert State which are reactive (ObservableQuery & AggregationQuery)
@@ -42,12 +42,12 @@ export declare class AlertInternalApi extends ApiBase {
      * Retrieves all Alert Definitions which prevent a Cell Edit
      * @returns alert definitions
      */
-    getAlertDefinitionsWithPreventEdit(): AlertDefinition[];
+    getAlertDefinitionsWithPreventEdit(config?: LayoutExtendedConfig): AlertDefinition[];
     /**
      * Retrieves all Alert Definitions which allow a Cell Edit
      *  @returns alert definitions
      */
-    getAlertDefinitionsWithAllowEdit(): AlertDefinition[];
+    getAlertDefinitionsWithAllowEdit(config?: LayoutExtendedConfig): AlertDefinition[];
     /**
      * Runs after a button in an Alert Form is clicked
      */

package/src/Api/Internal/AlertInternalApi.js

@@ -34,26 +34,26 @@ export class AlertInternalApi extends ApiBase {
      * Retrieves all Alert Definitions in Alert State which are NOT Reactive (BooleanQuery)
      * @returns alert definitions
      */
-    getNonReactiveAlertDefinitions() {
+    getNonReactiveAlertDefinitions(config) {
         return this.getAlertApi()
-            .getAlertDefinitions()
+            .getAlertDefinitions(config)
             .filter((alertDef) => !isReactiveQuery(alertDef.Rule));
     }
     /**
      * Retrieves all active (non-suspended) Alert Definitions in Alert State which are NOT Reactive (BooleanQuery)
      * @returns alert definitions
      */
-    getActiveNonReactiveAlertDefinitions() {
-        return this.getNonReactiveAlertDefinitions().filter((alertDef) => !alertDef.IsSuspended);
+    getActiveNonReactiveAlertDefinitions(config) {
+        return this.getNonReactiveAlertDefinitions(config).filter((alertDef) => !alertDef.IsSuspended);
     }
     /**
      *
      * Retrieves all Alert Definitions in Alert State which are reactive (ObservableQuery & AggregationQuery)
      * @returns alert definitions
      */
-    getReactiveAlertDefinitions() {
+    getReactiveAlertDefinitions(config) {
         return this.getAlertApi()
-            .getAlertDefinitions()
+            .getAlertDefinitions(config)
             .filter((alertDef) => isReactiveQuery(alertDef.Rule));
     }
     /**
@@ -68,15 +68,15 @@ export class AlertInternalApi extends ApiBase {
      * Retrieves all Alert Definitions which prevent a Cell Edit
      * @returns alert definitions
      */
-    getAlertDefinitionsWithPreventEdit() {
-        return this.getActiveNonReactiveAlertDefinitions().filter((a) => a.AlertProperties != null && a.AlertProperties.PreventEdit === true);
+    getAlertDefinitionsWithPreventEdit(config) {
+        return this.getActiveNonReactiveAlertDefinitions(config).filter((a) => a.AlertProperties != null && a.AlertProperties.PreventEdit === true);
     }
     /**
      * Retrieves all Alert Definitions which allow a Cell Edit
      *  @returns alert definitions
      */
-    getAlertDefinitionsWithAllowEdit() {
-        return this.getActiveNonReactiveAlertDefinitions().filter((a) => a.AlertProperties == null || a.AlertProperties.PreventEdit !== true);
+    getAlertDefinitionsWithAllowEdit(config) {
+        return this.getActiveNonReactiveAlertDefinitions(config).filter((a) => a.AlertProperties == null || a.AlertProperties.PreventEdit !== true);
     }
     /**
      * Runs after a button in an Alert Form is clicked

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

@@ -5,7 +5,9 @@ import { AdaptablePredicateDef } from '../../AdaptableState/Common/AdaptablePred
 import { ColumnFilter } from '../../AdaptableState/Common/ColumnFilter';
 import { GridCell } from '../../AdaptableState/Selection/GridCell';
 import { LayoutColumnFilterAction } from '../../Redux/ActionsReducers/LayoutRedux';
+import { InFilterValue } from '../../types';
 import { ApiBase } from '../Implementation/ApiBase';
+import { AdaptableFilterHandler } from '../../agGrid/AdaptableFilterHandler';
 export declare class ColumnFilterInternalApi extends ApiBase {
     /**
      * Returns Predicate Definition for given Column and Quick Filter shortcut
@@ -44,4 +46,15 @@ export declare class ColumnFilterInternalApi extends ApiBase {
     getPredicateDefShortcuts(predicateDef: AdaptablePredicateDef): string[];
     showQuickFilterDropdown(columnId: string): boolean;
     openColumnFilterPopup(columnId: string, popupProps?: any): void;
+    /**
+     * First we try to get the cached values from the FilterHandler
+     * Only if the FilterHandler is not available we fallback to the GridApi method
+     */
+    getColumnFilterValues(options: {
+        columnId: string;
+        currentSearchValue: string;
+    }): Promise<InFilterValue[]>;
+    shouldAutoApplyColumnFilter(columnId: string): boolean;
+    shouldCacheColumnFilterValues(columnId: string): boolean;
+    getAllAdaptableFilterHandlers(): AdaptableFilterHandler[];
 }

package/src/Api/Internal/ColumnFilterInternalApi.js

@@ -4,6 +4,7 @@ import ArrayExtensions, { areArraysEqual } from '../../Utilities/Extensions/Arra
 import StringExtensions from '../../Utilities/Extensions/StringExtensions';
 import { COLUMN_FILTER_WINDOW } from '../../View/Components/Popups/WindowPopups/windowFactory';
 import { ApiBase } from '../Implementation/ApiBase';
+import { AdaptableFilterHandler } from '../../agGrid/AdaptableFilterHandler';
 export class ColumnFilterInternalApi extends ApiBase {
     /**
      * Returns Predicate Definition for given Column and Quick Filter shortcut
@@ -164,7 +165,38 @@ export class ColumnFilterInternalApi extends ApiBase {
         if (ArrayExtensions.IsNullOrEmpty(oldFilters) && ArrayExtensions.IsNullOrEmpty(newFilters)) {
             return false;
         }
-        return ArrayExtensions.areArraysNotEqual(oldFilters, newFilters);
+        return !ArrayExtensions.areArraysEqualWithCustomComparator(oldFilters, newFilters, (filter1, filter2) => {
+            // Compare basic properties
+            if (filter1.ColumnId !== filter2.ColumnId) {
+                return false;
+            }
+            if ((filter1.PredicatesOperator || 'AND') !== (filter2.PredicatesOperator || 'AND')) {
+                return false;
+            }
+            if ((filter1.IsSuspended || false) !== (filter2.IsSuspended || false)) {
+                return false;
+            }
+            // Compare predicates (regardless of order)
+            return ArrayExtensions.areArraysEqualWithCustomComparator(filter1.Predicates, filter2.Predicates, (pred1, pred2) => {
+                if (pred1.PredicateId !== pred2.PredicateId) {
+                    return false;
+                }
+                // Compare inputs array (might be primitives or objects)
+                return ArrayExtensions.areArraysEqualWithCustomComparator(pred1.Inputs, pred2.Inputs, (input1, input2) => {
+                    if (input1 === input2) {
+                        return true;
+                    }
+                    if (typeof input1 !== typeof input2) {
+                        return false;
+                    }
+                    // For object inputs, use JSON comparison
+                    if (typeof input1 === 'object' && input1 !== null && input2 !== null) {
+                        return JSON.stringify(input1) === JSON.stringify(input2);
+                    }
+                    return input1 === input2;
+                });
+            });
+        });
     }
     getPredicateDefShortcuts(predicateDef) {
         const shortcuts = this.getFilterOptions().columnFilterOptions.quickFilterWildcards;
@@ -203,4 +235,64 @@ export class ColumnFilterInternalApi extends ApiBase {
             },
         });
     }
+    /**
+     * First we try to get the cached values from the FilterHandler
+     * Only if the FilterHandler is not available we fallback to the GridApi method
+     */
+    async getColumnFilterValues(options) {
+        const shouldUseCachedValues = this.shouldCacheColumnFilterValues(options.columnId);
+        if (!shouldUseCachedValues) {
+            return this.getGridApi().internalApi.getDistinctFilterDisplayValuesForColumn(options);
+        }
+        const columnFilterHandler = this.getAgGridApi().getColumnFilterHandler(options.columnId);
+        if (!columnFilterHandler) {
+            this.logWarn(`No ColumnFilterHandler found for columnId: ${options.columnId}!`);
+            return this.getGridApi().internalApi.getDistinctFilterDisplayValuesForColumn(options);
+        }
+        if (typeof columnFilterHandler.getFilterDisplayValues !== 'function') {
+            this.logWarn(`ColumnFilterHandler for columnId: ${options.columnId} does not have getFilterDisplayValues method!`);
+            return this.getGridApi().internalApi.getDistinctFilterDisplayValuesForColumn(options);
+        }
+        return columnFilterHandler.getFilterDisplayValues(options.currentSearchValue);
+    }
+    shouldAutoApplyColumnFilter(columnId) {
+        const autoApplyColumnFilterOpt = this.getOptionsApi().getFilterOptions().columnFilterOptions?.autoApplyColumnFilter;
+        if (typeof autoApplyColumnFilterOpt === 'boolean') {
+            return autoApplyColumnFilterOpt;
+        }
+        if (typeof autoApplyColumnFilterOpt === 'function') {
+            const column = this.getColumnApi().getColumnWithColumnId(columnId);
+            const context = {
+                column,
+                ...this.getAdaptableApi().internalApi.buildBaseContext(),
+            };
+            return autoApplyColumnFilterOpt(context);
+        }
+        // fallback, should never happen
+        return true;
+    }
+    shouldCacheColumnFilterValues(columnId) {
+        const cacheColumnFilterValuesOpt = this.getOptionsApi().getFilterOptions().columnFilterOptions?.cacheInFilterValues;
+        if (typeof cacheColumnFilterValuesOpt === 'boolean') {
+            return cacheColumnFilterValuesOpt;
+        }
+        if (typeof cacheColumnFilterValuesOpt === 'function') {
+            const column = this.getColumnApi().getColumnWithColumnId(columnId);
+            const context = {
+                column,
+                ...this.getAdaptableApi().internalApi.buildBaseContext(),
+            };
+            return cacheColumnFilterValuesOpt(context);
+        }
+        // fallback, should never happen
+        return true;
+    }
+    getAllAdaptableFilterHandlers() {
+        const allFilterableColumns = this.getColumnApi().getFilterableColumns();
+        const filterHandlers = allFilterableColumns
+            .map((column) => this.getAgGridApi().getColumnFilterHandler(column.columnId))
+            .filter(Boolean)
+            .filter((handler) => handler instanceof AdaptableFilterHandler);
+        return filterHandlers;
+    }
 }

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

@@ -2,7 +2,7 @@ import { ApiBase } from '../Implementation/ApiBase';
 import { ColDef, Column, HeaderValueGetterParams, IRowNode } from 'ag-grid-enterprise';
 import { CustomSort } from '../../AdaptableState/CustomSortState';
 import { ColumnValuesComparer } from '../../AdaptableOptions/CustomSortOptions';
-import { AdaptableColumn } from '../../types';
+import { AdaptableColumn, AdaptableColumnDataType } from '../../types';
 export declare function getAutoRowGroupColumnIdFor(columnId: string): string;
 export declare class ColumnInternalApi extends ApiBase {
     /**
@@ -36,4 +36,5 @@ export declare class ColumnInternalApi extends ApiBase {
     hasArrayDataType(column: AdaptableColumn): boolean;
     getQueryableColumnsForUIEditor(): AdaptableColumn[];
     isAlwaysHiddenColumn(columnIdentifier: string | ColDef): boolean;
+    getColumnDateTypes(): AdaptableColumnDataType[];
 }

package/src/Api/Internal/ColumnInternalApi.js

@@ -294,4 +294,8 @@ export class ColumnInternalApi extends ApiBase {
     isAlwaysHiddenColumn(columnIdentifier) {
         return this.getColumnApi().hasColumnType(columnIdentifier, HIDDEN_COLUMN_TYPE);
     }
+    getColumnDateTypes() {
+        // this is required because Adaptable uses 'date' type for all AG Grid date types: 'date', 'dateString'
+        return ['date', 'dateString'];
+    }
 }

package/src/Api/Internal/DashboardInternalApi.js

@@ -33,7 +33,7 @@ export class DashboardInternalApi extends ApiBase {
     getModuleToolbars() {
         const moduleService = this.getAdaptableInternalApi().getModuleService();
         return ALL_TOOLBARS.filter((moduleName) => {
-            return moduleService.isModuleAvailable(moduleName);
+            return moduleService.isAdapTableModulePresent(moduleName);
         }).map((moduleName) => {
             return {
                 id: moduleName,

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

@@ -1,4 +1,5 @@
 import { ApiBase } from '../Implementation/ApiBase';
 export declare class EntitlementInternalApi extends ApiBase {
     setModulesEntitlements(): void;
+    setModulesAgGridDepsInfos(): void;
 }

package/src/Api/Internal/EntitlementInternalApi.js

@@ -8,4 +8,12 @@ export class EntitlementInternalApi extends ApiBase {
             module.setModuleEntitlement();
         });
     }
+    setModulesAgGridDepsInfos() {
+        this.getAdaptableInternalApi()
+            .getModuleService()
+            .getModuleCollection()
+            .forEach((module) => {
+            module.setAgGridDepsInfo();
+        });
+    }
 }

package/src/Api/Internal/ExportInternalApi.js

@@ -380,7 +380,7 @@ export class ExportInternalApi extends ApiBase {
             };
             const gridParams = {
                 modules: this.getAdaptableApi()
-                    .internalApi.getAdaptableInstance()
+                    .internalApi.getAgGridModulesAdapter()
                     .getAgGridRegisteredModules(),
             };
             htmlDivElement.style.display = 'none';

package/src/Api/Internal/FlashingCellInternalApi.js

@@ -41,7 +41,7 @@ export class FlashingCellInternalApi extends ApiBase {
             ? toFlashingAlert(forPrimaryKey[columnId])
             : toFlashingAlert(forPrimaryKey[FLASHING_CELL_ROW_KEY]);
         if (adaptableFlashingCell?.flashingCellDefinition &&
-            !this.getLayoutApi().internalApi.isObjectAvailableInLayout(adaptableFlashingCell.flashingCellDefinition, 'FlashingCell', this.getLayoutApi().getCurrentLayout())) {
+            !this.getLayoutApi().internalApi.isObjectExtendedInLayout(adaptableFlashingCell.flashingCellDefinition, 'FlashingCell', this.getLayoutApi().getCurrentLayout())) {
             return;
         }
         return adaptableFlashingCell;

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

@@ -1,37 +1,34 @@
 import { HeaderValueGetterParams, IRowNode } from 'ag-grid-enterprise';
-import { AdaptableColumn, AdaptableFormat, AdaptablePredicateDef, ColumnScope, FormatColumn, FormatColumnTarget, StringFormatterOptions } from '../../types';
+import { AdaptableColumn, AdaptableFormat, AdaptablePredicateDef, ColumnScope, FormatColumn, FormatColumnConfig, FormatColumnTarget, StringFormatterOptions } from '../../types';
 import { ApiBase } from '../Implementation/ApiBase';
 export declare class FormatColumnInternalApi extends ApiBase {
     /**
      * Retrieves all Format Columns in Adaptable State with the `Style` property set
      * @returns format columns
      */
-    getAllFormatColumnWithStyle(): FormatColumn[];
+    getAllFormatColumnWithStyle(config?: FormatColumnConfig): FormatColumn[];
     /**
      * Retrieves all Format Columns in Adaptable State with the `Style` or the `CellAlignment` property set
      * @returns format columns
      */
-    getAllFormatColumnWithStyleAndCellAlignment(): FormatColumn[];
+    getAllFormatColumnWithStyleAndCellAlignment(config?: FormatColumnConfig): FormatColumn[];
     /**
      * Retrieves all Format Columns in Adaptable State with `DisplayFormat` property set
      * @returns format columns
      */
-    getAllFormatColumnWithDisplayFormat(): FormatColumn[];
+    getAllFormatColumnWithDisplayFormat(config?: FormatColumnConfig): FormatColumn[];
     /**
      * Retrieves all Format Columns in Adaptable State with `CellAlignment` property set
      * @returns format columns
      */
-    getAllFormatColumnWithCellAlignment(): FormatColumn[];
+    getAllFormatColumnWithCellAlignment(config?: FormatColumnConfig): FormatColumn[];
     /**
      * Get all FormatColumns which are defined for this column and have a custom AdaptableStyle
      * @param column
      * @param config
      * @returns list of FormatColumn
      */
-    getFormatColumnsWithStyleForColumn(column: AdaptableColumn, config: {
-        target: FormatColumnTarget;
-        includeSuspended?: boolean;
-    }): FormatColumn[];
+    getFormatColumnsWithStyleForColumn(column: AdaptableColumn, config: FormatColumnConfig): FormatColumn[];
     /**
      * Gets Format Column if any for given Column which includes Style element with ClassName
      * @param column The Column for which to retrieve the Format Column
@@ -124,8 +121,8 @@ export declare class FormatColumnInternalApi extends ApiBase {
      * Retrieves all Format Columns which have an Expression
      * @returns Format Columns with Expression
      */
-    getFormatColumnsWithExpression(): FormatColumn[];
-    getFormatColumnsDependentOnColumns(columnSet: Set<string>): FormatColumn[];
+    getFormatColumnsWithExpression(config?: FormatColumnConfig): FormatColumn[];
+    getFormatColumnsDependentOnColumns(columnSet: Set<string>, config?: FormatColumnConfig): FormatColumn[];
     /**
      * Retrieves the columns that need rerendering based on format column predicates.
      */

package/src/Api/Internal/FormatColumnInternalApi.js

@@ -36,36 +36,36 @@ export class FormatColumnInternalApi extends ApiBase {
      * Retrieves all Format Columns in Adaptable State with the `Style` property set
      * @returns format columns
      */
-    getAllFormatColumnWithStyle() {
+    getAllFormatColumnWithStyle(config) {
         return this.getFormatColumnApi()
-            .getFormatColumns()
+            .getFormatColumns(config)
             .filter((fc) => fc.Style);
     }
     /**
      * Retrieves all Format Columns in Adaptable State with the `Style` or the `CellAlignment` property set
      * @returns format columns
      */
-    getAllFormatColumnWithStyleAndCellAlignment() {
+    getAllFormatColumnWithStyleAndCellAlignment(config) {
         return this.getFormatColumnApi()
-            .getFormatColumns()
+            .getFormatColumns(config)
             .filter((fc) => fc.Style || fc.CellAlignment);
     }
     /**
      * Retrieves all Format Columns in Adaptable State with `DisplayFormat` property set
      * @returns format columns
      */
-    getAllFormatColumnWithDisplayFormat() {
+    getAllFormatColumnWithDisplayFormat(config) {
         return this.getFormatColumnApi()
-            .getFormatColumns()
+            .getFormatColumns(config)
             .filter((fc) => fc.DisplayFormat);
     }
     /**
      * Retrieves all Format Columns in Adaptable State with `CellAlignment` property set
      * @returns format columns
      */
-    getAllFormatColumnWithCellAlignment() {
+    getAllFormatColumnWithCellAlignment(config) {
         return this.getFormatColumnApi()
-            .getFormatColumns()
+            .getFormatColumns(config)
             .filter((fc) => fc.CellAlignment);
     }
     /**
@@ -189,7 +189,7 @@ export class FormatColumnInternalApi extends ApiBase {
             return true;
         }
         const agGridApi = this.getAdaptableApi().agGridApi;
-        const agGridColumn = agGridApi.isPivotMode()
+        const agGridColumn = this._adaptable.isInPivotMode()
             ? agGridApi.getPivotResultColumns().find((col) => col.getColId() === column.columnId)
             : agGridApi.getColumn(column.columnId);
         if (!agGridColumn) {
@@ -331,14 +331,14 @@ export class FormatColumnInternalApi extends ApiBase {
      * Retrieves all Format Columns which have an Expression
      * @returns Format Columns with Expression
      */
-    getFormatColumnsWithExpression() {
+    getFormatColumnsWithExpression(config) {
         return this.getFormatColumnApi()
-            .getFormatColumns()
+            .getFormatColumns(config)
             .filter((fc) => !!fc.Rule?.BooleanExpression);
     }
-    getFormatColumnsDependentOnColumns(columnSet) {
+    getFormatColumnsDependentOnColumns(columnSet, config) {
         return this.getFormatColumnApi()
-            .getFormatColumns()
+            .getFormatColumns(config)
             .filter((fc) => fc.Rule?.Predicates?.some((p) => columnSet.has(p.ColumnId)));
     }
     /**

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

@@ -1,11 +1,13 @@
-import { RowClassParams } from 'ag-grid-enterprise';
+import { IRowNode, RowClassParams } from 'ag-grid-enterprise';
 import { AdaptableColumn } from '../../AdaptableState/Common/AdaptableColumn';
 import { AdaptableMenuItem } from '../../AdaptableState/Common/Menu';
 import { SpecialColumnSettings } from '../../AdaptableState/Common/SpecialColumnSettings';
 import { GridCell } from '../../AdaptableState/Selection/GridCell';
 import { SelectedCellInfo } from '../../AdaptableState/Selection/SelectedCellInfo';
 import { SelectedRowInfo } from '../../AdaptableState/Selection/SelectedRowInfo';
+import { InFilterValue } from '../../types';
 import { ApiBase } from '../Implementation/ApiBase';
+import { EditColumnValueInfo } from '../../AdaptableOptions/EditOptions';
 export declare class GridInternalApi extends ApiBase {
     /**
      * Gets all distinct display values in the Column for given ColumnId
@@ -27,20 +29,13 @@ export declare class GridInternalApi extends ApiBase {
     getDistinctFilterDisplayValuesForColumn(options: {
         columnId: string;
         currentSearchValue: string;
-    }): Promise<{
-        value: any;
-        label: string;
-    }[]>;
+    }): Promise<InFilterValue[]>;
     getDistinctValuesForColumn(columnId: string): Promise<GridCell[]> | undefined;
-    getDistinctDisplayValuesForColumn(columnId: string): Promise<any[]> | undefined;
     getDistinctEditDisplayValuesForColumn(options: {
         columnId: string;
         gridCell: GridCell;
         currentSearchValue: string;
-    }): Promise<{
-        value: any;
-        label: string;
-    }[]> | undefined;
+    }): Promise<EditColumnValueInfo[]> | undefined;
     /**
      * Gets all distinct raw values in Column. Values are sorted.
      * @param columnId Column to check
@@ -51,6 +46,7 @@ export declare class GridInternalApi extends ApiBase {
      * @param columnId Column to check
      */
     getUnsortedDistinctRawValuesForColumn(columnId: string): any[];
+    getSortedRowNodesWithCurrentLayoutSortOrder(rowNodes?: IRowNode[]): IRowNode[];
     sortDistinctValues<T extends GridCell>(returnValues: T[], column: AdaptableColumn): T[];
     setColumns(columns: AdaptableColumn[]): void;
     setSelectedCells(selectedCellInfo: SelectedCellInfo): void;
@@ -72,4 +68,5 @@ export declare class GridInternalApi extends ApiBase {
      * DO NOT USE THIS METHOD DIRECTLY - use `GridApi.isCellEditable` instead
      */
     isCellEditableAccordingToEditOptions(gridCell: GridCell, defaultColDefinitionEditableValue: boolean): boolean | undefined;
+    isRowFilterable(rowNode: IRowNode): boolean;
 }

package/src/Api/Internal/GridInternalApi.js

@@ -1,6 +1,7 @@
 import { SortOrder } from '../../AdaptableState/Common/Enums';
 import * as InternalRedux from '../../Redux/ActionsReducers/InternalRedux';
-import ArrayExtensions from '../../Utilities/Extensions/ArrayExtensions';
+import { getDateComparatorForGridCell, getGenericComparatorForGridCell, getNumericComparatorForGridCell, sortCellValueArrayNumeric, sortCellValueArrayDates, sortCellValueArray, } from '../../Utilities/Extensions/ArrayExtensions';
+import { multisort } from '@infinite-table/infinite-react';
 import { convertAdaptableStyleToCSS } from '../../Utilities/Helpers/StyleHelper';
 import UIHelper from '../../View/UIHelper';
 import { ApiBase } from '../Implementation/ApiBase';
@@ -36,20 +37,13 @@ export class GridInternalApi extends ApiBase {
         if (abColumn == undefined) {
             return [];
         }
-        let gridCells = await this._adaptable.getDistinctFilterValuesForColumn({
+        const inFilterValues = await this._adaptable.getDistinctFilterValuesForColumn({
             column: abColumn,
             get currentSearchValue() {
                 return options.currentSearchValue;
             },
         });
-        gridCells = gridCells || [];
-        const valueOptions = gridCells.map((cv) => {
-            return {
-                label: cv.displayValue,
-                value: cv.normalisedValue,
-            };
-        });
-        return valueOptions;
+        return inFilterValues || [];
     }
     async getDistinctValuesForColumn(columnId) {
         const abColumn = this.getColumnApi().getColumnWithColumnId(columnId);
@@ -59,31 +53,19 @@ export class GridInternalApi extends ApiBase {
         const gridCells = await this._adaptable.getDistinctValuesForColumn(abColumn);
         return gridCells;
     }
-    async getDistinctDisplayValuesForColumn(columnId) {
-        const distinctValues = await this.getDistinctValuesForColumn(columnId);
-        return distinctValues.map((gc) => {
-            return gc.displayValue;
-        });
-    }
     async getDistinctEditDisplayValuesForColumn(options) {
         const abColumn = this.getColumnApi().getColumnWithColumnId(options.columnId);
         if (!abColumn) {
             return undefined;
         }
-        let gridCells = await this._adaptable.getDistinctEditValuesForColumn({
+        const valueOptions = await this._adaptable.getDistinctEditValuesForColumn({
             column: abColumn,
             gridCell: options.gridCell,
             get currentSearchValue() {
                 return options.currentSearchValue;
             },
         });
-        gridCells = gridCells || [];
-        return gridCells.map((gc) => {
-            return {
-                label: gc.displayValue,
-                value: gc.normalisedValue,
-            };
-        });
+        return valueOptions || [];
     }
     /**
      * Gets all distinct raw values in Column. Values are sorted.
@@ -109,6 +91,58 @@ export class GridInternalApi extends ApiBase {
         }
         return this._adaptable.getDistinctGridCellsForColumn(abColumn);
     }
+    getSortedRowNodesWithCurrentLayoutSortOrder(rowNodes) {
+        const currentLayout = this.getLayoutApi().getCurrentLayout();
+        const columnSorts = currentLayout.ColumnSorts || [];
+        const columnApi = this.getColumnApi();
+        const rowNodesMapToCells = new Map();
+        const allRowNodes = [];
+        // for each row node,let's create an object
+        // with only those gridcells that are needed - meaning
+        // for those column that are in the current sort
+        const rowNodeCallback = (node) => {
+            allRowNodes.push(node);
+            const rowNodeCells = {};
+            rowNodesMapToCells.set(node, rowNodeCells);
+            columnSorts.forEach((columnSort, i) => {
+                const { ColumnId } = columnSort;
+                const gridCell = this._adaptable.getGridCellFromRowNode(node, ColumnId);
+                rowNodeCells[ColumnId] = gridCell;
+            });
+        };
+        if (rowNodes) {
+            rowNodes.forEach(rowNodeCallback);
+        }
+        else {
+            this.getAgGridApi().forEachNode(rowNodeCallback);
+        }
+        if (!columnSorts.length) {
+            return allRowNodes;
+        }
+        const sortInfo = columnSorts.map((columnSort) => {
+            const { ColumnId } = columnSort;
+            // NOTE: the comparator we pass to multisort should always sort in ascending order
+            // that's why we pass SortOrder.Asc to the comparators
+            const comparator = columnApi.hasNumberDataType(ColumnId)
+                ? getNumericComparatorForGridCell(SortOrder.Asc)
+                : columnApi.hasDateDataType(ColumnId)
+                    ? getDateComparatorForGridCell(SortOrder.Asc)
+                    : getGenericComparatorForGridCell(SortOrder.Asc);
+            return {
+                // but here we pass the actual direction of the column sort
+                dir: columnSort.SortOrder === 'Asc' ? 1 : -1,
+                fn: (rowNodeA, rowNodeB) => {
+                    const gridCellA = rowNodesMapToCells.get(rowNodeA)?.[ColumnId];
+                    const gridCellB = rowNodesMapToCells.get(rowNodeB)?.[ColumnId];
+                    if (!gridCellA || !gridCellB) {
+                        return 0;
+                    }
+                    return comparator(gridCellA, gridCellB);
+                },
+            };
+        });
+        return multisort(sortInfo, allRowNodes);
+    }
     sortDistinctValues(returnValues, column) {
         // this does NOT into account Custom Sort - far too hard for now...
         let sortOrder = undefined;
@@ -123,13 +157,13 @@ export class GridInternalApi extends ApiBase {
         }
         if (sortOrder) {
             if (this.getColumnApi().hasNumberDataType(column?.columnId)) {
-                returnValues = ArrayExtensions.sortCellValueArrayNumeric(returnValues, sortOrder);
+                returnValues = sortCellValueArrayNumeric(returnValues, sortOrder);
             }
             else if (this.getColumnApi().hasDateDataType(column?.columnId)) {
-                returnValues = ArrayExtensions.sortCellValueArrayDates(returnValues, sortOrder);
+                returnValues = sortCellValueArrayDates(returnValues, sortOrder);
             }
             else {
-                returnValues = ArrayExtensions.sortCellValueArray(returnValues, sortOrder);
+                returnValues = sortCellValueArray(returnValues, sortOrder);
             }
         }
         return returnValues;
@@ -222,4 +256,19 @@ export class GridInternalApi extends ApiBase {
         }
         return undefined;
     }
+    isRowFilterable(rowNode) {
+        // first assess if the Row is filterable - if not, then return true so it appears in Grid
+        const isRowFilterable = this.getOptionsApi().getFilterOptions().isRowFilterable;
+        if (typeof isRowFilterable === 'function') {
+            const rowFilterableContext = {
+                ...this.getAdaptableApi().internalApi.buildBaseContext(),
+                rowNode,
+                data: rowNode.data,
+            };
+            if (!isRowFilterable(rowFilterableContext)) {
+                return false;
+            }
+        }
+        return true;
+    }
 }