@adaptabletools/adaptable 12.1.6 → 12.1.8-canary.1

package/src/Utilities/Services/AlertService.js

@@ -25,11 +25,10 @@ class AlertService {
     createReactiveAlert(alertDefinition) {
         // if there is already a reactive alert for this definition, delete it (possible in case of editing definitions),
         this.deleteReactiveAlert(alertDefinition);
-        if (!alertDefinition.Rule.ObservableExpression &&
-            !alertDefinition.Rule.AggregatedBooleanExpression) {
+        if (!alertDefinition.Rule.ObservableExpression) {
             return;
         }
-        const isValidExpression = this.isValidExpression(alertDefinition.Rule);
+        const isValidExpression = this.adaptableApi.queryLanguageApi.isValidObservableExpression(alertDefinition.Rule.ObservableExpression, ModuleConstants_1.AlertModuleId, `Invalid Alert rule with observable expression `);
         if (!isValidExpression) {
             LoggingHelper_1.LogAdaptableWarning(`Could NOT create reactive alert due to invalid Rule definition!`, alertDefinition.Rule);
             return;
@@ -58,21 +57,10 @@ class AlertService {
             this.reactiveAlertsMap.delete(alertDefinition.Uuid);
         }
     }
-    isValidExpression(rule) {
-        return rule.ObservableExpression
-            ? this.adaptableApi.queryLanguageApi.isValidObservableExpression(rule.ObservableExpression, ModuleConstants_1.AlertModuleId, `Invalid Alert rule with observable expression `)
-            : rule.AggregatedBooleanExpression
-                ? this.adaptableApi.queryLanguageApi.isValidAggregatedBooleanExpression(rule.AggregatedBooleanExpression, ModuleConstants_1.AlertModuleId, `Invalid Alert rule with aggregation expression `)
-                : false;
-    }
     evaluateReactiveExpression(rule) {
-        return rule.ObservableExpression
-            ? this.adaptableApi.internalApi
-                .getQueryLanguageService()
-                .evaluateObservableExpression(rule.ObservableExpression, ModuleConstants_1.AlertModuleId)
-            : this.adaptableApi.internalApi
-                .getQueryLanguageService()
-                .evaluateAggregatedBooleanExpression(rule.AggregatedBooleanExpression, ModuleConstants_1.AlertModuleId);
+        return this.adaptableApi.internalApi
+            .getQueryLanguageService()
+            .evaluateObservableExpression(rule.ObservableExpression, ModuleConstants_1.AlertModuleId);
     }
 }
 exports.AlertService = AlertService;

package/src/Utilities/Services/CalculatedColumnExpressionService.d.ts

@@ -4,12 +4,12 @@ import { AdaptableCalculatedColumnQuery, CalculatedColumn } from '../../Predefin
 import { AdaptableApi } from '../../../types';
 export declare class CalculatedColumnExpressionService implements ICalculatedColumnExpressionService {
     private adaptableApi;
-    private aggregatedScalarCalculatedColumnsMap;
+    private aggregatedScalarLiveValuesMap;
     constructor(adaptableApi: AdaptableApi);
     destroy(): void;
     getCalculatedColumnDataType(calculatedColumnQuery: AdaptableCalculatedColumnQuery): 'String' | 'Number' | 'Boolean' | 'Date';
     isCalculatedColumnQueryValid(calculatedColumnQuery: AdaptableCalculatedColumnQuery): boolean;
-    evaluateCalculatedColumnQuery(calculatedColumn: CalculatedColumn, node: RowNode): any;
-    createAggregatedScalarCalculatedColumn(calculatedColumn: CalculatedColumn): void;
-    destroyAggregatedScalarCalculatedColumn(calculatedColumn: CalculatedColumn): void;
+    evaluateCalculatedColumnQuery(calculatedColumn: CalculatedColumn, rowNode: RowNode): any;
+    createAggregatedScalarLiveValue(calculatedColumn: CalculatedColumn): void;
+    destroyAggregatedScalarLiveValue(calculatedColumn: CalculatedColumn): void;
 }

package/src/Utilities/Services/CalculatedColumnExpressionService.js

@@ -3,11 +3,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.CalculatedColumnExpressionService = void 0;
 const LoggingHelper_1 = require("../Helpers/LoggingHelper");
 const ModuleConstants_1 = require("../Constants/ModuleConstants");
-const scalarAggregationHelper_1 = require("../ExpressionFunctions/scalarAggregationHelper");
+const AggregatedScalarLiveValue_1 = require("./AggregatedScalarLiveValue");
 class CalculatedColumnExpressionService {
     constructor(adaptableApi) {
         this.adaptableApi = adaptableApi;
-        this.aggregatedScalarCalculatedColumnsMap = new Map();
+        this.aggregatedScalarLiveValuesMap = new Map();
         this.adaptableApi = adaptableApi;
         this.adaptableApi.internalApi
             .getDataService()
@@ -17,12 +17,12 @@ class CalculatedColumnExpressionService {
                 return;
             }
             const refreshedCalculatedColumns = [];
-            this.aggregatedScalarCalculatedColumnsMap.forEach((aggregatedScalarCalculatedColumn) => {
-                if (aggregatedScalarCalculatedColumn
-                    .getColumnDependencies()
-                    .includes(cellDataChangedInfo.column.columnId)) {
-                    aggregatedScalarCalculatedColumn.refreshAggregatedColumnValue();
-                    refreshedCalculatedColumns.push(aggregatedScalarCalculatedColumn.getCalculatedColumnId());
+            this.aggregatedScalarLiveValuesMap.forEach((aggregatedScalarLiveValue, calculatedColumnId) => {
+                const calculatedColumn = this.adaptableApi.calculatedColumnApi.getCalculatedColumnById(calculatedColumnId);
+                const columnDependencies = this.adaptableApi.calculatedColumnApi.getReferencedColumnIdsForCalculatedColumn(calculatedColumn);
+                if (columnDependencies.includes(cellDataChangedInfo.column.columnId)) {
+                    aggregatedScalarLiveValue.refresh();
+                    refreshedCalculatedColumns.push(calculatedColumn.ColumnId);
                 }
             });
             if (refreshedCalculatedColumns.length) {
@@ -31,9 +31,10 @@ class CalculatedColumnExpressionService {
         });
         this.adaptableApi.eventApi.on('GridDataChanged', () => {
             const refreshedCalculatedColumns = [];
-            this.aggregatedScalarCalculatedColumnsMap.forEach((aggregatedScalarCalculatedColumn) => {
-                aggregatedScalarCalculatedColumn.refreshAggregatedColumnValue();
-                refreshedCalculatedColumns.push(aggregatedScalarCalculatedColumn.getCalculatedColumnId());
+            this.aggregatedScalarLiveValuesMap.forEach((aggregatedScalarLiveValue, calculatedColumnId) => {
+                const calculatedColumn = this.adaptableApi.calculatedColumnApi.getCalculatedColumnById(calculatedColumnId);
+                aggregatedScalarLiveValue.refresh();
+                refreshedCalculatedColumns.push(calculatedColumn.ColumnId);
             });
             if (refreshedCalculatedColumns.length) {
                 this.adaptableApi.gridApi.refreshCells(null, refreshedCalculatedColumns);
@@ -41,9 +42,8 @@ class CalculatedColumnExpressionService {
         });
     }
     destroy() {
-        [...this.aggregatedScalarCalculatedColumnsMap.values()].forEach((aggregatedScalarCalculatedColumn) => aggregatedScalarCalculatedColumn.destroy());
-        this.aggregatedScalarCalculatedColumnsMap.clear();
-        this.aggregatedScalarCalculatedColumnsMap = null;
+        this.aggregatedScalarLiveValuesMap.clear();
+        this.aggregatedScalarLiveValuesMap = null;
     }
     getCalculatedColumnDataType(calculatedColumnQuery) {
         try {
@@ -99,21 +99,21 @@ class CalculatedColumnExpressionService {
         // if query has neither a ScalarExpression nor an AggregatedScalarExpression => it can only be false
         return false;
     }
-    evaluateCalculatedColumnQuery(calculatedColumn, node) {
+    evaluateCalculatedColumnQuery(calculatedColumn, rowNode) {
         var _a, _b, _c, _d, _e;
         try {
-            if (this.adaptableApi.gridApi.isGroupRowNode(node)) {
+            if (this.adaptableApi.gridApi.isGroupRowNode(rowNode)) {
                 return undefined;
             }
             // no validation here, this function has to be as performant as possible
             if ((_a = calculatedColumn === null || calculatedColumn === void 0 ? void 0 : calculatedColumn.Query) === null || _a === void 0 ? void 0 : _a.ScalarExpression) {
                 return this.adaptableApi.internalApi
                     .getQueryLanguageService()
-                    .evaluateScalarExpression(calculatedColumn.Query.ScalarExpression, ModuleConstants_1.CalculatedColumnModuleId, node);
+                    .evaluateScalarExpression(calculatedColumn.Query.ScalarExpression, ModuleConstants_1.CalculatedColumnModuleId, rowNode);
             }
             if ((_b = calculatedColumn === null || calculatedColumn === void 0 ? void 0 : calculatedColumn.Query) === null || _b === void 0 ? void 0 : _b.AggregatedScalarExpression) {
-                const aggregatedScalarCalculatedColumn = this.aggregatedScalarCalculatedColumnsMap.get(calculatedColumn.Uuid);
-                return aggregatedScalarCalculatedColumn === null || aggregatedScalarCalculatedColumn === void 0 ? void 0 : aggregatedScalarCalculatedColumn.getAggregatedColumnValue(node);
+                const aggregatedScalarLiveValue = this.aggregatedScalarLiveValuesMap.get(calculatedColumn.Uuid);
+                return aggregatedScalarLiveValue === null || aggregatedScalarLiveValue === void 0 ? void 0 : aggregatedScalarLiveValue.getAggregatedValueForRow(rowNode);
             }
         }
         catch (error) {
@@ -121,149 +121,24 @@ class CalculatedColumnExpressionService {
             return null;
         }
     }
-    createAggregatedScalarCalculatedColumn(calculatedColumn) {
-        var _a, _b;
+    createAggregatedScalarLiveValue(calculatedColumn) {
+        var _a, _b, _c;
         // if there is already an aggregated scalar, delete it (possible when editing)
-        this.destroyAggregatedScalarCalculatedColumn(calculatedColumn);
+        this.destroyAggregatedScalarLiveValue(calculatedColumn);
         if ((_a = calculatedColumn.Query) === null || _a === void 0 ? void 0 : _a.AggregatedScalarExpression) {
             try {
-                const aggregatedScalarCalculatedColumn = new AggregatedScalarCalculatedColumn(calculatedColumn, this.adaptableApi);
-                this.aggregatedScalarCalculatedColumnsMap.set(calculatedColumn.Uuid, aggregatedScalarCalculatedColumn);
+                const aggregatedScalarLiveValue = new AggregatedScalarLiveValue_1.AggregatedScalarLiveValue({
+                    aggregatedScalarExpression: (_b = calculatedColumn.Query) === null || _b === void 0 ? void 0 : _b.AggregatedScalarExpression,
+                }, ModuleConstants_1.CalculatedColumnModuleId, this.adaptableApi);
+                this.aggregatedScalarLiveValuesMap.set(calculatedColumn.Uuid, aggregatedScalarLiveValue);
             }
             catch (e) {
-                LoggingHelper_1.LogAdaptableError(`Creating CalculatedColumn ('${(_b = calculatedColumn.Query) === null || _b === void 0 ? void 0 : _b.AggregatedScalarExpression}') failed!\n${e.message}`);
+                LoggingHelper_1.LogAdaptableError(`Creating CalculatedColumn ('${(_c = calculatedColumn.Query) === null || _c === void 0 ? void 0 : _c.AggregatedScalarExpression}') failed!\n${e.message}`);
             }
         }
     }
-    destroyAggregatedScalarCalculatedColumn(calculatedColumn) {
-        var _a;
-        (_a = this.aggregatedScalarCalculatedColumnsMap.get(calculatedColumn.Uuid)) === null || _a === void 0 ? void 0 : _a.destroy();
-        this.aggregatedScalarCalculatedColumnsMap.delete(calculatedColumn.Uuid);
+    destroyAggregatedScalarLiveValue(calculatedColumn) {
+        this.aggregatedScalarLiveValuesMap.delete(calculatedColumn.Uuid);
     }
 }
 exports.CalculatedColumnExpressionService = CalculatedColumnExpressionService;
-class AggregatedScalarCalculatedColumn {
-    constructor(calculatedColumn, adaptableApi) {
-        this.calculatedColumn = calculatedColumn;
-        this.adaptableApi = adaptableApi;
-        const aggregationConfig = this.adaptableApi.internalApi
-            .getQueryLanguageService()
-            .evaluateAggregatedScalarExpression(calculatedColumn.Query.AggregatedScalarExpression, ModuleConstants_1.CalculatedColumnModuleId);
-        this.expressionEvaluation = aggregationConfig.value;
-        this.aggregationResult = this.computeAggregatedValue(this.expressionEvaluation);
-        // currently we support only one reducer
-        this.aggregationReducerName = Object.keys(this.expressionEvaluation.aggregationParams.reducers)[0];
-    }
-    destroy() {
-        this.expressionEvaluation = null;
-        this.calculatedColumn = null;
-        this.adaptableApi = null;
-        this.aggregationResult = null;
-    }
-    getAggregatedColumnValue(rowNode) {
-        const aggregationValue = this.getAggregationValue(rowNode);
-        if (this.expressionEvaluation.rowValueGetter) {
-            return this.expressionEvaluation.rowValueGetter(rowNode, aggregationValue);
-        }
-        return aggregationValue;
-    }
-    refreshAggregatedColumnValue() {
-        const aggregationConfig = this.adaptableApi.internalApi
-            .getQueryLanguageService()
-            .evaluateAggregatedScalarExpression(this.calculatedColumn.Query.AggregatedScalarExpression, ModuleConstants_1.CalculatedColumnModuleId);
-        this.expressionEvaluation = aggregationConfig.value;
-        this.aggregationResult = this.computeAggregatedValue(this.expressionEvaluation);
-    }
-    getCalculatedColumnId() {
-        return this.calculatedColumn.ColumnId;
-    }
-    getColumnDependencies() {
-        return this.expressionEvaluation.columnDependencies;
-    }
-    computeAggregatedValue(expressionEvaluation) {
-        var _a;
-        const gridRowNodes = this.adaptableApi.gridApi.getAllRowNodes();
-        // we iterate over the RowNode list (we need this to handle complex column values (nested values, valueGetters etc)
-        // so we will map the fieldNames to RowNode.data
-        const mapReducerValueGetter = (fieldName) => {
-            return (rowNode) => {
-                return this.adaptableApi.gridApi.getRawValueFromRowNode(rowNode, fieldName);
-            };
-        };
-        Object.values(expressionEvaluation.aggregationParams.reducers).forEach((aggregationReducer) => {
-            aggregationReducer.getter = mapReducerValueGetter(aggregationReducer.field);
-            // nullify the field to force the fallback on the getter fn
-            aggregationReducer.field = null;
-        });
-        const mapGroupByToKey = (fieldName) => {
-            return (_unusableProperty, rowNode) => this.adaptableApi.gridApi.getRawValueFromRowNode(rowNode, fieldName);
-        };
-        (_a = expressionEvaluation.aggregationParams.groupBy) === null || _a === void 0 ? void 0 : _a.forEach((groupByDef) => {
-            groupByDef.toKey = mapGroupByToKey(groupByDef.field);
-        });
-        if (!expressionEvaluation.cumulateOver) {
-            let aggregatedRowNodes = gridRowNodes;
-            if (expressionEvaluation.sortByColumn) {
-                const sortByColumn = expressionEvaluation.sortByColumn;
-                const getRowNodeValue = (rowNode, columnId) => this.adaptableApi.gridApi.getRawValueFromRowNode(rowNode, columnId);
-                if (expressionEvaluation.filterUndefinedValues) {
-                    aggregatedRowNodes = gridRowNodes.filter((node) => {
-                        const rowValue = getRowNodeValue(node, sortByColumn);
-                        return rowValue != undefined;
-                    });
-                }
-                // currently, we support only ascending sorting
-                aggregatedRowNodes.sort((first, second) => {
-                    const firstValue = getRowNodeValue(first, sortByColumn);
-                    const secondValue = getRowNodeValue(second, sortByColumn);
-                    if (firstValue < secondValue) {
-                        return -1;
-                    }
-                    if (firstValue > secondValue) {
-                        return 1;
-                    }
-                    return 0;
-                });
-            }
-            return scalarAggregationHelper_1.aggregate(expressionEvaluation.aggregationParams, aggregatedRowNodes);
-        }
-        else {
-            // 1. sort grid data by given OVER column
-            const sortByColumn = expressionEvaluation.cumulateOver;
-            const getRowNodeValue = (rowNode, columnId) => this.adaptableApi.gridApi.getRawValueFromRowNode(rowNode, columnId);
-            // currently, we support only ascending sorting
-            gridRowNodes.sort((first, second) => {
-                const firstValue = getRowNodeValue(first, sortByColumn);
-                const secondValue = getRowNodeValue(second, sortByColumn);
-                if (firstValue < secondValue) {
-                    return -1;
-                }
-                if (firstValue > secondValue) {
-                    return 1;
-                }
-                return 0;
-            });
-            // 2. add primary key column as the most specific groupBy
-            if (!expressionEvaluation.aggregationParams.groupBy) {
-                expressionEvaluation.aggregationParams.groupBy = [];
-            }
-            const gridPrimaryKeyColumn = this.adaptableApi.internalApi.getAdaptableOptions().primaryKey;
-            // !! aggregationParams mutated
-            expressionEvaluation.aggregationParams.groupBy.push({
-                field: gridPrimaryKeyColumn,
-                toKey: mapGroupByToKey(gridPrimaryKeyColumn),
-            });
-            // 3. cumulate
-            return scalarAggregationHelper_1.cumulate(expressionEvaluation.aggregationParams, gridRowNodes);
-        }
-    }
-    getAggregationValue(rowNode) {
-        var _a, _b;
-        if ((_a = this.expressionEvaluation.aggregationParams.groupBy) === null || _a === void 0 ? void 0 : _a.length) {
-            const groupColumns = this.expressionEvaluation.aggregationParams.groupBy.map((groupByParam) => groupByParam.field);
-            const groupKeys = groupColumns.map((groupColumnName) => this.adaptableApi.gridApi.getRawValueFromRowNode(rowNode, groupColumnName));
-            return (_b = this.aggregationResult.deepMap.get(groupKeys)) === null || _b === void 0 ? void 0 : _b.reducerResults[this.aggregationReducerName];
-        }
-        return this.aggregationResult.reducerResults[this.aggregationReducerName];
-    }
-}

package/src/Utilities/Services/Interface/ICalculatedColumnExpressionService.d.ts

@@ -5,6 +5,6 @@ export interface ICalculatedColumnExpressionService extends IAdaptableService {
     isCalculatedColumnQueryValid(calculatedColumnQuery: AdaptableCalculatedColumnQuery): boolean;
     evaluateCalculatedColumnQuery(calculatedColumn: CalculatedColumn, rowNode: RowNode): any;
     getCalculatedColumnDataType(calculatedColumnQuery: AdaptableCalculatedColumnQuery): 'String' | 'Number' | 'Boolean' | 'Date';
-    createAggregatedScalarCalculatedColumn(calculatedColumn: CalculatedColumn): void;
-    destroyAggregatedScalarCalculatedColumn(calculatedColumn: CalculatedColumn): void;
+    createAggregatedScalarLiveValue(calculatedColumn: CalculatedColumn): void;
+    destroyAggregatedScalarLiveValue(calculatedColumn: CalculatedColumn): void;
 }

package/src/Utilities/Services/Interface/IQueryLanguageService.d.ts

@@ -3,14 +3,15 @@ import { IAdaptableService } from './IAdaptableService';
 import { RowNode } from '@ag-grid-community/all-modules';
 import { CellDataChangedInfo } from '../../../PredefinedConfig/Common/CellDataChangedInfo';
 import { AdaptableModule } from '../../../PredefinedConfig/Common/Types';
-import { AggregationParameter } from '../../ExpressionFunctions/aggregatedScalarExpressionFunctions';
+import { ScalarAggregationParameter } from '../../ExpressionFunctions/aggregatedScalarExpressionFunctions';
 import { ModuleExpressionFunctions } from '../../../AdaptableOptions/AdaptableQLOptions';
+import { BooleanAggregationParameter } from '../../ExpressionFunctions/aggregatedBooleanExpressionFunctions';
 export interface IQueryLanguageService extends IAdaptableService {
     evaluateBooleanExpression(expression: string, module: AdaptableModule, rowNode: RowNode): boolean;
     evaluateScalarExpression(expression: string, module: AdaptableModule, rowNode: RowNode): any;
     evaluateObservableExpression(expression: string, module: AdaptableModule): Observable<CellDataChangedInfo>;
-    evaluateAggregatedBooleanExpression(expression: string, module: AdaptableModule): Observable<CellDataChangedInfo>;
-    evaluateAggregatedScalarExpression(expression: string, module: AdaptableModule): AggregationParameter;
+    evaluateAggregatedBooleanExpression(expression: string, module: AdaptableModule): BooleanAggregationParameter;
+    evaluateAggregatedScalarExpression(expression: string, module: AdaptableModule): ScalarAggregationParameter;
     validateBoolean(expression: string, module: AdaptableModule, config?: {
         force?: boolean;
     }): {
@@ -29,7 +30,9 @@ export interface IQueryLanguageService extends IAdaptableService {
         isValid: boolean;
         errorMessage: string;
     };
+    computeAggregatedBooleanValue(expression: string, module: AdaptableModule): boolean;
     getModuleExpressionFunctions(module: AdaptableModule): ModuleExpressionFunctions;
     getColumnsFromExpression(input: string): string[];
     getNamedQueryNamesFromExpression(input: string): string[];
+    isCumulativeAggregate(input: string): boolean;
 }

package/src/Utilities/Services/QueryLanguageService.d.ts

@@ -4,8 +4,9 @@ import { CellDataChangedInfo } from '../../PredefinedConfig/Common/CellDataChang
 import { RowNode } from '@ag-grid-community/all-modules';
 import { AdaptableModule } from '../../PredefinedConfig/Common/Types';
 import { ModuleExpressionFunctions } from '../../AdaptableOptions/AdaptableQLOptions';
-import { AggregationParameter } from '../ExpressionFunctions/aggregatedScalarExpressionFunctions';
+import { ScalarAggregationParameter } from '../ExpressionFunctions/aggregatedScalarExpressionFunctions';
 import { AdaptableApi } from '../../../types';
+import { BooleanAggregationParameter } from '../ExpressionFunctions/aggregatedBooleanExpressionFunctions';
 export declare class QueryLanguageService implements IQueryLanguageService {
     private adaptableApi;
     private cacheBooleanValidation;
@@ -16,9 +17,9 @@ export declare class QueryLanguageService implements IQueryLanguageService {
     constructor(adaptableApi: AdaptableApi);
     evaluateBooleanExpression(expression: string, module: AdaptableModule, rowNode: any): any;
     evaluateScalarExpression(expression: string, module: AdaptableModule, rowNode: RowNode): any;
-    evaluateAggregatedScalarExpression(expression: string, module: AdaptableModule): AggregationParameter;
+    evaluateAggregatedScalarExpression(expression: string, module: AdaptableModule): ScalarAggregationParameter;
     evaluateObservableExpression(reactiveExpression: string, module: AdaptableModule): Observable<CellDataChangedInfo>;
-    evaluateAggregatedBooleanExpression(aggregationExpression: string, module: AdaptableModule): Observable<CellDataChangedInfo>;
+    evaluateAggregatedBooleanExpression(aggregationExpression: string, module: AdaptableModule): BooleanAggregationParameter;
     validateBoolean(expressionInput: string, module: AdaptableModule, config?: {
         force?: boolean;
     }): {
@@ -37,8 +38,10 @@ export declare class QueryLanguageService implements IQueryLanguageService {
         isValid: boolean;
         errorMessage: string;
     };
+    computeAggregatedBooleanValue(expression: string, module: AdaptableModule): boolean;
     getColumnsFromExpression(input?: string): string[];
     getNamedQueryNamesFromExpression(input?: string): string[];
+    isCumulativeAggregate(input: string): boolean;
     getModuleExpressionFunctions(module: AdaptableModule): ModuleExpressionFunctions;
     destroy(): void;
     private getBooleanAndScalarFunctions;

package/src/Utilities/Services/QueryLanguageService.js

@@ -5,6 +5,7 @@ const tslib_1 = require("tslib");
 const parser = tslib_1.__importStar(require("../../parser/src"));
 const rxjs_1 = require("rxjs");
 const LoggingHelper_1 = require("../Helpers/LoggingHelper");
+const AggregatedScalarLiveValue_1 = require("./AggregatedScalarLiveValue");
 class QueryLanguageService {
     constructor(adaptableApi) {
         this.adaptableApi = adaptableApi;
@@ -49,13 +50,13 @@ class QueryLanguageService {
     evaluateAggregatedBooleanExpression(aggregationExpression, module) {
         const moduleExpressionFunctions = this.getModuleExpressionFunctions(module);
         const booleanAndScalarFunctions = this.getBooleanAndScalarFunctions(moduleExpressionFunctions);
-        const aggregationExpression$ = parser.evaluate(aggregationExpression, {
+        const aggregationEvaluation = parser.evaluate(aggregationExpression, {
             node: aggregationExpression,
             adaptableApi: this.adaptableApi,
             functions: moduleExpressionFunctions.aggregatedBooleanFunctions,
             whereClauseFunctions: booleanAndScalarFunctions,
         });
-        return aggregationExpression$;
+        return aggregationEvaluation;
     }
     validateBoolean(expressionInput = '', module, config = { force: false }) {
         var _a;
@@ -170,15 +171,16 @@ class QueryLanguageService {
             return result;
         }
         try {
-            const aggregatedBooleanExpressionEvaluation = this.evaluateAggregatedBooleanExpression(expression, module);
-            if (!rxjs_1.isObservable(aggregatedBooleanExpressionEvaluation)) {
+            const evaluationResult = this.evaluateAggregatedBooleanExpression(expression, module);
+            if (evaluationResult.type !== 'aggregationBoolean') {
                 const result = {
                     isValid: false,
-                    errorMessage: `provided AggregatedBoolean expression does not evaluate to an Observable`,
+                    errorMessage: 'provided AggregatedBBoolean expression does not evaluate to a supported aggregation',
                 };
                 this.cacheAggregatedBooleanValidation.set(cacheKey, result);
                 return result;
             }
+            // no exception,so everything seems to be fine
             const result = { isValid: true, errorMessage: '' };
             this.cacheAggregatedBooleanValidation.set(cacheKey, result);
             return result;
@@ -208,7 +210,7 @@ class QueryLanguageService {
         }
         try {
             const evaluationResult = this.evaluateAggregatedScalarExpression(expression, module);
-            if (evaluationResult.type !== 'aggregation') {
+            if (evaluationResult.type !== 'aggregationScalar') {
                 const result = {
                     isValid: false,
                     errorMessage: 'provided AggregatedScalar expression does not evaluate to a supported aggregation',
@@ -230,12 +232,27 @@ class QueryLanguageService {
             return result;
         }
     }
+    computeAggregatedBooleanValue(expression, module) {
+        const booleanAggregationParameter = this.evaluateAggregatedBooleanExpression(expression, module);
+        const aggregatedScalarExpressionEvaluation = booleanAggregationParameter.scalarAggregation.value;
+        const aggregatedScalarLiveValue = new AggregatedScalarLiveValue_1.AggregatedScalarLiveValue({ aggregatedScalarExpressionEvaluation }, module, this.adaptableApi);
+        const allAggregationValues = aggregatedScalarLiveValue.getAllAggregationValues();
+        const numericOperand = booleanAggregationParameter.conditionValue;
+        const booleanConditionFn = booleanAggregationParameter.conditionFn;
+        return allAggregationValues.some((aggregationValue) => {
+            return booleanConditionFn(aggregationValue, numericOperand);
+        });
+    }
     getColumnsFromExpression(input = '') {
         return this.getNodesFromExpression(input, 'COL');
     }
     getNamedQueryNamesFromExpression(input = '') {
         return this.getNodesFromExpression(input, 'QUERY');
     }
+    isCumulativeAggregate(input) {
+        var _a;
+        return !!((_a = this.getNodesFromExpression(input, 'CUMUL')) === null || _a === void 0 ? void 0 : _a.length);
+    }
     // Returns the ExpressionFunctions available for the given Module as specified in the `QueryLanguageOptions.moduleExpressionFunctions`
     // if there are no specific functions defined, it falls back to the default values
     getModuleExpressionFunctions(module) {