@adaptabletools/adaptable 18.0.17 → 18.1.0-canary.1

package/src/Utilities/Services/QueryLanguageService.js

@@ -1,12 +1,14 @@
-import * as parser from '../../parser/src';
 import { isObservable } from 'rxjs';
-import { aggregatedScalarExpressionFunctions, } from '../ExpressionFunctions/aggregatedScalarExpressionFunctions';
+import * as parser from '../../parser/src';
 import { aggregatedBooleanExpressionFunctions, } from '../ExpressionFunctions/aggregatedBooleanExpressionFunctions';
-import { AggregatedScalarLiveValue } from './AggregatedScalarLiveValue';
+import { addGroupByParams, aggregatedScalarExpressionFunctions, } from '../ExpressionFunctions/aggregatedScalarExpressionFunctions';
 import { booleanExpressionFunctions } from '../ExpressionFunctions/booleanExpressionFunctions';
-import { scalarExpressionFunctions } from '../ExpressionFunctions/scalarExpressionFunctions';
+import { extractColumnParameters, extractParameter, } from '../ExpressionFunctions/expressionFunctionUtils';
 import { observableExpressionFunctions } from '../ExpressionFunctions/observableExpressionFunctions';
+import { scalarExpressionFunctions } from '../ExpressionFunctions/scalarExpressionFunctions';
 import { getTypedKeys } from '../Extensions/TypeExtensions';
+import { createBaseContext } from '../ObjectFactory';
+import { AggregatedScalarLiveValue } from './AggregatedScalarLiveValue';
 export class QueryLanguageService {
     constructor(adaptableApi) {
         this.adaptableApi = adaptableApi;
@@ -285,8 +287,11 @@ export class QueryLanguageService {
         const generalBooleanExpressionFunctions = this.extractMappedExpressionFunctions(booleanExpressionFunctions, expressionOptions.systemBooleanFunctions, expressionOptions.customBooleanFunctions);
         const generalScalarExpressionFunctions = this.extractMappedExpressionFunctions(scalarExpressionFunctions, expressionOptions.systemScalarFunctions, expressionOptions.customScalarFunctions);
         const generalObservableExpressionFunctions = this.extractMappedExpressionFunctions(observableExpressionFunctions, expressionOptions.systemObservableFunctions);
-        const generalAggregatedBooleanExpressionFunctions = this.extractMappedExpressionFunctions(aggregatedBooleanExpressionFunctions, expressionOptions.systemAggregatedBooleanFunctions);
-        const generalAggregatedScalarExpressionFunctions = this.extractMappedExpressionFunctions(aggregatedScalarExpressionFunctions, expressionOptions.systemAggregatedScalarFunctions);
+        const generalAggregatedBooleanExpressionFunctions = this.extractMappedExpressionFunctions(aggregatedBooleanExpressionFunctions, expressionOptions.systemAggregatedBooleanFunctions, 
+        // right now the custom aggregated scalar functions are used in the aggregated boolean functions as well
+        // hopefully we'll simplify this in the future
+        this.getCustomAggregatedScalarFunctions());
+        const generalAggregatedScalarExpressionFunctions = this.extractMappedExpressionFunctions(aggregatedScalarExpressionFunctions, expressionOptions.systemAggregatedScalarFunctions, this.getCustomAggregatedScalarFunctions());
         if (!module) {
             this.adaptableApi.logWarn(`QueryLanguageService.getModuleExpressionFunctions() was called with an undefined 'module' param, this should never happen`);
             return {
@@ -325,6 +330,100 @@ export class QueryLanguageService {
         this.cacheModuleSpecificExpressionFunctions.set(module, moduleExpressionFunctionsMap);
         return moduleExpressionFunctionsMap;
     }
+    getCustomAggregatedScalarFunctions() {
+        var _a;
+        const customAggregatedScalarFunctions = (_a = this.adaptableApi.optionsApi.getExpressionOptions()) === null || _a === void 0 ? void 0 : _a.customAggregatedScalarFunctions;
+        if (!customAggregatedScalarFunctions) {
+            return {};
+        }
+        if (typeof customAggregatedScalarFunctions === 'function') {
+            return (context) => {
+                const customDefinitions = customAggregatedScalarFunctions(context);
+                return this.mapCustomAggregatedScalarFunctionsToInternal(customDefinitions);
+            };
+        }
+        return this.mapCustomAggregatedScalarFunctionsToInternal(customAggregatedScalarFunctions);
+    }
+    mapCustomAggregatedScalarFunctionsToInternal(aggregatedScalarFunctions) {
+        const getValueForColId = (colId, rowNode) => {
+            return this.adaptableApi.gridApi.getRawValueFromRowNode(rowNode, colId);
+        };
+        return Object.entries(aggregatedScalarFunctions).reduce((acc, [expressionName, customExpressionDefinition]) => {
+            const expression = {
+                handler: (args, context) => {
+                    // There is built in support for column validation
+                    // TODO: change to extractParameters
+                    // { colArgs: { [colId]: value } }
+                    const [aggColParam, ...restOfColParams] = extractColumnParameters(expressionName, args);
+                    const aggColumnId = aggColParam === null || aggColParam === void 0 ? void 0 : aggColParam.value;
+                    const groupByParameter = extractParameter(expressionName, 'operand', ['GROUP_BY'], args, {
+                        isOptional: true,
+                    });
+                    const preparedArgs = args.filter((arg) => {
+                        if (typeof arg === 'object' && arg.name === 'COL') {
+                            // filter out only first col
+                            return arg.value !== aggColumnId;
+                        }
+                        // filter out all other objects, e.g. GROUP_BY
+                        return typeof arg !== 'object';
+                    });
+                    const aggregationExpressionEvaluation = {
+                        aggregationParams: {
+                            reducers: {
+                                [expressionName]: {
+                                    name: expressionName,
+                                    field: aggColumnId,
+                                    initialValue: customExpressionDefinition.initialValue,
+                                    reducer: (acc, value, rowNode, dataIndex) => {
+                                        const context = Object.assign({ rowNode, args: preparedArgs.map((arg) => {
+                                                // if col, replace with value
+                                                if (typeof arg === 'object' && arg.name === 'COL') {
+                                                    return getValueForColId(arg.value, rowNode);
+                                                }
+                                                return arg;
+                                            }), aggColumnId, getValueForColId: (colId) => getValueForColId(colId, rowNode) }, createBaseContext(this.adaptableApi));
+                                        return customExpressionDefinition.reducer(acc, value, dataIndex, context);
+                                    },
+                                    done: (accValue, dataArray) => {
+                                        if (customExpressionDefinition.processReducerValue) {
+                                            return customExpressionDefinition.processReducerValue(accValue, dataArray, Object.assign(Object.assign({}, createBaseContext(this.adaptableApi)), { args }));
+                                        }
+                                        return accValue;
+                                    },
+                                },
+                            },
+                        },
+                        rowValueGetter: (rowNode, aggregationValue) => {
+                            if (customExpressionDefinition.prepareRowValue) {
+                                return customExpressionDefinition.prepareRowValue(rowNode, aggregationValue, Object.assign(Object.assign({}, createBaseContext(this.adaptableApi)), { aggColumnId,
+                                    args, getValueForColId: (colId) => getValueForColId(colId, rowNode) }));
+                            }
+                            return aggregationValue;
+                        },
+                        rowFilterFn: (rowNode) => {
+                            var _a, _b;
+                            if (customExpressionDefinition.rowFilter) {
+                                return customExpressionDefinition.rowFilter(rowNode, Object.assign(Object.assign({}, createBaseContext(this.adaptableApi)), { aggColumnId, getValueForColId: (colId) => getValueForColId(colId, rowNode) }));
+                            }
+                            return (_b = (_a = context === null || context === void 0 ? void 0 : context.filterFn) === null || _a === void 0 ? void 0 : _a.call(context, rowNode)) !== null && _b !== void 0 ? _b : true;
+                        },
+                        getRowNodes: context.getRowNodes,
+                    };
+                    addGroupByParams(groupByParameter === null || groupByParameter === void 0 ? void 0 : groupByParameter.value, aggregationExpressionEvaluation);
+                    const result = {
+                        name: expressionName,
+                        type: 'aggregationScalar',
+                        value: aggregationExpressionEvaluation,
+                    };
+                    return result;
+                },
+                description: customExpressionDefinition.description,
+                signatures: customExpressionDefinition.signatures,
+            };
+            acc[expressionName] = expression;
+            return acc;
+        }, {});
+    }
     extractMappedExpressionFunctions(availableExpressionFunctions, systemFunctions, customFunctions) {
         const systemFunctionNames = typeof systemFunctions === 'function'
             ? systemFunctions({

package/src/Utilities/Services/ReportService.js

@@ -323,16 +323,17 @@ export class ReportService {
         if (StringExtensions.IsNullOrEmpty(cellRawValue)) {
             return cellRawValue;
         }
-        const columnType = this.adaptableApi.columnApi.getColumnDataTypeForColumnId(columnId);
+        const column = this.adaptableApi.columnApi.getColumnWithColumnId(columnId);
+        const columnDataType = column.dataType;
         // if this is a date column and there is a custom export date format provided, that will take precedence
-        if (columnType === 'Date' && !!this.getCustomExportDateFormat()) {
+        if (columnDataType === 'Date' && !!this.getCustomExportDateFormat()) {
             const exportDateFormat = this.getCustomExportDateFormat();
             return FormatHelper.DateFormatter(cellRawValue, {
                 Pattern: exportDateFormat,
             });
         }
         // otherwise check the general export format types
-        let cellExportFormat = this.adaptableApi.exportApi.internalApi.getCellExportFormatType(columnType);
+        let cellExportFormat = this.adaptableApi.exportApi.internalApi.getCellExportFormatType(column, columnDataType);
         return this.getCellExportValueFromRawValueByType(rowNode, cellRawValue, columnId, cellExportFormat);
     }
     getReportFileName(reportName, destination) {
@@ -395,7 +396,6 @@ export class ReportService {
             formatColumnsWithDisplayFormatForColumn[columnId] = formatColumns;
             return formatColumns;
         };
-        const isDateCellExportedAsFormattedValue = this.adaptableApi.exportApi.internalApi.isDateCellExportedAsFormattedValue();
         const displayedColumns = this.adaptableApi.agGridApi.getAllDisplayedColumns();
         const colDefs = displayedColumns.map((column) => {
             return column.getColDef();
@@ -419,6 +419,9 @@ export class ReportService {
             displayedColumns.forEach((column, columnIndex) => {
                 var _a, _b, _c;
                 const colDef = colDefs[columnIndex];
+                const columnId = column.getId();
+                const adaptableColumn = this.adaptableApi.columnApi.getColumnWithColumnId(columnId);
+                const isDateCellExportedAsFormattedValue = this.adaptableApi.exportApi.internalApi.isDateCellExportedAsFormattedValue(adaptableColumn);
                 let cellClassParams;
                 const getLazyCellClassParams = () => {
                     if (!cellClassParams) {
@@ -427,7 +430,7 @@ export class ReportService {
                             node,
                             column,
                             data: node.data,
-                            value: this.adaptableApi.gridApi.getRawValueFromRowNode(node, column.getId()),
+                            value: this.adaptableApi.gridApi.getRawValueFromRowNode(node, columnId),
                             rowIndex,
                             api: agGridApi,
                             columnApi: null,

package/src/Utilities/Services/RowSummaryService.js

@@ -94,7 +94,9 @@ export class RowSummaryService {
             return;
         }
         const rowSummaries = (_a = this.api.layoutApi.getCurrentLayout().RowSummaries) !== null && _a !== void 0 ? _a : [];
-        const rowSummariesResults = rowSummaries.map(({ ColumnsMap, Position }) => {
+        const rowSummariesResults = rowSummaries
+            .filter((rowSummary) => !rowSummary.IsSuspended)
+            .map(({ ColumnsMap, Position }) => {
             return {
                 Position,
                 RowData: Object.entries(ColumnsMap !== null && ColumnsMap !== void 0 ? ColumnsMap : {}).reduce((acc, [columnId, expression]) => {

package/src/Utilities/divideBy100.d.ts

@@ -0,0 +1 @@
+export declare function divideBy100(value: any): any;

package/src/Utilities/divideBy100.js

@@ -0,0 +1,30 @@
+export function divideBy100(value) {
+    // the simple solution does not work
+    // return value / 100;
+    // needed because 4012.3456/100 = 40.123456000000004
+    // but we dont want that to happen
+    // this solution does not handle  -0 correctly
+    // return parseFloat((value / 100).toFixed(12));
+    if (isNaN(value) || !value) {
+        return value;
+    }
+    const isNegative = value < 0;
+    if (isNegative) {
+        value = -value;
+    }
+    const valueAsStr = value.toPrecision();
+    const separator = Number(1.1).toLocaleString()[1];
+    let indexOfSeparator = valueAsStr.indexOf(separator);
+    if (indexOfSeparator === -1) {
+        indexOfSeparator = 0;
+    }
+    let [integer = '', decimal] = valueAsStr.split(separator);
+    decimal = decimal || '';
+    integer = integer.padStart(2, '0');
+    const integerArr = [...integer];
+    const num = integerArr.slice(0, integerArr.length - 2).join('') +
+        separator +
+        integerArr.slice(-2).join('') +
+        decimal;
+    return Number(num) * (isNegative ? -1 : 1);
+}

package/src/Utilities/times100.d.ts

@@ -0,0 +1 @@
+export declare function times100(value: any): any;

package/src/Utilities/times100.js

@@ -0,0 +1,23 @@
+export function times100(value) {
+    // the simple solution does not work
+    // return value * 100;
+    // needed because 0.12676 * 100 = 12.676000000000002
+    // but we dont want that to happen
+    // this solution does not handle  -0 correctly
+    // also 1267.6 * 100 is 126759.99999999999
+    // which is not what we want
+    // return parseFloat((value * 100).toFixed(12));
+    if (isNaN(value) || !value) {
+        return value;
+    }
+    const valueAsStr = value.toPrecision();
+    const separator = Number(1.1).toLocaleString()[1];
+    const indexOfSeparator = valueAsStr.indexOf(separator);
+    if (indexOfSeparator === -1) {
+        return value * 100;
+    }
+    const [integer, decimal] = valueAsStr.split(separator);
+    const num = [...`${integer}${decimal !== null && decimal !== void 0 ? decimal : ''}00`];
+    num.splice(indexOfSeparator + 2, 0, separator);
+    return Number(num.join(''));
+}

package/src/View/Alert/Wizard/AlertMessageWizardSection.js

@@ -15,7 +15,7 @@ export const renderAlertMessageSummary = () => {
 export const AlertMessageWizardSection = (props) => {
     const { data, api } = useOnePageAdaptableWizardContext();
     const messageType = data.MessageType;
-    const messageText = api.alertApi.internalApi.getAlertDescription(data);
+    const messageText = api.alertApi.internalApi.getAlertDescriptionForDataChange(data);
     const messageHeader = data.MessageHeader;
     const onMessageTextChange = (e) => {
         const { value } = e.target;

package/src/View/Alert/Wizard/AlertNotificationWizardSection.js

@@ -31,8 +31,8 @@ export const AlertPreview = (_a) => {
         }
         const result = {
             alertType: 'generic',
-            header: api.alertApi.internalApi.getAlertMessageHeader(alertDefinition),
-            message: api.alertApi.internalApi.getAlertDescription(alertDefinition),
+            header: api.alertApi.internalApi.getAlertMessageHeaderForDataChange(alertDefinition),
+            message: api.alertApi.internalApi.getAlertDescriptionForDataChange(alertDefinition),
             alertDefinition: Object.assign(Object.assign({}, alertDefinition), { AlertForm: alertForm }),
         };
         return result;

package/src/View/Alert/Wizard/AlertScopeWizardSection.js

@@ -24,7 +24,8 @@ export const AlertScopeWizardSection = (props) => {
                         Predicates: [{ PredicateId: 'AnyChange' }],
                     };
                 }
-                if (newData.Rule.ObservableExpression !== undefined && !api.columnScopeApi.scopeIsAll(Scope)) {
+                if (newData.Rule.ObservableExpression !== undefined &&
+                    !api.columnScopeApi.scopeIsAll(Scope)) {
                     // if it had observable expression and the scope is changed to partial
                     // we need to reset to not be an observable expression, as observable is not supported
                     // for partial scope

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

@@ -49,7 +49,7 @@ export const CalculatedColumnExpressionWizardSection = (props) => {
         React.createElement(Tabs.Content, null, (() => {
             switch (props.expressionType) {
                 case 'ScalarExpression':
-                    return (React.createElement(ExpressionEditor, { type: 'scalar', module: moduleInfo.ModuleName, style: { paddingLeft: 0 }, value: data.Query.ScalarExpression, onChange: (ScalarExpression) => setCalculatedColumnExpression({ ScalarExpression }), initialData: initialData, columns: api.columnApi.getQueryableColumns(), namedQueries: api.namedQueryApi.getNamedQueries(), isFullExpression: true, api: api }));
+                    return (React.createElement(ExpressionEditor, { type: 'scalar', module: moduleInfo.ModuleName, style: { paddingLeft: 0 }, value: data.Query.ScalarExpression, onChange: (ScalarExpression) => setCalculatedColumnExpression({ ScalarExpression }), initialData: initialData, columns: api.columnApi.getQueryableColumns(), fields: api.expressionApi.internalApi.getAvailableFields(), namedQueries: api.namedQueryApi.getNamedQueries(), isFullExpression: true, api: api }));
                 case 'AggregatedScalarExpression':
                 case 'CumulativeAggregatedExpression':
                 case 'QuantileAggregatedExpression':

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/EntityRulesEditor/index.d.ts

@@ -27,6 +27,7 @@ export type EntityRulesEditorProps<T> = {
         useAggregationQuery: React.ReactNode;
     };
     flexProps?: FlexProps;
+    showQueryBuilder?: boolean;
 };
 export declare const EntityRulesSummary: <T extends {
     Rule?: RuleType;

package/src/View/Components/EntityRulesEditor/index.js

@@ -7,6 +7,7 @@ import Radio from '../../../components/Radio';
 import { ExpressionEditor } from '../../../components/ExpressionEditor';
 import { useAdaptable } from '../../AdaptableContext';
 import { EntityRulePredicatesEditor } from './EntityRulePredicatesEditor';
+import Panel from '../../../components/Panel';
 const QueryTab = (props) => {
     const { type, label, disabled = false } = props, tabProps = __rest(props, ["type", "label", "disabled"]);
     const text = (React.createElement(Flex, { flexDirection: "column" },
@@ -43,7 +44,7 @@ const RuleTabTitle = (props) => {
     return props.showRadio ? (React.createElement(Radio, { tabIndex: -1, margin: 0, checked: props.checked }, props.children)) : (React.createElement(React.Fragment, null, "props.children"));
 };
 export const EntityRulesEditor = (props) => {
-    var _a, _b, _c;
+    var _a, _b;
     const { data, children, descriptions, predicateDefs, showNoRule = false, showPredicate = true, showObservable = true, showBoolean = true, showAggregation = true, flexProps, module, } = props;
     const { api } = useAdaptable();
     const numberOfTabs = [
@@ -125,12 +126,15 @@ export const EntityRulesEditor = (props) => {
             showPredicate ? (React.createElement(Tabs.Content, { "data-name": "Predicate", value: "Predicate" },
                 React.createElement(EntityRulePredicatesEditor, { enablePredicateColumnId: props.enablePredicateColumnId, data: data, descriptions: descriptions, predicateDefs: filteredPredicateDefs, getPredicateDefsForColId: props.getPredicateDefsForColId, onChange: props.onChange }))) : null,
             showBoolean ? (React.createElement(QueryTab, { showRadio: showRadioButtons, value: "BooleanExpression", type: type, label: "Boolean" })) : null,
-            showBoolean ? (React.createElement(Tabs.Content, { "data-name": "BooleanExpression", value: 'BooleanExpression', paddingLeft: 0 },
-                React.createElement(ExpressionEditor, { type: 'boolean', module: module, value: (_a = data.Rule) === null || _a === void 0 ? void 0 : _a.BooleanExpression, onChange: setBooleanExpression, initialData: initialData, columns: api.columnApi.getQueryableColumns(), namedQueries: api.namedQueryApi.getNamedQueries(), api: api }))) : null,
+            showBoolean ? (React.createElement(Tabs.Content, { "data-name": "BooleanExpression", value: 'BooleanExpression' }, (() => {
+                var _a;
+                const editor = (React.createElement(ExpressionEditor, { type: 'boolean', module: module, value: (_a = data.Rule) === null || _a === void 0 ? void 0 : _a.BooleanExpression, onChange: setBooleanExpression, initialData: initialData, columns: api.columnApi.getQueryableColumns(), fields: api.expressionApi.internalApi.getAvailableFields(), namedQueries: api.namedQueryApi.getNamedQueries(), api: api, showQueryBuilder: props.showQueryBuilder }));
+                return props.showQueryBuilder ? React.createElement(Panel, null, editor) : editor;
+            })())) : null,
             showObservable ? (React.createElement(QueryTab, { showRadio: showRadioButtons, value: "ObservableExpression", type: type, label: "Observable" })) : null,
-            showObservable ? (React.createElement(Tabs.Content, { "data-name": "ObservableExpression", value: 'ObservableExpression', paddingLeft: 0 },
-                React.createElement(ExpressionEditor, { type: 'observable', module: module, value: (_b = data.Rule) === null || _b === void 0 ? void 0 : _b.ObservableExpression, onChange: setReactiveExpression, initialData: initialData, columns: api.columnApi.getQueryableColumns(), namedQueries: api.namedQueryApi.getNamedQueries(), api: api }))) : null,
+            showObservable ? (React.createElement(Tabs.Content, { "data-name": "ObservableExpression", value: 'ObservableExpression' },
+                React.createElement(ExpressionEditor, { type: 'observable', module: module, value: (_a = data.Rule) === null || _a === void 0 ? void 0 : _a.ObservableExpression, onChange: setReactiveExpression, initialData: initialData, columns: api.columnApi.getQueryableColumns(), fields: api.expressionApi.internalApi.getAvailableFields(), namedQueries: api.namedQueryApi.getNamedQueries(), api: api }))) : null,
             showAggregation ? (React.createElement(QueryTab, { showRadio: showRadioButtons, value: "AggregatedBooleanExpression", type: type, label: "Aggregated Boolean" })) : null,
-            showAggregation ? (React.createElement(Tabs.Content, { "data-name": "AggregatedBooleanExpression", value: 'AggregatedBooleanExpression', paddingLeft: 0 },
-                React.createElement(ExpressionEditor, { type: 'aggregatedBoolean', module: module, value: (_c = data.Rule) === null || _c === void 0 ? void 0 : _c.AggregatedBooleanExpression, onChange: setAggregationExpression, initialData: initialData, columns: api.columnApi.getQueryableColumns(), namedQueries: api.namedQueryApi.getNamedQueries(), api: api }))) : null)));
+            showAggregation ? (React.createElement(Tabs.Content, { "data-name": "AggregatedBooleanExpression", value: 'AggregatedBooleanExpression' },
+                React.createElement(ExpressionEditor, { type: 'aggregatedBoolean', module: module, value: (_b = data.Rule) === null || _b === void 0 ? void 0 : _b.AggregatedBooleanExpression, onChange: setAggregationExpression, initialData: initialData, columns: api.columnApi.getQueryableColumns(), fields: api.expressionApi.internalApi.getAvailableFields(), namedQueries: api.namedQueryApi.getNamedQueries(), api: api }))) : null)));
 };

package/src/View/Components/ExpressionWizard.js

@@ -28,7 +28,7 @@ export class ExpressionWizard extends React.Component {
     render() {
         const initialData = useMemo(() => this.props.api.internalApi.getQueryPreviewData(), []);
         return (React.createElement(React.Fragment, null,
-            React.createElement(ExpressionEditor, { type: 'boolean', module: NamedQueryModuleId, value: this.state.expression, onChange: this.handleCustomExpressionChange, initialData: initialData, columns: this.props.api.columnApi.getQueryableColumns(), namedQueries: this.props.api.namedQueryApi.getNamedQueries(), api: this.props.api }),
+            React.createElement(ExpressionEditor, { type: 'boolean', module: NamedQueryModuleId, value: this.state.expression, onChange: this.handleCustomExpressionChange, initialData: initialData, columns: this.props.api.columnApi.getQueryableColumns(), fields: this.props.api.expressionApi.internalApi.getAvailableFields(), namedQueries: this.props.api.namedQueryApi.getNamedQueries(), api: this.props.api }),
             ' ',
             React.createElement(Flex, { flexDirection: "row", padding: 1, marginBottom: 2, marginLeft: 1, alignItems: "center", "data-name": "expression-wizard-save-option" },
                 React.createElement(CheckBox, { marginLeft: 2, disabled: !this.isValidExpression(), marginBottom: 2, checked: this.state.saveToNamedQueries, onChange: (checked) => this.setState({

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;

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

@@ -1,12 +1,12 @@
+import { isSameDay } from 'date-fns';
+import { Resizable } from 're-resizable';
 import * as React from 'react';
 import { useCallback, useEffect, useRef } from 'react';
+import { Flex } from 'rebass';
 import ArrayExtensions from '../../../Utilities/Extensions/ArrayExtensions';
-import SimpleButton from '../../../components/SimpleButton';
-import { isSameDay } from 'date-fns';
 import OverlayTrigger from '../../../components/OverlayTrigger';
-import { Flex } from 'rebass';
+import SimpleButton from '../../../components/SimpleButton';
 import { ListBoxFilterForm } from './ListBoxFilterForm';
-import { Resizable } from 're-resizable';
 export const QuickFilterValues = (props) => {
     const { api } = props;
     const currentOverlayVisible = useRef(false);
@@ -48,7 +48,7 @@ export const QuickFilterValues = (props) => {
         let ignore = false;
         setIsDistinctColumnValuesLoading(true);
         api.gridApi.internalApi
-            .getDistinctFilterDisplayValuesForColumn(props.columnFilter.ColumnId, textFilterValue, api.optionsApi.getColumnFilterOptions().valuesFilterOptions.showDistinctFilteredValuesOnly)
+            .getDistinctFilterDisplayValuesForColumnForFiltersUI(props.columnFilter.ColumnId, textFilterValue, api.optionsApi.getColumnFilterOptions().valuesFilterOptions.showCurrentlyFilteredValuesOnly)
             .then((distinctFilterDisplayValues) => {
             if (ignore) {
                 return;

package/src/View/Components/Popups/AdaptablePopup/AdaptablePopupModuleView.js

@@ -79,10 +79,14 @@ export const AdaptablePopupModuleView = (props) => {
         newButton = (React.createElement(ButtonNew, { onClick: () => handleOpenEditPopup(), tooltip: toolTipText, accessLevel: props.accessLevel }));
     }
     let suspendButton = null;
-    if (items.length &&
+    const editableObjects = (items).filter(item => !item.abObject.IsReadOnly);
+    if (editableObjects.length &&
         (moduleViewProperties === null || moduleViewProperties === void 0 ? void 0 : moduleViewProperties.getSuspendAllAction) &&
         (moduleViewProperties === null || moduleViewProperties === void 0 ? void 0 : moduleViewProperties.getUnSuspendAllAction)) {
-        const isAtLeastOneAbObjectActive = items.some((item) => { var _a; return !((_a = item.abObject) === null || _a === void 0 ? void 0 : _a.IsSuspended); });
+        const isAtLeastOneAbObjectActive = editableObjects.some((item) => {
+            var _a;
+            return !((_a = item.abObject) === null || _a === void 0 ? void 0 : _a.IsSuspended);
+        });
         const handleSuspendUnsuspendAll = () => {
             if (isAtLeastOneAbObjectActive) {
                 const suspendAllAction = moduleViewProperties.getSuspendAllAction();

package/src/View/Components/Selectors/FieldSelector.d.ts

@@ -0,0 +1,13 @@
+import * as React from 'react';
+import { SelectProps } from '../../../components/Select';
+import { AdaptableColumnDataType } from '../../../types';
+interface FieldSelectorProps {
+    value: string;
+    onChange: (fieldExp: string) => void;
+    type?: AdaptableColumnDataType;
+    disabled?: boolean;
+    menuPosition?: SelectProps<any>['menuPosition'];
+    placeholder?: string;
+}
+export declare const FieldSelector: React.FunctionComponent<FieldSelectorProps>;
+export {};

package/src/View/Components/Selectors/FieldSelector.js

@@ -0,0 +1,21 @@
+import * as React from 'react';
+import { Select } from '../../../components/Select';
+import { useAdaptable } from '../../AdaptableContext';
+export const FieldSelector = (props) => {
+    var _a;
+    const { api } = useAdaptable();
+    const fields = React.useMemo(() => {
+        return api.expressionApi.internalApi.getFieldsOfType(props.type);
+    }, []);
+    const options = fields.map((field) => {
+        var _a;
+        return ({
+            label: (_a = field.label) !== null && _a !== void 0 ? _a : field.name,
+            value: field.name,
+        });
+    });
+    return (React.createElement(React.Fragment, null,
+        React.createElement(Select, { "data-name": "column-selector", disabled: props.disabled, isMulti: false, menuPosition: props.menuPosition, value: props.value || undefined, placeholder: (_a = props.placeholder) !== null && _a !== void 0 ? _a : 'Select Field', onChange: (fieldValue) => {
+                props.onChange(fieldValue);
+            }, options: options })));
+};

package/src/View/Components/Selectors/PermittedValuesSelector.js

@@ -7,7 +7,7 @@ export const PermittedValuesSelector = function (props) {
     const [isLoading, setIsLoading] = React.useState(true);
     const [options, setOptions] = React.useState([]);
     const [filter, setFilter] = React.useState('');
-    const columnType = React.useMemo(() => {
+    const dataType = React.useMemo(() => {
         return adaptable.api.columnApi.getColumnDataTypeForColumnId(props.columnId);
     }, [props.columnId]);
     React.useEffect(() => {
@@ -18,17 +18,21 @@ export const PermittedValuesSelector = function (props) {
         setIsLoading(true);
         (async () => {
             const { values: distinctColumnValues } = await runIfNotResolvedIn(adaptable.api.gridApi.internalApi.getDistinctFilterDisplayValuesForColumn(props.columnId, filter, adaptable.api.optionsApi.getColumnFilterOptions().valuesFilterOptions
-                .showDistinctFilteredValuesOnly), () => {
+                .showCurrentlyFilteredValuesOnly), () => {
                 setIsLoading(true);
             });
             setIsLoading(false);
             setOptions(distinctColumnValues);
         })();
     }, [props.columnId, filter]);
-    const isCreatable = props.allowNewValues && ['String', 'Number'].includes(columnType);
+    const isCreatable = (props.allowNewValues && !dataType) || ['String', 'Number'].includes(dataType);
     const handleSingleValueChange = (value) => {
         if (isCreatable) {
-            if (columnType === 'Number') {
+            // try to convert to correct type, when there is not type, e.g. field
+            if (!dataType && typeof value === 'string' && !isNaN(parseFloat(value))) {
+                props.onChange(parseFloat(value));
+            }
+            else if (dataType === 'Number') {
                 let num = parseFloat(value);
                 num = isNaN(num) ? null : num;
                 props.onChange(num);
@@ -43,7 +47,7 @@ export const PermittedValuesSelector = function (props) {
     };
     const handleMultiValueChange = (values) => {
         if (isCreatable) {
-            if (columnType === 'Number') {
+            if (dataType === 'Number') {
                 const nums = values.map((v) => parseFloat(v)).filter((v) => !isNaN(v));
                 props.onChange(nums);
             }

package/src/View/Export/Wizard/ReportRowsWizardSection.js

@@ -66,5 +66,5 @@ export const ReportRowsWizardSection = (props) => {
                         props.onChange(Object.assign(Object.assign({}, data), { Query: {
                                 BooleanExpression,
                             } }));
-                    }, initialData: initialData, columns: api.columnApi.getQueryableColumns(), namedQueries: api.namedQueryApi.getNamedQueries(), api: api })))));
+                    }, initialData: initialData, columns: api.columnApi.getQueryableColumns(), fields: api.expressionApi.internalApi.getAvailableFields(), namedQueries: api.namedQueryApi.getNamedQueries(), api: api })))));
 };

package/src/View/FormatColumn/Wizard/FormatColumnRuleWizardSection.js

@@ -5,7 +5,7 @@ export function FormatColumnRuleWizardSection(props) {
     const { data, api, moduleInfo } = useOnePageAdaptableWizardContext();
     return (React.createElement(EntityRulesEditor, { module: moduleInfo.ModuleName, defaultPredicateId: props.defaultPredicateId, 
         // TODO see what is this
-        predicateDefs: api.formatColumnApi.internalApi.getFormatColumnDefsForScope(data.Scope), getPredicateDefsForColId: (colId) => api.formatColumnApi.internalApi.getFormatColumnDefsForScope({ ColumnIds: [colId] }), showNoRule: true, showBoolean: true, showAggregation: false, showObservable: false, showPredicate: !api.columnScopeApi.scopeIsAll(data.Scope), data: data, onChange: (formatColumn) => props.onChange(formatColumn), descriptions: {
+        predicateDefs: api.formatColumnApi.internalApi.getFormatColumnDefsForScope(data.Scope), getPredicateDefsForColId: (colId) => api.formatColumnApi.internalApi.getFormatColumnDefsForScope({ ColumnIds: [colId] }), showNoRule: true, showBoolean: true, showAggregation: false, showObservable: false, showQueryBuilder: true, showPredicate: !api.columnScopeApi.scopeIsAll(data.Scope), data: data, onChange: (formatColumn) => props.onChange(formatColumn), descriptions: {
             selectPredicate: 'Create a Format Column Rule - to be applied when data changes',
             useBooleanQuery: (React.createElement(React.Fragment, null,
                 "Use an BooleanQuery if ",

package/src/View/GridFilter/GridFilterExpressionEditor.js

@@ -88,7 +88,7 @@ export const GridFilterExpressionEditor = (props) => {
             },
         } },
         React.createElement(Flex, { height: "100%", flexDirection: "column" },
-            React.createElement(ExpressionEditor, Object.assign({}, expressionEditorProps, { type: 'boolean', module: GridFilterModuleId, value: expression, onChange: (expression) => setExpression(expression), initialData: initialData, columns: api.columnApi.getQueryableColumns(), namedQueries: api.namedQueryApi.getNamedQueries(), api: api })),
+            React.createElement(ExpressionEditor, Object.assign({}, expressionEditorProps, { type: 'boolean', module: GridFilterModuleId, value: expression, onChange: (expression) => setExpression(expression), initialData: initialData, columns: api.columnApi.getQueryableColumns(), fields: api.expressionApi.internalApi.getAvailableFields(), namedQueries: api.namedQueryApi.getNamedQueries(), api: api })),
             React.createElement(Flex, { flexDirection: "row", padding: 1, alignItems: "center" },
                 props.onDismiss && (React.createElement(SimpleButton, { margin: 1, variant: "text", "data-name": "action-close", onClick: () => {
                         props.onDismiss();

package/src/View/Layout/Wizard/sections/GridFilterSection.js

@@ -8,6 +8,7 @@ import { ExpressionEditor } from '../../../../components/ExpressionEditor';
 import { GridFilterModuleId } from '../../../../Utilities/Constants/ModuleConstants';
 import StringExtensions from '../../../../Utilities/Extensions/StringExtensions';
 import { useGridFilterOptionsForExpressionEditorProps } from '../../../GridFilter/useGridFilterOptionsForExpressionEditor';
+import Panel from '../../../../components/Panel';
 export const isGridFiltersValid = (layout, api) => {
     var _a;
     const expression = (_a = layout === null || layout === void 0 ? void 0 : layout.GridFilter) === null || _a === void 0 ? void 0 : _a.Expression;
@@ -30,8 +31,9 @@ export const GridFilterSection = (props) => {
     const expressionEditorProps = useGridFilterOptionsForExpressionEditorProps();
     const expressionEditorContent = (React.createElement(ExpressionEditor, Object.assign({}, expressionEditorProps, { allowSaveNamedQuery: false, type: 'boolean', module: GridFilterModuleId, value: (_b = (_a = layout === null || layout === void 0 ? void 0 : layout.GridFilter) === null || _a === void 0 ? void 0 : _a.Expression) !== null && _b !== void 0 ? _b : '', onChange: (expression) => {
             props.onChange(Object.assign(Object.assign({}, layout), { GridFilter: Object.assign(Object.assign({}, layout.GridFilter), { Expression: expression }) }));
-        }, initialData: initialData, columns: api.columnApi.getQueryableColumns(), namedQueries: api.namedQueryApi.getNamedQueries(), api: api })));
+        }, initialData: initialData, columns: api.columnApi.getQueryableColumns(), fields: api.expressionApi.internalApi.getAvailableFields(), namedQueries: api.namedQueryApi.getNamedQueries(), api: api })));
     return (React.createElement(Tabs, { style: { height: '100%' } },
         React.createElement(Tabs.Tab, null, "Grid Filters"),
-        React.createElement(Tabs.Content, null, expressionEditorContent)));
+        React.createElement(Tabs.Content, null,
+            React.createElement(Panel, null, expressionEditorContent))));
 };