@adaptabletools/adaptable 18.1.0-canary.0 → 18.1.0-canary.1

package/src/AdaptableInterfaces/IAdaptable.d.ts

@@ -44,11 +44,10 @@ export interface AgGridConfig {
      */
     modules: Module[];
 }
-export interface DistinctValuesParams {
+export interface DistinctColumnValuesParams {
     visibleRowsOnly?: boolean;
     skipRowNode?: IRowNode;
     permittedValues?: any[];
-    addBlankValue?: boolean;
 }
 export type AdaptableVariant = 'vanilla' | 'react' | 'angular';
 /**
@@ -172,13 +171,13 @@ export interface IAdaptable {
     }>;
     deleteRows(dataRows: any[], dataUpdateConfig?: DataUpdateConfig): Promise<IRowNode[]>;
     getPrimaryKeyValueFromRowNode(rowNode: IRowNode, gridApi?: GridApi): any;
-    getDistinctValuesForColumn(column: AdaptableColumn, distinctValuesParams: DistinctValuesParams): GridCell[];
+    getDistinctValuesForColumn(column: AdaptableColumn, distinctValuesParams: DistinctColumnValuesParams): GridCell[];
     getGridCellFromRowNode(rowNode: IRowNode, columnId: string): GridCell | undefined;
     getRawValueFromRowNode(rowNode: IRowNode, columnId: string): any;
     getDisplayValueFromRowNode(rowNode: IRowNode, columnId: string): string | undefined;
     getDisplayValueFromRawValue(rowNode: IRowNode, columnId: string, rawValue: any): string | undefined;
     getNormalisedValueFromRawValue(rawValue: any, column: AdaptableColumn): string | number | boolean | Date | unknown;
-    getGridCellsForColumn(columnId: string, includeBlanks?: boolean): GridCell[] | undefined;
+    getGridCellsForColumn(columnId: string, includeBlanks?: boolean, onlyVisibleRows?: boolean): GridCell[] | undefined;
     getRowNodesForPrimaryKeys(primaryKeyValues: any[]): IRowNode[];
     getRowNodeForPrimaryKey(primaryKeyValue: any): IRowNode;
     getRowNodeByIndex(index: number): IRowNode;
@@ -255,6 +254,7 @@ export interface IAdaptable {
     getAgGridContainerElement(): HTMLElement | null;
     updateColumnModelAndRefreshGrid(config?: {
         skipColDefsRefresh?: boolean;
+        preemptiveColumnStateRefresh?: boolean;
     }): void;
     getAgGridColumnForColumnId(columnId: string): Column;
     getMinMaxCachedValueForColumn(column: AdaptableColumn, minMax: 'min' | 'max'): number | undefined;

package/src/AdaptableOptions/ColumnFilterOptions.d.ts

@@ -112,12 +112,12 @@ export interface ColumnFilterOptions<TData = any> {
      */
     showDatePicker?: boolean;
     /**
-     * Override column filter, return false to prevent filtering on a row
+     * Configure whether some Rows will not be evaluated when Column Filtering
      *
      * @param context
      * @returns boolean
      */
-    isRowFilterable?: (context: ColumnFilterIsRowFiltrableContext) => boolean;
+    isRowFilterable?: (context: IsRowFilterableContext) => boolean;
 }
 /**
  * Options for managing the Filter Bar (aka Quick Filter)
@@ -211,27 +211,20 @@ export interface ValuesFilterOptions<TData = any> {
      */
     filterValuesUsingTime?: boolean;
     /**
-     * Display only currently filtered distinct values in Filter controls
+     * Display only currently filtered values in Filter controls
      *
      * @defaultValue false
      * @gridInfoItem
      * @noCodeItem
      */
-    showDistinctFilteredValuesOnly?: boolean;
+    showCurrentlyFilteredValuesOnly?: boolean;
     /**
      * Show the count of each distinct item for given column in the Values (IN) Filter
      * @defaultValue  false
      * @gridInfoItem
      * @noCodeItem
      */
-    showValuesCount?: (columFilterContext: ColumnFilterContext<TData>) => boolean;
-    /**
-     * Includes a [BLANKS] entry in Values filter
-     * @defaultValue  false
-     * @gridInfoItem
-     * @noCodeItem
-     */
-    includeBlankFilterValues?: boolean;
+    showValuesCount?: boolean | ((columFilterContext: ColumnFilterContext<TData>) => boolean);
     /**
      * Whether column values in filter dropdown should apply column's current Sort Order for the column
      *
@@ -248,18 +241,9 @@ export interface ValuesFilterOptions<TData = any> {
      */
     valuesFilterTrigger?: 'mouseenter' | 'click';
     /**
-     * Adds predicates to values filter.
-     * The predicates should not take inputs, good predicates can be: 'BLANK', 'NOT_BLANK', 'TODAY'
-     */
-    predicates?: ColumnValuesFilterPredicate[] | ((context: ColumnFilterPredicateContext) => ColumnValuesFilterPredicate[]);
-    /**
-     * Where shoudld predicates be displayed in the values filter.
+     * Options for including (Non Input) Predicates in Values Filter
      */
-    predicatesPosition?: 'Start' | 'End';
-}
-export type ColumnValuesFilterPredicate = TypeHint<string, SystemFilterPredicateIds>;
-export interface ColumnFilterPredicateContext extends BaseContext {
-    column: AdaptableColumn;
+    valuesFilterPredicateOptions?: ValuesFilterPredicateOptions;
 }
 /**
  * Context provided when Column Filtering
@@ -270,7 +254,38 @@ export interface ColumnFilterContext<TData = any> extends BaseContext {
      */
     column: AdaptableColumn<TData>;
 }
-export interface ColumnFilterIsRowFiltrableContext<TData = any> extends BaseContext {
+/**
+ * Context used for setting whether a Row can be Column Filtered
+ */
+export interface IsRowFilterableContext<TData = any> extends BaseContext {
     rowNode: IRowNode;
     data: TData;
 }
+/**
+ * Options for including Predicates in Values Filter
+ */
+export interface ValuesFilterPredicateOptions<TData = any> {
+    /**
+     * Predicates to add to Values Filter: should NOT take inputs (ie. use 'BLANK', 'NOT_BLANK', 'TODAY')
+     */
+    predicates: ColumnValuesFilterPredicate[] | ((context: ColumnFilterContext) => ColumnValuesFilterPredicate[]);
+    /**
+     * Where Predicates are displayed in Values Filter
+     * @defaultValue 'Start'
+     */
+    predicatesPosition?: 'Start' | 'End';
+}
+/**
+ * Context provided when Column Filtering
+ */
+export interface ValuesFilterPredicateContext<TData = any> extends BaseContext {
+    /**
+     * Column being filtered
+     */
+    column: AdaptableColumn<TData>;
+    /**
+     * Predicate being evaluated
+     */
+    predicate: ColumnValuesFilterPredicate;
+}
+export type ColumnValuesFilterPredicate = TypeHint<string, SystemFilterPredicateIds>;

package/src/Api/ColumnApi.d.ts

@@ -290,6 +290,11 @@ export interface ColumnApi {
      * Sets the Column Definitions for the Grid
      */
     setColumnDefinitions(columnDefinitions: (ColDef | ColGroupDef)[]): void;
+    /**
+     * Returns all the distinct display values in a given Column
+     * @param columnId Column to Check
+     */
+    getDistinctDisplayValuesForColumn(columnId: string): any[];
 }
 /**
  * Configuration of an AG Grid Column, used for runtime updating of ColDefs

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

@@ -72,4 +72,5 @@ export declare class ColumnApiImpl extends ApiBase implements ColumnApi {
     updateColumnConfiguration(columnConfig: ColumnConfig): void;
     updateColumnConfigurations(columnConfigs: ColumnConfig[]): void;
     setColumnDefinitions(columnDefinitions: (ColDef | ColGroupDef)[]): void;
+    getDistinctDisplayValuesForColumn(columnId: string): any[];
 }

package/src/Api/Implementation/ColumnApiImpl.js

@@ -393,4 +393,7 @@ export class ColumnApiImpl extends ApiBase {
         const agGridApi = this.adaptable.agGridAdapter.getAgGridApi();
         agGridApi.setGridOption('columnDefs', columnDefinitions);
     }
+    getDistinctDisplayValuesForColumn(columnId) {
+        return this.getAdaptableApi().gridApi.internalApi.getDistinctDisplayValuesForColumn(columnId);
+    }
 }

package/src/Api/Implementation/ConfigApiImpl.js

@@ -137,7 +137,9 @@ export class ConfigApiImpl extends ApiBase {
                     });
                     promise
                         .then(() => {
-                        this.adaptable.updateColumnModelAndRefreshGrid({ skipColDefsRefresh: true });
+                        this.adaptable.updateColumnModelAndRefreshGrid({
+                            preemptiveColumnStateRefresh: true,
+                        });
                         this.adaptable.setLayout();
                     })
                         .then(() => {

package/src/Api/Internal/ColumnFilterInternalApi.js

@@ -207,16 +207,16 @@ export class ColumnFilterInternalApi extends ApiBase {
         }
     }
     getValuesFitlerPredicateIds(column) {
-        var _a;
-        const valuesFilterOptions = (_a = this.getOptions().columnFilterOptions) === null || _a === void 0 ? void 0 : _a.valuesFilterOptions;
+        var _a, _b;
+        const valuesFilterPredicateOptions = (_b = (_a = this.getOptions().columnFilterOptions) === null || _a === void 0 ? void 0 : _a.valuesFilterOptions) === null || _b === void 0 ? void 0 : _b.valuesFilterPredicateOptions;
         const availablePredicates = this.getPredicateApi().getPredicateDefsByModuleScope('columnFilter');
         let predicateIds = [];
-        if (typeof (valuesFilterOptions === null || valuesFilterOptions === void 0 ? void 0 : valuesFilterOptions.predicates) === 'function') {
+        if (typeof (valuesFilterPredicateOptions === null || valuesFilterPredicateOptions === void 0 ? void 0 : valuesFilterPredicateOptions.predicates) === 'function') {
             const columnFilterContext = Object.assign(Object.assign({}, this.getAdaptableApi().internalApi.buildBaseContext()), { column: column });
-            predicateIds = valuesFilterOptions.predicates(columnFilterContext);
+            predicateIds = valuesFilterPredicateOptions.predicates(columnFilterContext);
         }
-        else if (Array.isArray(valuesFilterOptions === null || valuesFilterOptions === void 0 ? void 0 : valuesFilterOptions.predicates)) {
-            predicateIds = valuesFilterOptions.predicates;
+        else if (Array.isArray(valuesFilterPredicateOptions === null || valuesFilterPredicateOptions === void 0 ? void 0 : valuesFilterPredicateOptions.predicates)) {
+            predicateIds = valuesFilterPredicateOptions.predicates;
         }
         return predicateIds.filter((predicateId) => {
             const predicate = availablePredicates.find((p) => p.id === predicateId);

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

@@ -1,16 +1,16 @@
-import { ApiBase } from '../Implementation/ApiBase';
-import { CellDataChangedInfo } from '../../PredefinedConfig/Common/CellDataChangedInfo';
 import { IRowNode, RowClassParams } from '@ag-grid-community/core';
-import { GridDataChangeTrigger } from '../Events/GridDataChanged';
-import { GridCell } from '../../PredefinedConfig/Selection/GridCell';
+import { DistinctColumnValuesParams } from '../../AdaptableInterfaces/IAdaptable';
+import { EditLookUpPermittedValues } from '../../AdaptableOptions/UserInterfaceOptions';
 import { AdaptableColumn, AdaptableColumnDataType } from '../../PredefinedConfig/Common/AdaptableColumn';
-import { SelectedCellInfo } from '../../PredefinedConfig/Selection/SelectedCellInfo';
-import { SelectedRowInfo } from '../../PredefinedConfig/Selection/SelectedRowInfo';
+import { CellDataChangedInfo } from '../../PredefinedConfig/Common/CellDataChangedInfo';
 import { AdaptableMenuItem } from '../../PredefinedConfig/Common/Menu';
-import { EditLookUpPermittedValues } from '../../AdaptableOptions/UserInterfaceOptions';
-import { DistinctValuesParams } from '../../AdaptableInterfaces/IAdaptable';
-import { AdaptableColumnType } from '../../PredefinedConfig/Common/Types';
 import { SpecialColumnSettings } from '../../PredefinedConfig/Common/SpecialColumnSettings';
+import { AdaptableColumnType } from '../../PredefinedConfig/Common/Types';
+import { GridCell } from '../../PredefinedConfig/Selection/GridCell';
+import { SelectedCellInfo } from '../../PredefinedConfig/Selection/SelectedCellInfo';
+import { SelectedRowInfo } from '../../PredefinedConfig/Selection/SelectedRowInfo';
+import { GridDataChangeTrigger } from '../Events/GridDataChanged';
+import { ApiBase } from '../Implementation/ApiBase';
 export declare class GridInternalApi extends ApiBase {
     /**
      * Fires Grid Sorted Event
@@ -25,7 +25,7 @@ export declare class GridInternalApi extends ApiBase {
      */
     fireGridDataChangedEvent(dataRows: any[], rowNodes: IRowNode[], rowTrigger: GridDataChangeTrigger): void;
     /**
-     * Gets all distinct display values in the Column with the given ColumnId
+     * Gets all distinct display values in the Column for given ColumnId
      * @param columnId Column to check
      */
     getDistinctDisplayValuesForColumn(columnId: string): any[];
@@ -33,6 +33,11 @@ export declare class GridInternalApi extends ApiBase {
      * Gets all distinct Filter values for the Column with the given ColumnId
      * used for Floating Filter and Column Header filter
      * either returns a list of values or al ist a list of values with count
+     *
+     * This is a general method, and it is used in:
+     * - Column Filters
+     * - Query Builder
+     *
      * @param columnId Column to check
      * @param columnFilter Current applied filter
      */
@@ -43,7 +48,18 @@ export declare class GridInternalApi extends ApiBase {
         }[];
         suppressClientSideFilter: boolean;
     }>;
-    getDistinctFilterListValuesForColumn(column: AdaptableColumn, filter: string, distinctValuesParams: DistinctValuesParams): Promise<{
+    private shouldShowValuesCount;
+    getDistinctFilterDisplayValuesForColumnForFiltersUI(columnId: string, filter: string, showFilteredRowsOnly: boolean): Promise<{
+        values: {
+            value: any;
+            label: string;
+        }[];
+        suppressClientSideFilter: boolean;
+    }>;
+    private addPredicateValues;
+    private isPredicateInVisibleCellValues;
+    private getPredicateOccurance;
+    getDistinctFilterListValuesForColumn(column: AdaptableColumn, filter: string, distinctValuesParams: DistinctColumnValuesParams): Promise<{
         suppressClientSideFilter?: boolean;
         gridCells: GridCell[];
     }>;
@@ -52,14 +68,14 @@ export declare class GridInternalApi extends ApiBase {
      * @param columnId Column to check
      */
     getDistinctCustomSortDisplayValuesForColumn(columnId: string): Promise<any[]>;
-    getDistinctCustomSortValuesForColumn(column: AdaptableColumn, distinctValuesParams: DistinctValuesParams): Promise<GridCell<any>[]>;
+    getDistinctCustomSortValuesForColumn(column: AdaptableColumn, distinctValuesParams: DistinctColumnValuesParams): Promise<GridCell<any>[]>;
     /**
      * Gets all distinct Bulk Update values for the Column with the given ColumnId
      * @param columnId Column to check
      * @param selectedGridCells Selected grid cells
      */
     getDistinctBulkUpdateDisplayValuesForColumn(columnId: string, selectedGridCells: GridCell[]): Promise<any[]>;
-    getDistinctBulkUpdateValuesForColumn(column: AdaptableColumn, selectedGridCells: GridCell[], distinctValuesParams: DistinctValuesParams): Promise<GridCell<any>[]>;
+    getDistinctBulkUpdateValuesForColumn(column: AdaptableColumn, selectedGridCells: GridCell[], distinctValuesParams: DistinctColumnValuesParams): Promise<GridCell<any>[]>;
     /**
      * Gets all distinct visible (after current filters are applied) display values in the Column with the given ColumnId
      * @param columnId Column to check

package/src/Api/Internal/GridInternalApi.js

@@ -1,12 +1,11 @@
-import { ApiBase } from '../Implementation/ApiBase';
 import { SortOrder } from '../../PredefinedConfig/Common/Enums';
-import ArrayExtensions from '../../Utilities/Extensions/ArrayExtensions';
 import * as GridRedux from '../../Redux/ActionsReducers/GridRedux';
+import ArrayExtensions from '../../Utilities/Extensions/ArrayExtensions';
 import NumberExtensions from '../../Utilities/Extensions/NumberExtensions';
 import { convertAdaptableStyleToCSS } from '../../Utilities/Helpers/StyleHelper';
-import UIHelper from '../../View/UIHelper';
 import { createBaseContext } from '../../Utilities/ObjectFactory';
-import { BLANK_DISTINCT_COLUMN_VALUE } from '../../Utilities/Constants/GeneralConstants';
+import UIHelper from '../../View/UIHelper';
+import { ApiBase } from '../Implementation/ApiBase';
 export class GridInternalApi extends ApiBase {
     /**
      * Fires Grid Sorted Event
@@ -41,7 +40,7 @@ export class GridInternalApi extends ApiBase {
         }
     }
     /**
-     * Gets all distinct display values in the Column with the given ColumnId
+     * Gets all distinct display values in the Column for given ColumnId
      * @param columnId Column to check
      */
     getDistinctDisplayValuesForColumn(columnId) {
@@ -61,11 +60,15 @@ export class GridInternalApi extends ApiBase {
      * Gets all distinct Filter values for the Column with the given ColumnId
      * used for Floating Filter and Column Header filter
      * either returns a list of values or al ist a list of values with count
+     *
+     * This is a general method, and it is used in:
+     * - Column Filters
+     * - Query Builder
+     *
      * @param columnId Column to check
      * @param columnFilter Current applied filter
      */
     async getDistinctFilterDisplayValuesForColumn(columnId, filter, showFilteredRowsOnly) {
-        var _a, _b;
         const abColumn = this.getColumnApi().getColumnWithColumnId(columnId);
         if (abColumn == undefined) {
             return {
@@ -73,53 +76,140 @@ export class GridInternalApi extends ApiBase {
                 suppressClientSideFilter: false,
             };
         }
-        const addBlankValue = this.getColumnFilterOptions().valuesFilterOptions.includeBlankFilterValues;
         const distinctValuesParams = {
             visibleRowsOnly: showFilteredRowsOnly,
-            addBlankValue: addBlankValue,
         };
         const { gridCells, suppressClientSideFilter } = await this.getDistinctFilterListValuesForColumn(abColumn, filter, distinctValuesParams);
         const sortedDistinctValues = this.sortDistinctValues(gridCells, abColumn);
-        let shouldShowValuesCount = false;
-        const showValuesCountFunction = this.getColumnFilterOptions().valuesFilterOptions.showValuesCount;
-        if (showValuesCountFunction) {
-            const columnFilterContext = Object.assign({ column: abColumn }, this.getAdaptableApi().internalApi.buildBaseContext());
-            shouldShowValuesCount = showValuesCountFunction(columnFilterContext);
-        }
+        const shouldShowValuesCount = this.shouldShowValuesCount(abColumn);
+        let valueOptions = [];
         if (shouldShowValuesCount) {
-            const allColumnDisplayValues = addBlankValue
-                ? (_a = this.adaptable.getGridCellsForColumn(columnId, true)) === null || _a === void 0 ? void 0 : _a.map((gc) => {
-                    var _a;
-                    return (_a = gc.displayValue) !== null && _a !== void 0 ? _a : BLANK_DISTINCT_COLUMN_VALUE;
-                })
-                : (_b = this.adaptable.getGridCellsForColumn(columnId)) === null || _b === void 0 ? void 0 : _b.map((gc) => {
-                    return gc.displayValue;
-                });
-            const newsortedDistinctValues = addBlankValue
-                ? sortedDistinctValues
-                : sortedDistinctValues.filter((gc) => gc.displayValue !== undefined);
-            return {
-                values: newsortedDistinctValues.map((cv) => {
-                    const label = cv.displayValue +
-                        NumberExtensions.WrapInParentheses(ArrayExtensions.getOccurrence(allColumnDisplayValues, cv.displayValue));
-                    return {
-                        label: label,
-                        value: cv.normalisedValue,
-                    };
-                }),
-                suppressClientSideFilter,
-            };
+            const allGridCells = this.adaptable.getGridCellsForColumn(columnId);
+            const allGridValues = allGridCells.map((gc) => gc.displayValue);
+            const newsortedDistinctValues = sortedDistinctValues.filter((gc) => gc.displayValue != undefined && gc.displayValue != '' && gc.displayValue != null);
+            valueOptions = newsortedDistinctValues.map((cv) => {
+                const label = cv.displayValue +
+                    NumberExtensions.WrapInParentheses(ArrayExtensions.getOccurrence(allGridValues, cv.displayValue));
+                return {
+                    label: label,
+                    value: cv.normalisedValue,
+                };
+            });
         }
-        return {
-            values: sortedDistinctValues.map((cv) => {
+        else {
+            valueOptions = sortedDistinctValues.map((cv) => {
                 return {
                     label: cv.displayValue,
                     value: cv.normalisedValue,
                 };
-            }),
+            });
+        }
+        return {
+            values: valueOptions,
             suppressClientSideFilter,
         };
     }
+    shouldShowValuesCount(column) {
+        const showValuesCount = this.getColumnFilterOptions().valuesFilterOptions.showValuesCount;
+        let shouldShowValuesCount = false;
+        if (showValuesCount) {
+            if (typeof showValuesCount === 'function') {
+                const columnFilterContext = Object.assign({ column }, this.getAdaptableApi().internalApi.buildBaseContext());
+                shouldShowValuesCount = showValuesCount(columnFilterContext);
+            }
+            else {
+                shouldShowValuesCount = showValuesCount;
+            }
+        }
+        return shouldShowValuesCount;
+    }
+    async getDistinctFilterDisplayValuesForColumnForFiltersUI(columnId, filter, showFilteredRowsOnly) {
+        const abColumn = this.getColumnApi().getColumnWithColumnId(columnId);
+        if (!abColumn) {
+            return {
+                values: [],
+                suppressClientSideFilter: false,
+            };
+        }
+        const shouldShowValuesCount = this.shouldShowValuesCount(abColumn);
+        const valueOptions = await this.getDistinctFilterDisplayValuesForColumn(columnId, filter, showFilteredRowsOnly);
+        this.addPredicateValues({
+            valueOptions: valueOptions.values,
+            column: abColumn,
+            shouldShowValuesCount,
+            visibleRowsOnly: showFilteredRowsOnly,
+        });
+        return valueOptions;
+    }
+    addPredicateValues(params) {
+        var _a, _b, _c, _d;
+        const { valueOptions, column, shouldShowValuesCount, visibleRowsOnly } = params;
+        const allGridCells = this.adaptable.getGridCellsForColumn(column.columnId, true, visibleRowsOnly);
+        const adaptableApi = this.getAdaptableApi();
+        const predicateIds = adaptableApi.columnFilterApi.internalApi.getValuesFitlerPredicateIds(column);
+        if (ArrayExtensions.IsNullOrEmpty(predicateIds)) {
+            return;
+        }
+        const predicatesPosition = (_d = (_c = (_b = (_a = adaptableApi.optionsApi.getColumnFilterOptions()) === null || _a === void 0 ? void 0 : _a.valuesFilterOptions) === null || _b === void 0 ? void 0 : _b.valuesFilterPredicateOptions) === null || _c === void 0 ? void 0 : _c.predicatesPosition) !== null && _d !== void 0 ? _d : 'Start';
+        const predicateValues = predicateIds
+            .filter((predicateId) => {
+            // we have to make sure it is part of the visibleRowsOnly, when true
+            if (!visibleRowsOnly) {
+                return true;
+            }
+            return this.isPredicateInVisibleCellValues(predicateId, allGridCells);
+        })
+            .map((predicateId) => {
+            var _a;
+            const predicateDef = adaptableApi.predicateApi.getPredicateDefById(predicateId);
+            let label = ((_a = predicateDef.label) !== null && _a !== void 0 ? _a : predicateId);
+            return {
+                value: predicateId,
+                label: shouldShowValuesCount
+                    ? label +
+                        NumberExtensions.WrapInParentheses(this.getPredicateOccurance({ predicateId, column, allGridCells }))
+                    : label,
+            };
+        });
+        if (predicatesPosition === 'End') {
+            valueOptions.push(...predicateValues);
+        }
+        else {
+            valueOptions.unshift(...predicateValues);
+        }
+    }
+    isPredicateInVisibleCellValues(predicateId, allGridCells) {
+        const predicate = this.getPredicateApi().getPredicateDefById(predicateId);
+        if (!predicate) {
+            return false;
+        }
+        const commonContext = createBaseContext(this.getAdaptableApi());
+        for (let gridCell of allGridCells) {
+            if (this.getPredicateApi().handlePredicate({
+                PredicateId: predicate.id,
+            }, Object.assign({ value: gridCell.rawValue, oldValue: null, displayValue: gridCell.displayValue, node: gridCell.rowNode, column: gridCell.column }, commonContext), false)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    getPredicateOccurance(params) {
+        const { predicateId, allGridCells, column } = params;
+        const predicate = this.getPredicateApi().getPredicateDefById(predicateId);
+        if (!predicate) {
+            return 0;
+        }
+        let count = 0;
+        const commonContext = createBaseContext(this.getAdaptableApi());
+        for (let gridCell of allGridCells) {
+            if (this.getPredicateApi().handlePredicate({
+                PredicateId: predicate.id,
+            }, Object.assign({ value: gridCell.rawValue, oldValue: null, displayValue: gridCell.displayValue, node: gridCell.rowNode, column }, commonContext), false)) {
+                count++;
+            }
+        }
+        return count;
+    }
     async getDistinctFilterListValuesForColumn(column, filter, distinctValuesParams) {
         var _a;
         const filterPermittedValues = (_a = this.getUserInterfaceApi().getFilterPermittedValuesForColumn(column)) !== null && _a !== void 0 ? _a : {

package/src/PredefinedConfig/Common/AdaptableField.d.ts

@@ -4,7 +4,7 @@ import { AdaptableColumnDataType } from './AdaptableColumn';
  */
 export interface AdaptableField {
     /**
-     * Name of field, e.g. 'rowId', 'parentObject.childObject.value'
+     * Name of field in data source, e.g. 'rowId', 'parentObject.childObject.value'
      */
     name: string;
     /**

package/src/PredefinedConfig/Common/AdaptablePredicate.js

@@ -37,11 +37,15 @@ export const SystemPredicateDefs = [
             if (predicateInputs.length) {
                 const nestedContext = Object.assign({}, context);
                 delete nestedContext.inputs;
-                return predicateInputs.some((predicate) => {
+                const predicateResult = predicateInputs.some((predicate) => {
                     return adaptableApi.predicateApi.handlePredicate({
                         PredicateId: predicate.id,
                     }, nestedContext, false);
                 });
+                if (predicateResult) {
+                    // We want to use the only true values, to allow for multiple predicates to be used
+                    return predicateResult;
+                }
             }
             if (inputs.length === 0) {
                 return true;

package/src/Utilities/Constants/DocumentationLinkConstants.js

@@ -1,11 +1,11 @@
 export const HOST_URL_DOCS = 'https://docs.adaptabletools.com';
 //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-boolean`;
-export const ScalarQueryDocsLink = `${HOST_URL_DOCS}/guide/adaptable-ql-expression-scalar`;
+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-boolean`;
-export const AggregatedScalarQueryDocsLink = `${HOST_URL_DOCS}/guide/adaptable-ql-expression-aggregation-scalar`;
+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`;

package/src/View/CalculatedColumn/Wizard/CalculatedColumnTypeSection.js

@@ -4,11 +4,11 @@ import { Tabs } from '../../../components/Tabs';
 import { TypeRadio } from '../../Wizard/TypeRadio';
 export const CalculatedColumnTypeWizardSection = (props) => {
     return (React.createElement(Tabs, null,
-        React.createElement(Tabs.Tab, null, "Calculated Column Type"),
+        React.createElement(Tabs.Tab, null, "Calculated Column Expression Type"),
         React.createElement(Tabs.Content, null,
             React.createElement(Flex, { flexDirection: "column" },
-                React.createElement(TypeRadio, { text: 'Scalar Expression', description: "The calculated value is derived from other cells in the row", checked: props.type === 'ScalarExpression', onClick: () => props.onTypeChange('ScalarExpression') }),
-                React.createElement(TypeRadio, { text: 'Aggregated Scalar Expression', description: "The calculated value is derived from other rows", checked: props.type === 'AggregatedScalarExpression', onClick: () => props.onTypeChange('AggregatedScalarExpression') }),
-                React.createElement(TypeRadio, { text: 'Cumulative Aggregated Expression', description: "The calculated value is derived cumulatively from other rows", checked: props.type === 'CumulativeAggregatedExpression', onClick: () => props.onTypeChange('CumulativeAggregatedExpression') }),
-                React.createElement(TypeRadio, { text: 'Quantile Aggregated Expression', description: "The calculated value is derived from other rows using quantile aggregations", checked: props.type === 'QuantileAggregatedExpression', onClick: () => props.onTypeChange('QuantileAggregatedExpression') })))));
+                React.createElement(TypeRadio, { text: 'Standard', description: "The calculated value is derived from other cells in the row", checked: props.type === 'ScalarExpression', onClick: () => props.onTypeChange('ScalarExpression') }),
+                React.createElement(TypeRadio, { text: 'Aggregated', description: "The calculated value is derived from other rows", checked: props.type === 'AggregatedScalarExpression', onClick: () => props.onTypeChange('AggregatedScalarExpression') }),
+                React.createElement(TypeRadio, { text: 'Cumulative', description: "The calculated value is derived cumulatively from other rows", checked: props.type === 'CumulativeAggregatedExpression', onClick: () => props.onTypeChange('CumulativeAggregatedExpression') }),
+                React.createElement(TypeRadio, { text: 'Quantile', description: "The calculated value is derived from other rows using quantile aggregations", checked: props.type === 'QuantileAggregatedExpression', onClick: () => props.onTypeChange('QuantileAggregatedExpression') })))));
 };

package/src/View/Components/FilterForm/FilterForm.js

@@ -107,8 +107,8 @@ class FilterFormComponent extends React.Component {
         }
     }
     async loadPermittedValues(filter = '') {
-        const { values: distinctColumnValues, suppressClientSideFilter } = await runIfNotResolvedIn(this.props.api.gridApi.internalApi.getDistinctFilterDisplayValuesForColumn(this.props.currentColumn.columnId, filter, this.props.api.optionsApi.getColumnFilterOptions().valuesFilterOptions
-            .showDistinctFilteredValuesOnly), () => this._isMounted && this.setState({ isDistinctColumnValuesLoading: true }));
+        const { values: distinctColumnValues, suppressClientSideFilter } = await runIfNotResolvedIn(this.props.api.gridApi.internalApi.getDistinctFilterDisplayValuesForColumnForFiltersUI(this.props.currentColumn.columnId, filter, this.props.api.optionsApi.getColumnFilterOptions().valuesFilterOptions
+            .showCurrentlyFilteredValuesOnly), () => this._isMounted && this.setState({ isDistinctColumnValuesLoading: true }));
         if (this._isMounted) {
             this.setState({
                 distinctColumnValues,

package/src/View/Components/FilterForm/ListBoxFilterForm.js

@@ -41,7 +41,8 @@ export const ListBoxFilterForm = (props) => {
             setUiSelectedColumnValues([...UiSelectedColumnValues, item]);
         }
     };
-    const columnValuesItemsElements = props.columnDistinctValues.map((distinctValue, index) => {
+    const permittedValuesOptions = props.columnDistinctValues;
+    const columnValuesItemsElements = permittedValuesOptions.map((distinctValue, index) => {
         let isActive = UiSelectedColumnValues.indexOf(distinctValue.value) >= 0;
         // special case for date objects, need to check against string values
         if (!isActive && distinctValue.value && distinctValue.value instanceof Date) {

package/src/View/Components/FilterForm/QuickFilterValues.d.ts

@@ -1,7 +1,7 @@
 /// <reference types="react" />
-import { ColumnFilter } from '../../../PredefinedConfig/Common/ColumnFilter';
 import { AdaptableApi } from '../../../Api/AdaptableApi';
 import { AdaptableColumn } from '../../../PredefinedConfig/Common/AdaptableColumn';
+import { ColumnFilter } from '../../../PredefinedConfig/Common/ColumnFilter';
 import { ValuesFilterOptions } from '../../../types';
 export interface QuickFilterValuesProps {
     api: AdaptableApi;