@adaptabletools/adaptable 18.0.12 → 18.1.0-canary.0

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

@@ -12,6 +12,30 @@ export const QuickFilterValues = (props) => {
     const currentOverlayVisible = useRef(false);
     const valuesDropdownRef = React.useRef(null);
     const [quickFilterValues, setQuickFilterValues] = React.useState({ values: [], suppressClientSideFilter: false, dataLoadIsComplete: false });
+    const quickFilterValuesWithPredicates = React.useMemo(() => {
+        var _a, _b, _c;
+        let values = quickFilterValues.values;
+        const predicateIds = api.columnFilterApi.internalApi.getValuesFitlerPredicateIds(props.currentColumn);
+        if (ArrayExtensions.IsNullOrEmpty(predicateIds)) {
+            return values;
+        }
+        const predicatesPosition = (_c = (_b = (_a = api.optionsApi.getColumnFilterOptions()) === null || _a === void 0 ? void 0 : _a.valuesFilterOptions) === null || _b === void 0 ? void 0 : _b.predicatesPosition) !== null && _c !== void 0 ? _c : 'End';
+        const predicateValues = predicateIds.map(predicateId => {
+            var _a;
+            const predicateDef = api.predicateApi.getPredicateDefById(predicateId);
+            return {
+                value: predicateId,
+                label: ((_a = predicateDef.label) !== null && _a !== void 0 ? _a : predicateId),
+            };
+        });
+        if (predicatesPosition === 'End') {
+            values = [...values, ...predicateValues];
+        }
+        else {
+            values = [...predicateValues, ...values];
+        }
+        return values;
+    }, [quickFilterValues.values]);
     const [isDistinctColumnValuesLoading, setIsDistinctColumnValuesLoading] = React.useState(false);
     const [textFilterValue, setTextFilterValue] = React.useState('');
     const [valuesLoadTrigger, setValuesLoadTrigger] = React.useState({
@@ -102,13 +126,13 @@ export const QuickFilterValues = (props) => {
     let selectedValues = props.columnFilter.Predicate.PredicateId === 'Values' ? 'Select Values' : 'Exclude Values';
     if (props.columnFilter.Predicate.Inputs.length) {
         selectedValues = props.columnFilter.Predicate.Inputs.map((input) => {
-            var _a, _b;
-            const label = (_b = (_a = quickFilterValues.values) === null || _a === void 0 ? void 0 : _a.find((distinctValue) => {
+            var _a;
+            const label = (_a = quickFilterValuesWithPredicates === null || quickFilterValuesWithPredicates === void 0 ? void 0 : quickFilterValuesWithPredicates.find((distinctValue) => {
                 if (input instanceof Date) {
                     return isSameDay(input, distinctValue.value);
                 }
                 return distinctValue.value === input;
-            })) === null || _b === void 0 ? void 0 : _b.label;
+            })) === null || _a === void 0 ? void 0 : _a.label;
             return label !== null && label !== void 0 ? label : input;
         }).join(', ');
     }
@@ -177,7 +201,7 @@ export const QuickFilterValues = (props) => {
                                     props.updateColumnFilter(transientColumnFilter);
                                 }
                             } }, "Apply Filter"))),
-                    React.createElement(ListBoxFilterForm, { disabled: props.isFilterDisabled, suppressClientSideFilter: quickFilterValues.suppressClientSideFilter, isLoading: isDistinctColumnValuesLoading, onFilterChange: handleFilterChange, currentColumn: props.currentColumn, columns: [], columnDistinctValues: quickFilterValues.values, dataType: props.currentColumn.dataType, uiSelectedColumnValues: props.columnFilter.Predicate.Inputs.filter((input) => input !== ''), useAgGridStyle: true, onColumnValueSelectedChange: (list) => onColumnValueSelectedChange(list) }))));
+                    React.createElement(ListBoxFilterForm, { disabled: props.isFilterDisabled, suppressClientSideFilter: quickFilterValues.suppressClientSideFilter, isLoading: isDistinctColumnValuesLoading, onFilterChange: handleFilterChange, currentColumn: props.currentColumn, columns: [], columnDistinctValues: quickFilterValuesWithPredicates, dataType: props.currentColumn.dataType, uiSelectedColumnValues: props.columnFilter.Predicate.Inputs.filter((input) => input !== ''), useAgGridStyle: true, onColumnValueSelectedChange: (list) => onColumnValueSelectedChange(list) }))));
         } },
         React.createElement(SimpleButton, { "data-name": 'Select Values', style: {
                 flex: 1,

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(() => {
@@ -25,10 +25,14 @@ export const PermittedValuesSelector = function (props) {
             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))));
 };

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

@@ -14,6 +14,7 @@ import { useAdaptable } from '../../../AdaptableContext';
 import { ValueSelector } from '../../../Components/ValueSelector';
 import { useOnePageAdaptableWizardContext } from '../../../Wizard/OnePageAdaptableWizard';
 import { columnFilter } from './Utilities';
+import { SuspendToggleButton } from '../../../Components/Buttons/SuspendToggleButton';
 export const areSummaryRowsValid = (layout) => {
     var _a;
     if (!layout.RowSummaries)
@@ -32,7 +33,6 @@ export const areSummaryRowsValid = (layout) => {
 };
 const getAvailableExpressionsForColumnType = (columnType, availableScalarExpressions) => {
     const inputType = mapColumnDataTypeToExpressionFunctionType(columnType);
-    // Object.entries(availableScalarExpressions ?? {})
     return summarySupportedExpressions
         .filter((expression) => availableScalarExpressions[expression])
         .map((expression) => {
@@ -80,6 +80,12 @@ const RowSummaryEditor = ({ rowSummary, onChange, availableScalarExpressions, on
     }, [rowSummary.ColumnsMap]);
     return (React.createElement(Panel, { header: React.createElement(Flex, { style: { width: '100%' } },
             React.createElement(Flex, { flex: 1, alignItems: "center" }, "Row Summary"),
+            React.createElement(Box, { mr: 2 },
+                React.createElement(SuspendToggleButton, { onSuspend: () => {
+                        onChange(Object.assign(Object.assign({}, rowSummary), { IsSuspended: true }));
+                    }, onUnSuspend: () => {
+                        onChange(Object.assign(Object.assign({}, rowSummary), { IsSuspended: false }));
+                    }, suspendableObject: rowSummary })),
             React.createElement(SimpleButton, { icon: "delete", onClick: () => {
                     onDelete();
                 } })), p: 2 },

package/src/View/NamedQuery/Wizard/NamedQueryExpressionWizardSection.js

@@ -26,5 +26,5 @@ export const NamedQueryExpressionWizardSection = (props) => {
     const initialData = useMemo(() => api.internalApi.getQueryPreviewData(), []);
     return (React.createElement(ExpressionEditor, { allowSaveNamedQuery: false, showQueryBuilder: true, type: 'boolean', module: moduleInfo.ModuleName, value: data.BooleanExpression, onChange: (BooleanExpression) => {
             props.onChange(Object.assign(Object.assign({}, data), { 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 }));
 };